jade-lang 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1bbeb934a5bbbeb19cfeddeb18f59798c37380a34d514110f42e07dab206525
-  data.tar.gz: 1f68a227a953fa57f875274f409bf93aa7269bbadfc4b3abc7634ea1d6b283c2
+  metadata.gz: 0e1034e93db617cde9f33aad318dc23a4bf4987f9f0243558434f14ed64feca8
+  data.tar.gz: f1e067ee109d4db4b7ac9a94664d2d69b92e1df10ccdbf31260958c23827e8d8
 SHA512:
-  metadata.gz: 87f7c7e84b193ee2dba6e989f493ca36cf4bc6a58ba7d4c38519aedf5052908263cea802e917b11555396edce72c1ae4af5ff687676f13e123d37858c9643e8f
-  data.tar.gz: 0d2f3e20d4e1863a567310355a04bc7eb0fb73c49b629db3f0f6162ce2a009ddf821420558962e35052f0a5859d035b196483ead990659f0c73700ad97b4abfb
+  metadata.gz: 69fb033248f3950561b72732f70b51e2b7ed0e32aeffdab821c86a112a767e3b01dacccfda561467c312958b0f068be132421798d59551c6a0d28f3ddde06f67
+  data.tar.gz: 612d3fa844be6d1fa368679d1af12eb77f59a18175e84a906f29dd47405e7d6ef6002975dde83ffc291973eec3ca1cdad1c061755e89ba158a88eb369e3b8e93

data/CHANGELOG.md

@@ -6,6 +6,104 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.7.0]
+
+### Added
+
+- **`^Ctor` — the constructor, curried.** `Decode.succeed(Spec(_, _, _, _))`
+  opens an applicative decode pipeline, and those underscores are coupled to
+  the struct's arity: add a field and every pipeline needs another one,
+  reported as a type mismatch at the pipeline rather than at the struct.
+  `^Spec` desugars to exactly the same curried lambda, with the arity read off
+  the resolved constructor. Works on variants as well as structs.
+
+### Fixed
+
+- **A constraint on a compound type holding a free var gets its dictionary.**
+  A polymorphic function whose body needed something like
+  `Decodable(List(a))`, `Decodable(Maybe(a))`, or `Decodable({ value: a })`
+  crashed codegen with `undefined method 'map' for nil` — no span, no message.
+  The derived instance depends on `Decodable(a)`, but only *bare* var
+  constraints earn a dict param, so the enclosing function took none and the
+  dep had nothing to bind to. Those deps are now surfaced as constraints of
+  their own, so the function takes the dict and callers pass their witness
+  down. Should a dep still find no dict in scope, codegen now fails naming the
+  constraint instead of handing `nil` on to the pretty-printer.
+- **The `Encodable` deriver keeps its free-var deps.** The mirror of the above,
+  and quieter: `Encodable(List(a))` with `a` free dropped the derivation
+  outright, and `Encode.encode(items)` compiled to Ruby referencing an
+  `impl_arg` that was never bound — a `NameError` at run time, no compile-time
+  complaint. The deriver now falls back to the constraint marker for a free
+  var, the way `Decodable` already did.
+- **A witness reaches a callee declared later in the file.** A polymorphic
+  function calling a polymorphic function declared below it lost the interface
+  witness — the call type-checked, then died at run time missing a dictionary
+  argument. Moving the callee above the caller fixed it, which is what made
+  this look like it was about lambdas. The collecting pass walks declarations
+  in source order, so the callee's constraints weren't known yet; it now
+  repeats until the constraint sets stop growing.
+- **Anonymous records of the same shape compare equal across modules.** Each
+  module hoisted its own class per record shape, so `{ x: 1 }` built in one
+  module compared false against the same record built in another — both have
+  type `{ x: Int }`, and it type-checks fine, so nothing warned you. A record
+  decoded at a port boundary compared false against either. Shapes now resolve
+  through the interned `Jade::Runtime.record` registry, named under
+  `Jade::Records` so they don't inspect as belonging to whichever module
+  happened to assign one first.
+- **`struct Probe` in `module Probe` loads.** It type-checked clean and died at
+  Ruby load with `uninitialized constant Probe::Probe::Probe` — the emitter
+  wrote an unrooted `Probe::Probe[n]` from inside `module Probe`, while the
+  boundary decoder three lines below already wrote `::Probe::Probe`. Unions
+  escaped it because their generated constants are the variants. All three
+  unrooted sites are now rooted.
+- **`Eq` on a variant-less union is native equality.** A union with no variants
+  represents an opaque native (`Decode.Value`, `List`), and the derived `Eq`
+  was one case branch per variant plus a `_ then false` fallthrough — with no
+  variants, the fallthrough was the whole function and `x == x` answered false,
+  no warning, no type error.
+
+### Changed
+
+- Generated output moves for any code that names a constructor or builds an
+  anonymous record. A project that CI-checks committed artifacts will see a
+  diff.
+
+## [0.6.0]
+
+### Fixed
+
+- **A `Maybe` return encodes its element.** A function returning `Maybe(T)`
+  handed Ruby the internal `Data` object whenever `T` was a union, or a struct
+  holding one — no error, just an un-encoded value across the boundary. The
+  specialized encoder fell back to emitting the raw element when it couldn't
+  specialize it, instead of declining so the generic encoder could take over;
+  `decode`, five lines above it, already declined correctly. `Maybe(Int)` and
+  `Maybe(SomeStruct)` were unaffected, which is why it stayed hidden — identity
+  happens to be right for primitives. Both derived and hand-written
+  `Encodable` instances are now applied, and a `Maybe` field of a struct
+  unwraps the same way a `Maybe` return does.
+- **Boundary decode errors name the right side.** `DecodeError` reported
+  "Port returned a value that failed to decode" for every failure, including
+  values Ruby passed *into* an exposed function, where no port is involved —
+  sending you to look for a `uses` block that may not exist. Argument failures
+  now read "Ruby passed a value that failed to decode"; port returns are
+  unchanged.
+- **A symbol-keyed Hash says so.** Structs cross the boundary as a Hash with
+  string keys, so `Person.birthday(name: "Ada", age: 40)` used to fail with
+  `expected String, got null` — each field independently reading `nil`, naming
+  neither the cause nor the fix. It is now caught where the whole hash is in
+  scope, listing the offending keys and the correction. Hashes mixing string
+  and symbol keys are left alone; that is a real shape mismatch, and the
+  per-field errors describe it better than a guess would.
+- **A module declared under the wrong file name is now a compile error.** A
+  module is keyed by the name its file implies — imports resolve `Shop.Cart`
+  to `shop/cart.jd` and back — but nothing checked that against what the file
+  declared. `module Cart` in `orders.jd` compiled clean and emitted a `Cart`
+  module whose own type references pointed at `Orders`, so the first call
+  raised `NameError: uninitialized constant Cart::Internal::Orders` far from
+  the cause. It now fails at compile time, pointing at the declared name and
+  offering both the rename and the move.
+
 ## [0.5.0]
 
 ### Added
@@ -328,7 +426,9 @@ Initial release.
 - `jade` CLI dispatcher: `fmt`, `lsp`, `q`.
 - Language server and headless query interface for editor/agent tooling.
 
-[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/agustinrhcp/jade/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/agustinrhcp/jade/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/agustinrhcp/jade/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/agustinrhcp/jade/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/agustinrhcp/jade/compare/v0.2.0...v0.3.0

data/docs/syntax.md

@@ -266,6 +266,10 @@ Lambdas are `(params) -> { body }` — the one construct that uses braces.
 A `_` in an argument position curries the call: each `_` becomes a parameter,
 left to right, so `add(_, 5)` is a one-argument function.
 
+`^Ctor` is the constructor with every field curried — `^Point` is
+`Point(_, _)` without counting the fields, and stays right when the struct
+gains one.
+
 ```jade
 module Curry exposing (add_five, add_one)
 

data/lib/jade/ast.rb

@@ -20,6 +20,7 @@ module Jade
     define(:Bind, :pattern, :expression)
     define(:VariableReference, :name)
     define(:ConstructorReference, :name)
+    define(:CurriedConstructor, :name)
 
     define(:Module, :name, :exposing, :body)
     define(:Body, :expressions)
@@ -155,6 +156,15 @@ module Jade
       end
     end
 
+    def curried_constructor
+      ->(constant) do
+        CurriedConstructor[
+          constant.value,
+          constant.range,
+        ]
+      end
+    end
+
     def body
       ->(expressions) do
         if expressions.empty?

data/lib/jade/codegen/boundary/cache.rb

@@ -36,8 +36,7 @@ module Jade
               Boundary::Specialized.decode_expr(t, '_', registry)
             },
             encoders: cache_map(per_fn.flat_map { it[:encoders] }, 'ENC') { |t|
-              Boundary::Specialized.identity_encoder?(t) ||
-                Boundary::Specialized.encode_expr(t, '_', registry)
+              Boundary::Specialized.encode_expr(t, '_', registry)
             },
           }
         end

data/lib/jade/codegen/boundary/specialized/list.rb

@@ -19,11 +19,16 @@ module Jade
           end
 
           def encode(type, value_expr, registry)
-            inner = inner_of(type) or return nil
-            return nil if Specialized.identity_encoder?(inner)
+            inner_of(type)
+              &.then { Specialized.encode_expr(it, '_1', registry) }
+              &.then { map_expr(it, value_expr) }
+          end
 
-            elem = Specialized.encode_expr(inner, '_1', registry) or return nil
-            "#{value_expr}.map { #{elem} }"
+          def map_expr(elem, value_expr)
+            case elem
+            in ::String then "#{value_expr}.map { #{elem} }"
+            in :identity then nil
+            end
           end
 
           def identity_encoder?(type)

data/lib/jade/codegen/boundary/specialized/maybe.rb

@@ -17,10 +17,22 @@ module Jade
           end
 
           def encode(type, value_expr, registry)
-            inner = inner_of(type) or return nil
-            inner_enc = Specialized.encode_expr(inner, 'it._1', registry) || 'it._1'
+            inner_of(type)
+              &.then { element_encoder(it, registry) }
+              &.then { unwrap_expr(it, value_expr) }
+          end
+
+          def unwrap_expr(elem, value_expr)
+            "#{value_expr}.then { it.is_a?(::Jade::Maybe::Just) ? #{elem} : nil }"
+          end
 
-            "#{value_expr}.then { it.is_a?(::Jade::Maybe::Just) ? #{inner_enc} : nil }"
+          # Never identity even when the element is: the Just still unwraps.
+          def element_encoder(inner, registry)
+            case Specialized.encode_expr(inner, 'it._1', registry)
+            in :identity then 'it._1'
+            in ::String => expr then expr
+            in nil then nil
+            end
           end
 
           def specializable?(type, registry, seen)

data/lib/jade/codegen/boundary/specialized/record.rb

@@ -138,7 +138,7 @@ module Jade
 
           def encode_helper(struct, registry)
             struct.record_type.fields
-              .map { |k, t| "#{k.inspect} => #{field_encode_value(t, "p.#{k}", registry)}" }
+              .map { |k, t| "#{k.inspect} => #{field_encode(k, t, "p.#{k}", registry)}" }
               .then { "{ #{it.join(', ')} }" }
               .then { Pretty.block("def self.#{encode_helper_name(struct)}(p)", it) }
           end
@@ -148,8 +148,12 @@ module Jade
               fail("non-specializable field type for #{key}: #{type}")
           end
 
-          def field_encode_value(type, accessor, registry)
-            Specialized.encode_expr(type, accessor, registry) || accessor
+          def field_encode(key, type, accessor, registry)
+            case Specialized.encode_expr(type, accessor, registry)
+            in :identity then accessor
+            in ::String => expr then expr
+            in nil then fail("non-encodable field type for #{key}: #{type}")
+            end
           end
 
           def snake(name)

data/lib/jade/codegen/boundary/specialized.rb

@@ -28,10 +28,14 @@ module Jade
             Record.decode(type, input, registry)
         end
 
-        # Ruby expression that encodes `value_expr` to the wire form, or
-        # `nil` if the encoder is identity (caller skips the wrap) or the
-        # type isn't specializable (caller falls back to the cache).
+        # How to encode `value_expr` to the wire form:
+        #
+        #   String    inline expression
+        #   :identity the value is already wire-shaped; emit it unchanged
+        #   nil       not specializable; fall back to the cached encoder
         def encode_expr(type, value_expr, registry)
+          return :identity if identity_encoder?(type)
+
           Record.encode(type, value_expr, registry) ||
             List.encode(type, value_expr, registry) ||
             Maybe.encode(type, value_expr, registry)

data/lib/jade/codegen/boundary.rb

@@ -160,7 +160,7 @@ module Jade
         in Ok[impl] then Codegen::FunctionCall.generate_impl_dispatch(impl, registry)
         in Err      then nil
         end
-      rescue NoMethodError, NoMatchingPatternError
+      rescue MissingDictionary, NoMethodError, NoMatchingPatternError
         # Deriver assumes derivability (type-check-time invariant); boundary
         # synthesis may probe types whose deps fail — treat as ineligible.
         nil

data/lib/jade/codegen/constructor_reference.rb

@@ -10,7 +10,7 @@ module Jade
       end
 
       def from_symbol(symbol)
-        qualified = to_qualified(symbol.qualified_name)
+        qualified = "::#{to_qualified(symbol.qualified_name)}"
         symbol.args.empty? ? "#{qualified}[]" : "#{qualified}.method(:[])"
       end
     end

data/lib/jade/codegen/emitter.rb

@@ -17,6 +17,9 @@ module Jade
         in [:and, expr1, expr2]
           "#{emit(expr1)} && #{emit(expr2)}"
 
+        in [:==, expr1, expr2]
+          "#{emit(expr1)} == #{emit(expr2)}"
+
         in Integer | TrueClass | FalseClass | Float
           ir.to_s
 

data/lib/jade/codegen/error.rb

@@ -0,0 +1,8 @@
+module Jade
+  module Codegen
+    # Codegen runs on a program the frontend already proved well-typed, so
+    # this is a bug in jade, not in the source. RuntimeError so the CLI
+    # reports it as a message rather than a backtrace.
+    MissingDictionary = Class.new(RuntimeError)
+  end
+end

data/lib/jade/codegen/function_call.rb

@@ -26,7 +26,7 @@ module Jade
 
       def constructor_call(callee, args, registry)
         resolve_callee_symbol(callee, registry)
-          .then { to_qualified(it.qualified_name) }
+          .then { "::#{to_qualified(it.qualified_name)}" }
           .then { "#{it}[#{generate_many(args, registry)}]" }
       end
 
@@ -89,8 +89,10 @@ module Jade
         in Symbol::Implementation
           generate_impl_dispatch(dep, registry)
 
-        in Type::Constraint(type: Type::Var)
-          dispatch_value(dep, registry)
+        in Type::Constraint(interface:, type: Type::Var => var)
+          dispatch_value(dep, registry) ||
+            raise(MissingDictionary, "no dict in scope for #{interface} #{var}" \
+                                    " — this is a jade bug, please report it")
         end
       end
 
@@ -151,7 +153,7 @@ module Jade
       end
 
       def generate_keyed_variant_call(constructor, args, registry)
-        qualified = to_qualified(constructor.qualified_name)
+        qualified = "::#{to_qualified(constructor.qualified_name)}"
         record_fields = constructor.args[0].fields.keys
 
         args[0] => arg

data/lib/jade/codegen/function_declaration.rb

@@ -80,14 +80,15 @@ module Jade
       end
 
       def encode_return(return_type, call_expr, registry)
-        if Codegen::Boundary::Specialized.identity_encoder?(return_type)
-          call_expr
-        elsif (expr = Codegen::Boundary::Specialized.encode_expr(return_type, call_expr, registry))
-          expr
-        else
+        case Codegen::Boundary::Specialized.encode_expr(return_type, call_expr, registry)
+        in :identity then call_expr
+
+        in ::String => expr then expr
+
+        in nil
           Codegen::Boundary::Cache
             .encoder_for(return_type, registry)
-            .then { |encoder| "#{encoder}.call(#{call_expr})" }
+            .then { "#{it}.call(#{call_expr})" }
         end
       end
 

data/lib/jade/codegen.rb

@@ -1,3 +1,4 @@
+require 'jade/codegen/error'
 require 'jade/codegen/context'
 require 'jade/codegen/helpers'
 require 'jade/codegen/pretty'
@@ -91,7 +92,7 @@ module Jade
         shape_consts = collect_record_shapes(body)
           .sort
           .map { |keys|
-            "#{record_shape_constant(keys)} = Data.define(#{keys.map { ":#{it}" }.join(', ')})"
+            "#{record_shape_constant(keys)} = #{record_class(keys)}"
           }
 
         boundary_cache   = Boundary::Cache.collect(body, registry)

data/lib/jade/formatter/helper.rb

@@ -59,6 +59,7 @@ module Jade
         in AST::RecordUpdate                 then RecordUpdate
         in AST::VariableReference            then VariableReference
         in AST::ConstructorReference         then ConstructorReference
+        in AST::CurriedConstructor           then CurriedConstructor
         in AST::CharLiteral                  then CharLiteral
         in AST::Literal                      then Literal
         end

data/lib/jade/formatter/leaves.rb

@@ -21,6 +21,15 @@ module Jade
       end
     end
 
+    module CurriedConstructor
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "^#{node.name}".then(&and_indent(indent))
+      end
+    end
+
     module CharLiteral
       extend self
       extend Helper

data/lib/jade/frontend/desugaring/resolved.rb

@@ -2,6 +2,7 @@ module Jade
   module Frontend
     module Desugaring
       extend self
+      extend Codegen::Helpers
 
       # Runs after SemanticAnalysis (which resolves names and attaches
       # symbols). Add new post-resolution rewrites as `in` branches
@@ -13,6 +14,9 @@ module Jade
 
       def desugar_resolved(node, registry)
         case node
+        in AST::CurriedConstructor
+          curry_constructor(node, registry)
+
         in AST::VariableReference | AST::QualifiedAccess
           zero_arg_fn?(node.symbol, registry) ? wrap_call(node) : node
 
@@ -23,6 +27,37 @@ module Jade
 
       private
 
+      # `^C` is `C(_, _, …)` with the arity filled in — which needs the
+      # resolved symbol, so it cannot be done at parse time.
+      def curry_constructor(node, registry)
+        arity = registry.lookup(node.symbol)&.args&.length || 0
+        names = (0...arity).map { param_synthetic_name(it) }
+
+        AST::FunctionCall
+          .new(
+            callee: AST::ConstructorReference[node.name, node.range].with(symbol: node.symbol),
+            args: names.map { AST::VariableReference[it, node.range].with(symbol: Symbol.var(it, nil)) },
+            infix: false,
+            dictionaries: [],
+            range: node.range,
+            symbol: nil,
+            id: node.id,
+            leading_comments: node.leading_comments,
+            trailing_comments: node.trailing_comments,
+            dangling_comments: node.dangling_comments,
+            trailing_comma: false,
+          )
+          .then do |call|
+            names.reverse.reduce(call) do |body, name|
+              AST::Lambda[
+                [AST::Pattern::Binding[name, node.range]],
+                AST::Body[[body], node.range],
+                node.range,
+              ]
+            end
+          end
+      end
+
       def map_children(node)
         node
           .to_h

data/lib/jade/frontend/desugaring.rb

@@ -175,7 +175,8 @@ module Jade
           AST::TypeDeclaration | AST::ImportDeclaration |
           AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard |
           AST::Pattern::Record | AST::InteropImportDeclaration | AST::StructDeclaration |
-          AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration
+          AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration |
+          AST::CurriedConstructor
 
           node
         end

data/lib/jade/frontend/fixity_fixer.rb

@@ -147,6 +147,7 @@ module Jade
         in AST::VariableReference | AST::ConstructorReference | AST::TypeDeclaration |
           AST::ImportDeclaration | AST::Literal | AST::CharLiteral | AST::RecordAccessSugar | AST::InteropImportDeclaration |
           AST::StructDeclaration | AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration |
+          AST::CurriedConstructor |
           AST::RecordUpdateSugar
 
           node

data/lib/jade/frontend/semantic_analysis/constructor_reference.rb

@@ -6,7 +6,7 @@ module Jade
         extend Helper
 
         def analyze(node, registry, scope, entry)
-          node => AST::ConstructorReference(name:)
+          name = node.name
 
           symbol = scope.lookup(name) || resolve_private_constructor(name, registry)
 

data/lib/jade/frontend/semantic_analysis.rb

@@ -76,7 +76,7 @@ module Jade
         in AST::CharLiteral then CharLiteral
         in AST::Assign then Assign
         in AST::VariableReference then VariableReference
-        in AST::ConstructorReference then ConstructorReference
+        in AST::ConstructorReference | AST::CurriedConstructor then ConstructorReference
         in AST::Body then Body
         in AST::FunctionDeclaration then FunctionDeclaration
         in AST::FunctionCall then FunctionCall

data/lib/jade/frontend/type_checking/constraints/deriving/decodable.rb

@@ -74,7 +74,7 @@ module Jade
 
               inner_types
                 .map { Type.constraint(INTERFACE, it, nil) }
-                .map { resolve_dep(it, lookup, entry_name) }
+                .map { resolve_dep(it, lookup) }
                 .then { Results.sequence(it) }
                 .map { implementation(constraint, body, it) }
             end
@@ -99,7 +99,7 @@ module Jade
               end
 
               field_deps
-                .map { resolve_dep(it, lookup, entry_name) }
+                .map { resolve_dep(it, lookup) }
                 .then { Results.sequence(it) }
                 .map { implementation(constraint, record_body(fields, constructor_ref), it) }
             end
@@ -131,18 +131,6 @@ module Jade
               ]
             end
 
-            # Free-var inner constraints fall back to the constraint marker
-            # itself — codegen later resolves it from the caller's dict env.
-            # Without this, `Decodable(List(a))` with `a` free would bail
-            # with UnresolvedConstraint.
-            def resolve_dep(dep, lookup, entry_name)
-              lookup
-                .call(dep)
-                .on_err(Error::UnresolvedConstraint) {
-                  dep.type.is_a?(Type::Var) ? Ok[dep] : Err[it]
-                }
-            end
-
             def implementation(constraint, body, deps)
               decoder_fn = Symbol::DerivedFunction.new(params: [], body:)
 

data/lib/jade/frontend/type_checking/constraints/deriving/encodable.rb

@@ -73,7 +73,7 @@ module Jade
 
               inner_types
                 .map { Type.constraint(INTERFACE, it, nil) }
-                .map { lookup.call(it) }
+                .map { resolve_dep(it, lookup) }
                 .then { Results.sequence(it) }
                 .map { implementation(constraint, params: [param], body:, deps: it) }
             end
@@ -111,7 +111,7 @@ module Jade
                 .then { [:hash, it] }
 
               field_deps
-                .map { lookup.call(it) }
+                .map { resolve_dep(it, lookup) }
                 .then { Results.sequence(it) }
                 .map { implementation(constraint, params: ['rec'], body:, deps: it) }
             end

data/lib/jade/frontend/type_checking/constraints/deriving/eq.rb

@@ -22,6 +22,8 @@ module Jade
               index_map = type_vars.each_with_index.map.to_h
               variants  = symbol.variants.map { registry.lookup(it) }
 
+              return native_eq(constraint, type_vars) if variants.empty?
+
               concrete = variants
                 .flat_map(&:args)
                 .reject { it in Symbol::Variable }
@@ -49,6 +51,14 @@ module Jade
                 end
             end
 
+            # A variant-less union stands in for an opaque native — `Decode.Value`,
+            # `List` — so there is nothing to match on and equality is Ruby's.
+            def native_eq(constraint, type_vars)
+              Symbol::DerivedFunction
+                .new(params: ["one", "other"], body: [:==, [:var, "one"], [:var, "other"]])
+                .then { Ok[build_union_impl(constraint, type_vars, [], it, [])] }
+            end
+
             def build_union_impl(constraint, type_vars, concrete, eq_fn, deps)
               return implementation(constraint, { '(==)' => eq_fn }, deps:) if type_vars.empty?
 

data/lib/jade/frontend/type_checking/constraints/deriving/helpers.rb

@@ -54,6 +54,16 @@ module Jade
               )
             end
 
+            # A free-var inner constraint falls back to the marker itself —
+            # codegen resolves it from the caller's dict env.
+            def resolve_dep(dep, lookup)
+              lookup
+                .call(dep)
+                .on_err(Error::UnresolvedConstraint) {
+                  dep.type.is_a?(Type::Var) ? Ok[dep] : Err[it]
+                }
+            end
+
             def resolve_field_deps(field_types, lookup, origin)
               field_types
                 .map { lookup.call(Type.constraint(self::INTERFACE, it, origin)) }

data/lib/jade/frontend/type_checking/inference/function_call.rb

@@ -57,7 +57,7 @@ module Jade
                 .map { st.env.substitution.apply(it) }
 
               propagated = (callee_subst + args_subst)
-                .select { it.type.is_a?(Type::Var) }
+                .flat_map { propagate(it, registry, st.env.entry_name) }
 
               # Pass 1 still needs propagation so constraints from inner calls
               # bubble up through outer constructor calls and reach the function
@@ -71,10 +71,13 @@ module Jade
               # "use the enclosing function's local dict".
               callee_errors = callee_subst
                 .flat_map do |c|
-                  case c.type
-                  in Type::Var
+                  case c
+                  in Type::Constraint(index: :unindex) then []
+
+                  in Type::Constraint(type: Type::Var)
                     Constraints.attach_dictionary(c, c)
                     []
+
                   else
                     Constraints.solve_at_call_site(c, registry, st.env.entry_name)
                   end
@@ -87,10 +90,13 @@ module Jade
               # resolve via the enclosing function's dict_env.
               args_errors = args_subst
                 .flat_map do |c|
-                  case c.type
-                  in Type::Var
+                  case c
+                  in Type::Constraint(index: :unindex) then []
+
+                  in Type::Constraint(type: Type::Var)
                     Constraints.attach_dictionary(c, c)
                     []
+
                   else
                     Constraints.solve_at_call_site(c, registry, st.env.entry_name)
                   end
@@ -104,6 +110,28 @@ module Jade
 
           private
 
+          # Only bare-var constraints earn a dict param, so a constraint that
+          # still holds free vars (`Decodable(List(a))`) surfaces its deps as
+          # markers of their own — unindexed, since they occupy no slot in
+          # this call's dictionary list.
+          def propagate(constraint, registry, entry_name)
+            return [constraint] if constraint.type.is_a?(Type::Var)
+            return [] if constraint.unbound_vars.empty?
+
+            Constraints
+              .resolve(constraint, registry, entry_name)
+              .map { var_markers(it) }
+              .with_default([])
+          end
+
+          def var_markers(dep)
+            case dep
+            in Symbol::Implementation(deps:) then deps.flat_map { var_markers(it) }
+            in Type::Constraint(type: Type::Var) then [dep.with(origin: nil, index: :unindex)]
+            else []
+            end
+          end
+
           def unify_callee(state, callee_result, args_acc, node, outer)
             return_type = state.fresh
             fn_type = Type.function(args_acc.types, return_type)

data/lib/jade/frontend/type_checking/inference/function_declaration.rb

@@ -42,11 +42,11 @@ module Jade
                 )
               end
               .then do |st|
-                next st if st.env.bindings[symbol.qualified_name].is_a?(Scheme)
+                next st if st.env.bindings[symbol.qualified_name].is_a?(Scheme) && !st.skip_constraints
 
                 updated_constraints = (fn_constraints + body_result.constraints)
                   .map { st.env.substitution.apply(it) }
-                  .uniq
+                  .uniq { it.type.is_a?(Type::Var) ? [it.interface, it.type] : it }
 
                 # TODO: for impl function declarations, unresolved constraints here
                 # (e.g. Eq(a) when the body calls == on a field of type a) should

data/lib/jade/frontend/type_checking.rb

@@ -23,8 +23,7 @@ module Jade
       def check(entry, registry)
         Loader
           .load(entry, registry)
-          .then { check_node(entry.ast, registry, State.init(it, skip_constraints: true), Expected.infer(it.fresh)) }
-          .then { Generalizer.generalize(it.first.env) }
+          .then { collect_constraints(entry, registry, it) }
           .then { check_node(entry.ast, registry, State.init(it), Expected.infer(it.fresh)) }
           .then { finalize(*it, registry) }
           .map { Canonicalize.run(entry.ast, it, registry) }
@@ -33,6 +32,49 @@ module Jade
           .and_then { PortResolution.resolve(it, registry) }
       end
 
+      # A collecting pass walks declarations in source order, so a call to a
+      # function declared later sees it before its constraints are known and
+      # collects nothing. Each repeat carries them one caller further back, so
+      # a chain of forward references needs as many rounds as it is long.
+      def collect_constraints(entry, registry, env, rounds = declaration_count(entry))
+        return env if rounds.zero?
+
+        collect_round(entry, registry, env)
+          .then do |collected|
+            next env if same_constraints?(collected, env)
+
+            collect_constraints(entry, registry, collected, rounds - 1)
+          end
+      end
+
+      def collect_round(entry, registry, env)
+        State
+          .init(env, skip_constraints: true)
+          .then { check_node(entry.ast, registry, it, Expected.infer(env.fresh)) }
+          .then { Generalizer.generalize(it.first.env) }
+      end
+
+      def same_constraints?(one, other)
+        constraint_fingerprint(one) == constraint_fingerprint(other)
+      end
+
+      def constraint_fingerprint(env)
+        env
+          .bindings
+          .map { |name, binding| [name, binding.constraints.map { [it.interface, it.type.to_s] }.sort] }
+          .sort
+      end
+
+      def declaration_count(entry)
+        case entry.ast
+        in AST::Module(body: AST::Body(expressions:)) then expressions
+        in AST::Body(expressions:) then expressions
+        else []
+        end
+          .count { it.is_a?(AST::FunctionDeclaration) }
+          .then { it + 1 }
+      end
+
       def finalize(state, result, registry)
         state.env => { bindings:, entry_name: }
 

data/lib/jade/interop/boundary.rb

@@ -50,12 +50,21 @@ module Jade
 
       def hash(label, v)
         case v
-        when ::Hash then v
+        when ::Hash then string_keyed!(label, v)
         when ::Data then v.to_h.transform_keys(&:to_s)
         else type_error!(label, v)
         end
       end
 
+      # Mixed keys are a real shape mismatch; the per-field errors say more
+      # than a guess about intent would.
+      def string_keyed!(label, v)
+        return v if v.empty? || v.keys.any?(::String)
+
+        v.keys.grep(::Symbol)
+          .then { it.empty? ? v : raise(Jade::Interop::SymbolKeys.new(label, it)) }
+      end
+
       def type_error!(label, v)
         raise Jade::Interop::DecodeError.new(
           Jade::Decode::WrongType[label, Jade::Decode.type_name(v)],

data/lib/jade/interop/error.rb

@@ -40,12 +40,31 @@ module Jade
       end
     end
 
+    # Caught where the whole hash is in scope; downstream each field just
+    # reads nil and blames its own type.
+    class SymbolKeys < Error
+      def initialize(label, keys)
+        super(
+          "#{label} expects a Hash with string keys, got symbol keys " \
+            "(#{keys.take(4).map(&:inspect).join(', ')}). " \
+            "Values cross the boundary as wire data — " \
+            "try #{keys.first.to_s.inspect} rather than #{keys.first.inspect}."
+        )
+      end
+    end
+
     class DecodeError < Error
-      attr_reader :decode_error, :value
+      attr_reader :decode_error, :value, :source
+
+      SUBJECTS = {
+        argument: 'Ruby passed a value that failed to decode',
+        port_return: 'Port returned a value that failed to decode',
+      }.freeze
 
-      def initialize(decode_error, value)
+      def initialize(decode_error, value, source: :argument)
         @decode_error = decode_error
         @value = value
+        @source = source
         super(format(decode_error, value))
       end
 
@@ -54,16 +73,17 @@ module Jade
       def format(error, value)
         path, leaf = unwind(error)
         location = path.empty? ? "value" : path.join
+        subject = SUBJECTS.fetch(@source)
 
         case leaf
         in Jade::Decode::WrongType[expected, got]
-          "Port returned a value that failed to decode at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
+          "#{subject} at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
 
         in Jade::Decode::MissingField[key]
-          "Port returned a value that failed to decode at #{location}: missing field `#{key}` (#{value.inspect})"
+          "#{subject} at #{location}: missing field `#{key}` (#{value.inspect})"
 
         in Jade::Decode::Custom[msg]
-          "Port returned a value that failed to decode at #{location}: #{msg} (#{value.inspect})"
+          "#{subject} at #{location}: #{msg} (#{value.inspect})"
 
         in Jade::Decode::Multiple[errors]
           errors

data/lib/jade/lexer.rb

@@ -66,6 +66,7 @@ module Jade
       '<|' => :pipe_backward,
       '<-' => :bind,
 
+      '^' => :caret, # `^Ctor` — the constructor, curried
       '_' => :wildcard, # also used as placeholder
       '::' => :coloncolon,
       # Ternary `cond ? a : b`. Predicate-`?` attaches via the identifier

data/lib/jade/module_loader/module_name.rb

@@ -0,0 +1,46 @@
+module Jade
+  module ModuleLoader
+    # A module is keyed by the name its file implies — imports resolve
+    # `Shop.Cart` to `shop/cart.jd` and back. The wrapper takes the declared
+    # name while every type reference inside takes the file's, so a mismatch
+    # emits Ruby referring to a constant that was never defined.
+    module ModuleName
+      extend self
+
+      def check(ast, source)
+        return Ok[ast] unless ast.is_a?(AST::Module)
+
+        source.to_module_name.then do |expected|
+          ast.name == expected ? Ok[ast] : Err[mismatch(ast, source, expected)]
+        end
+      end
+
+      private
+
+      def mismatch(ast, source, expected)
+        Diagnostics::List
+          .empty
+          .error(
+            "Module is declared as `#{ast.name}` but `#{source.uri}` defines `#{expected}`.",
+            source:,
+            span: name_span(ast),
+            label: "expected `#{expected}`",
+          )
+          .help("Rename it to `#{expected}`, or move the file to `#{path_for(ast.name)}`.")
+      end
+
+      # `module` is skipped during parsing, so the node starts at the name.
+      def name_span(ast)
+        ast.range.begin...(ast.range.begin + ast.name.length)
+      end
+
+      def path_for(module_name)
+        module_name
+          .split('.')
+          .map { Source.snake_case(it) }
+          .join('/')
+          .then { "#{it}.jd" }
+      end
+    end
+  end
+end

data/lib/jade/module_loader.rb

@@ -9,6 +9,7 @@ require 'jade/codegen'
 require 'jade/module_loader/cache'
 require 'jade/module_loader/dependency_resolver'
 require 'jade/module_loader/dependency_graph'
+require 'jade/module_loader/module_name'
 require 'jade/module_loader/normalize'
 require 'jade/module_loader/topological_sort'
 require 'jade/diagnostics'
@@ -132,6 +133,10 @@ module Jade
             .then { raise CompilationError.new(it) }
         end => Ok([raw_ast, comments])
 
+      ModuleName
+        .check(raw_ast, source)
+        .on_err { raise CompilationError.new(it) }
+
       Frontend::CommentAttacher
         .attach(raw_ast, comments, source)
         .then { Registry.entry(source.to_module_name).with(ast: it, source:, entry:) }

data/lib/jade/parsing.rb

@@ -336,7 +336,8 @@ module Jade
     }
 
     parser(:atom) {
-      variable_reference | negative_literal | literal | constructor_reference |
+      variable_reference | negative_literal | literal |
+        curried_constructor | constructor_reference |
         lambda | tuple | grouping |
         record_literal | record_update_sugar | record_access_sugar | record_update
     }
@@ -509,6 +510,10 @@ module Jade
     # Should refactor to just an Constant node
     parser(:constructor_reference) { constant.map(&AST.constructor_reference) }
 
+    parser(:curried_constructor) {
+      (type(:caret) >> constant).map { AST.curried_constructor.call(it.last) }
+    }
+
     parser(:param) {
       (
         identifier >> type(:colon).skip >> type_expression

data/lib/jade/runtime.rb

@@ -6,6 +6,8 @@ require 'jade/decode'
 require 'jade/interop/boundary'
 
 module Jade
+  module Records; end
+
   module Tuple
     Tuple2 = Data.define(:_1, :_2) do
       def to_s = "(#{[_1, _2].map(&:to_s).join(', ')})"
@@ -123,8 +125,12 @@ module Jade
     # `{a: 1, b: 2}` expression evaluated in a hot loop would call
     # `Data.define(:a, :b)` and allocate a fresh anonymous class, defeating
     # YJIT's inline cache on every subsequent property access.
+    # Named, so the first module to assign it doesn't lend it a name
+    # pointing at an unrelated module.
     def record(*keys)
-      RECORD_CLASSES[keys] ||= Data.define(*keys)
+      RECORD_CLASSES[keys] ||= Data
+        .define(*keys)
+        .tap { Jade::Records.const_set(:"Record_#{keys.join('_')}", it) }
     end
 
     def register_impl(interface_name, ruby_class, functions)

data/lib/jade/task.rb

@@ -93,7 +93,7 @@ module Jade
 
       def decode(decoder, value)
         Jade::Decode::Runner.run!(decoder, value) do |error|
-          fail Jade::Interop::DecodeError.new(error, value)
+          fail Jade::Interop::DecodeError.new(error, value, source: :port_return)
         end
       end
     end

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.5.0'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-08-11 00:00:00.000000000 Z
+date: 2026-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -70,6 +70,7 @@ files:
 - lib/jade/codegen/constructor_reference.rb
 - lib/jade/codegen/context.rb
 - lib/jade/codegen/emitter.rb
+- lib/jade/codegen/error.rb
 - lib/jade/codegen/function_call.rb
 - lib/jade/codegen/function_declaration.rb
 - lib/jade/codegen/helpers.rb
@@ -303,6 +304,7 @@ files:
 - lib/jade/module_loader/cache.rb
 - lib/jade/module_loader/dependency_graph.rb
 - lib/jade/module_loader/dependency_resolver.rb
+- lib/jade/module_loader/module_name.rb
 - lib/jade/module_loader/normalize.rb
 - lib/jade/module_loader/topological_sort.rb
 - lib/jade/parsing.rb