jade-lang 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec12f8f9ca54c6ac59b3d8d521a9ad192eb87dd5a2a5e62620f3abe00b636cee
-  data.tar.gz: 940c0c3e78b8dcbd013050b298508323e5c0f60f8ddcb4749ede2416b14d9e16
+  metadata.gz: 38f4067e761c85016ad9baa6c733e6567aa93eea5cc0ffb755c0ac469a6a0002
+  data.tar.gz: 97dd4372b13bcb7e23bdc3ac2dcbe231d067410e9a99634afbbd3bd1a485452e
 SHA512:
-  metadata.gz: e2f05e1f66e7b893e547a2ccb4d31a9678705daecd35c4c806a94f65c47444ad8b69b334c14b18a3a67417963870debdc4f28530ac334c0106699ee278c1f199
-  data.tar.gz: 5711c4a232e7728699e89ddcf168e7dc5b1b86913e34579c7b0b1b2d3df6e069f2f4a12aeb35a800619fdb945169c142a2434f322ce582b1415c524259ab2646
+  metadata.gz: 415bcc6027fbefa912960d30c004d3d442000b37d6b3e6a27485b9ef9a12685bad3dc79855f7ccd99378987ea38fb6810fafe8f371dad5c50ce9b605c464f756
+  data.tar.gz: 8891cbe3dfe48e80cdb2ae73ec96a13b09a3adc8287adf812e7a30639ca4918b417cc02e45148222bacd2f7b1d412b58ce78d15f783dceed0868d0175e194daf

data/CHANGELOG.md

@@ -6,6 +6,84 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.8.0]
+
+### Added
+
+- `Assignable` also derives for structs, naming one column per field in
+  declaration order. A field renamed to dodge a keyword (`type_`) maps back to
+  the column it came from. Generic structs derive at the type they are applied
+  to. Inert unless jade-sql is loaded.
+
+### Changed
+
+- The derived jade-sql interface is now `Sql.Assignable`, was `Sql.SqlMapper`.
+  It is matched by name, so jade-sql must move to the new name in the same
+  release.
+
+## [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

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.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.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/{sql_mapper.rb → assignable.rb}

@@ -6,11 +6,11 @@ module Jade
           # jade-sql's interface, derived here rather than there: the
           # deriving framework is not extensible, and this stays inert
           # without jade-sql, since nothing else names the interface.
-          module SqlMapper
+          module Assignable
             extend self
             include Helpers
 
-            INTERFACE = 'Sql.SqlMapper'
+            INTERFACE = 'Sql.Assignable'
             ASSIGNMENT = 'Sql.Assignment'
             ASSIGNMENT_FIELDS = %w[col value_sql params].freeze
 
@@ -20,11 +20,11 @@ module Jade
               return failed(constraint, entry_name) unless assignment_matches?(registry)
 
               case constraint.type
-              in Type::Application(constructor: Type::Constructor(name:), args: [])
+              in Type::Application(constructor: Type::Constructor(name:), args:)
                 Symbol
                   .type_ref_from_qualified_name(name)
                   .then { registry.lookup(it) }
-                  .then { derive_for(constraint, it, registry, lookup, entry_name) }
+                  .then { derive_for(constraint, it, args, registry, lookup, entry_name) }
 
               else
                 failed(constraint, entry_name)
@@ -47,11 +47,14 @@ module Jade
                 end
             end
 
-            def derive_for(constraint, symbol, registry, lookup, entry_name)
+            def derive_for(constraint, symbol, args, registry, lookup, entry_name)
               case symbol
-              in Symbol::Union if single_payload?(symbol, registry)
+              in Symbol::Union if args.empty? && single_payload?(symbol, registry)
                 derive_union(constraint, symbol, registry, lookup, entry_name)
 
+              in Symbol::Struct
+                derive_struct(constraint, symbol, args, registry, lookup, entry_name)
+
               else
                 failed(constraint, entry_name)
               end
@@ -74,6 +77,43 @@ module Jade
                 .map { implementation(constraint, union_body(vs), it) }
             end
 
+            def derive_struct(constraint, struct_sym, args, registry, lookup, entry_name)
+              fields = struct_fields(struct_sym, args, registry)
+
+              fields
+                .map { |_, type| Type.constraint('Encode.Encodable', type, nil) }
+                .map { lookup.call(it) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, struct_body(fields), it) }
+            end
+
+            def struct_body(fields)
+              fields
+                .each_with_index
+                .map { |(name, _), idx| field_assignment(name, idx) }
+                .then { [:list, it] }
+            end
+
+            def field_assignment(name, idx)
+              [:call,
+                [:struct_constructor, ASSIGNMENT, 3],
+                [
+                  column_name(name),
+                  '?',
+                  [:list,
+                    [[:call, [:impl_arg, idx, 'encoder'], [[:access, [:var, 'f'], name.to_s]]]],
+                  ],
+                ],
+              ]
+            end
+
+            def column_name(field)
+              field
+                .to_s
+                .then { it.end_with?('_') ? it.delete_suffix('_') : it }
+                .then { Lexer::KEYWORDS.include?(it) ? it : field.to_s }
+            end
+
             def encodable_dep(variant, registry)
               variant
                 .args

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/constraints/deriving.rb

@@ -2,7 +2,7 @@ require_relative './deriving/helpers.rb'
 require_relative './deriving/eq.rb'
 require_relative './deriving/decodable.rb'
 require_relative './deriving/encodable.rb'
-require_relative './deriving/sql_mapper.rb'
+require_relative './deriving/assignable.rb'
 require_relative './deriving/show.rb'
 
 module Jade
@@ -12,7 +12,7 @@ module Jade
         module Deriving
           extend self
 
-          DERIVERS = [Eq, Show, Decodable, Encodable, SqlMapper]
+          DERIVERS = [Eq, Show, Decodable, Encodable, Assignable]
 
           def derivable?(interface)
             DERIVERS.any? { it.supports?(interface) }

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/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/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/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.6.0'
+  VERSION = '0.8.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-08-13 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
@@ -217,12 +218,12 @@ files:
 - lib/jade/frontend/type_checking/canonicalize.rb
 - lib/jade/frontend/type_checking/constraints.rb
 - lib/jade/frontend/type_checking/constraints/deriving.rb
+- lib/jade/frontend/type_checking/constraints/deriving/assignable.rb
 - lib/jade/frontend/type_checking/constraints/deriving/decodable.rb
 - lib/jade/frontend/type_checking/constraints/deriving/encodable.rb
 - lib/jade/frontend/type_checking/constraints/deriving/eq.rb
 - lib/jade/frontend/type_checking/constraints/deriving/helpers.rb
 - lib/jade/frontend/type_checking/constraints/deriving/show.rb
-- lib/jade/frontend/type_checking/constraints/deriving/sql_mapper.rb
 - lib/jade/frontend/type_checking/definition.rb
 - lib/jade/frontend/type_checking/env.rb
 - lib/jade/frontend/type_checking/error.rb