jade-lang 0.10.0 → 0.11.0

data/lib/jade/frontend/type_checking/error/record_update_type_mismatch.rb

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        # An update produces a record of its own, which then has to be the
+        # record the surrounding code wanted. Changing a field's type is the
+        # usual way to break that, and any other disagreement lands here too.
+        class RecordUpdateTypeMismatch < TypeMismatch
+          def message
+            "This update produces #{naming.annotated(@actual)}, " \
+              "but #{naming.annotated(@expected)} was expected"
+          end
+
+          def label
+            "produces #{naming[@actual]}, expected #{naming[@expected]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/undeclared_requirement.rb

@@ -0,0 +1,35 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class UndeclaredRequirement < Jade::Error
+          def initialize(entry, span, interface:, fn_name:, constraint:, declared:)
+            super(entry:, span:)
+            @interface  = interface
+            @fn_name    = fn_name
+            @constraint = constraint
+            @declared   = declared
+          end
+
+          def message
+            "Implementation of #{@interface}.#{@fn_name} requires #{@constraint}, " \
+              "which #{@interface} does not declare. It declares #{@declared}"
+          end
+
+          def label
+            "requires #{@constraint}"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                "add it to the method: `#{@fn_name} : ... with #{@constraint}`",
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error.rb

@@ -19,6 +19,10 @@ require 'jade/frontend/type_checking/error/pattern_type_mismatch'
 require 'jade/frontend/type_checking/error/empty_range_pattern'
 require 'jade/frontend/type_checking/error/range_pattern_type'
 require 'jade/frontend/type_checking/error/record_access_type_mismatch'
+require 'jade/frontend/type_checking/error/record_update_type_mismatch'
 require 'jade/frontend/type_checking/error/unresolved_constraint'
 require 'jade/frontend/type_checking/error/implementation_type_mismatch'
+require 'jade/frontend/type_checking/error/implementation_function_constraint'
+require 'jade/frontend/type_checking/error/cross_module_requirement'
+require 'jade/frontend/type_checking/error/undeclared_requirement'
 require 'jade/frontend/type_checking/error/missing_implementation'

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

@@ -48,11 +48,6 @@ module Jade
                   .map { st.env.substitution.apply(it) }
                   .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
-                # be stored as impl-level constraints, not function-level ones.
-                # The impl finalization pass (see TypeChecking.finalize) should then
-                # promote them into deps when the impl is instantiated for a concrete type.
                 st.bind(
                   symbol.qualified_name,
                   Placeholder[

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

@@ -27,6 +27,15 @@ module Jade
           def type_from_symbol(symbol, registry, var_gen)
             Type.from_symbol(symbol, registry, var_gen)
           end
+
+          def attach_markers(result)
+            result
+              .constraints
+              .select { it.type.is_a?(Type::Var) && it.index != :unindex }
+              .each { Constraints.attach_dictionary(it, it) }
+
+            result
+          end
         end
       end
     end

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

@@ -57,6 +57,8 @@ module Jade
                   st_after_bind,
                   Expected.check(expected_type),
                   interface_qname,
+                  concrete_type,
+                  iface_fn_type,
                 )
               end
               .then { [it, Result.init(Type.unit)] }
@@ -64,7 +66,7 @@ module Jade
 
           private
 
-          def infer_fn(impl_fn, registry, state, expected, interface_qname)
+          def infer_fn(impl_fn, registry, state, expected, interface_qname, head_type, sig_type)
             impl_fn => AST::ImplementationFunction(name:, fn:)
 
             case fn
@@ -83,29 +85,63 @@ module Jade
                   state,
                   Expected.infer(state.fresh),
                 )
-                body_state.unify(
-                  body_result.type,
-                  expected.type,
-                  &mismatch_error(state.env.entry_name, impl_fn, interface_qname, name)
-                )
+                body_state
+                  .unify(
+                    body_result.type,
+                    expected.type,
+                    &mismatch_error(state.env.entry_name, impl_fn, interface_qname, name)
+                  )
+                  .then do |unified|
+                    record_requirements(
+                      unified,
+                      body_result.constraints,
+                      head_type,
+                      sig_type,
+                      interface_qname,
+                      impl_fn,
+                      name,
+                    )
+                  end
               end
 
             in AST::Lambda
-              check(fn, registry, state, expected).first
+              lambda_state, lambda_result = check(fn, registry, state, expected)
+
+              record_requirements(
+                lambda_state,
+                lambda_result.constraints,
+                head_type,
+                sig_type,
+                interface_qname,
+                impl_fn,
+                name,
+              )
 
             in AST::VariableReference
               ref_state, ref_result = check(fn, registry, state, expected)
 
-              ref_state.unify(
-                ref_result.type,
-                expected.type,
-                &mismatch_error(
-                  state.env.entry_name,
-                  impl_fn,
-                  interface_qname,
-                  name
+              ref_state
+                .unify(
+                  ref_result.type,
+                  expected.type,
+                  &mismatch_error(
+                    state.env.entry_name,
+                    impl_fn,
+                    interface_qname,
+                    name
+                  )
                 )
-              )
+                .then do |unified|
+                  record_requirements(
+                    unified,
+                    ref_result.constraints,
+                    head_type,
+                    sig_type,
+                    interface_qname,
+                    impl_fn,
+                    name,
+                  )
+                end
 
             # `decoder: zero_arg_fn` becomes `FunctionCall(zero_arg_fn, [])`
             # after ZeroArgRewrite. Type the call; its result must match the
@@ -115,6 +151,47 @@ module Jade
             end
           end
 
+          def record_requirements(state, constraints, head_type, sig_type, interface_qname, impl_fn, fn_name)
+            substitution = state.env.substitution
+            head_vars = substitution.apply(head_type).unbound_vars.map(&:id).to_set
+            names = signature_names(sig_type, substitution)
+
+            free = constraints
+              .map { substitution.apply(it) }
+              .select { it.type.is_a?(Type::Var) && !head_vars.include?(it.type.id) }
+              .uniq { [it.interface, it.type.id] }
+
+            free
+              .reject { names.key?(it.type.id) }
+              .map { unsatisfiable(state, impl_fn, interface_qname, fn_name, it) }
+              .then { state.add_errors(it) }
+              .require_impl(
+                [interface_qname, fn_name],
+                free.filter_map { |c| names[c.type.id]&.then { |n| [c.interface, n] } },
+              )
+          end
+
+          def signature_names(sig_type, substitution)
+            sig_type
+              .unbound_vars
+              .filter_map do |var|
+                substitution
+                  .apply(var)
+                  .then { it.is_a?(Type::Var) ? [it.id, var.name] : nil }
+              end
+              .to_h
+          end
+
+          def unsatisfiable(state, impl_fn, interface_qname, fn_name, constraint)
+            Error::ImplementationFunctionConstraint.new(
+              state.env.entry_name,
+              impl_fn.range,
+              interface: interface_qname,
+              fn_name:,
+              constraint: constraint.to_s,
+            )
+          end
+
           def constructor_var_in?(type, var_id)
             case type
             in Type::Application(constructor: Type::Var(id:)) if id == var_id

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

@@ -13,6 +13,7 @@ module Jade
               .env
               .lookup(symbol.qualified_name)
               .then { it.attach_origin(node) }
+              .then { state.skip_constraints ? it : attach_markers(it) }
               .then { state.unify_result(it, expected.type) }
           end
         end

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

@@ -28,7 +28,14 @@ module Jade
               )
             end
 
-            after_state.unify_result(result, expected.type)
+            after_state.unify_result(result, expected.type) do
+              Error::RecordUpdateTypeMismatch.new(
+                state.env.entry_name,
+                node.range,
+                expected: it.expected,
+                actual: it.actual,
+              )
+            end
           end
         end
       end

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

@@ -17,6 +17,7 @@ module Jade
             end
               .then { state.env.lookup(it) }
               .then { it.attach_origin(node) }
+              .then { state.skip_constraints ? it : attach_markers(it) }
               .then { [state, it] }
           end
         end

data/lib/jade/frontend/type_checking/requirements.rb

@@ -0,0 +1,115 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Requirements
+        extend self
+
+        def reconcile(entry, registry, state)
+          pending = state
+            .impl_requirements
+            .to_h { |key, pairs| [key, pairs - declared_for(key, registry)] }
+            .reject { |_, pairs| pairs.empty? }
+
+          errors(entry, registry, pending)
+            .then { return [entry, state.add_errors(it)] if it.any? }
+
+          amended = amend_all(entry, pending)
+          return [entry, state] if amended.equal?(entry)
+
+          rebind(state.env, amended, registry)
+            .then { recheck(entry, registry, it) }
+            .then { |rechecked| [amended, rechecked] }
+        end
+
+        private
+
+        def recheck(entry, registry, env)
+          TypeChecking
+            .check_node(entry.ast, registry, State.init(env), Expected.infer(env.fresh))
+            .first
+        end
+
+        def rebind(env, entry, registry)
+          entry
+            .defined_values
+            .each_value
+            .select { it.is_a?(Symbol::InterfaceFunction) && it.constraints.any? }
+            .reduce(env) do |acc, sym|
+              Type
+                .from_symbol(sym, registry, acc.var_gen)
+                .then { Inference::Helpers.generalize(acc, *it) }
+                .then { acc.bind(sym.qualified_name, it) }
+            end
+        end
+
+        def declared_for((interface, fn_name), registry)
+          Symbol
+            .type_ref_from_qualified_name(interface)
+            .then { registry.lookup(it) }
+            .then { it.is_a?(Symbol::Interface) ? it.functions : [] }
+            .find { it.name == fn_name }
+            &.constraints || []
+        end
+
+        def errors(entry, registry, pending)
+          pending.flat_map do |(interface, fn_name), constraints|
+            declared = declared_for([interface, fn_name], registry)
+            next [] if declared.empty? && local?(entry, interface)
+
+            constraints.map do |iface, var|
+              error_for(entry, interface, fn_name, "#{iface} #{var}", declared)
+            end
+          end
+        end
+
+        def local?(entry, interface)
+          entry.defined_types.key?(interface.split('.').last)
+        end
+
+        def error_for(entry, interface, fn_name, constraint, declared)
+          return cross_module_error(entry, interface, fn_name, constraint) if declared.empty?
+
+          Error::UndeclaredRequirement.new(
+            entry.name,
+            nil,
+            interface:,
+            fn_name:,
+            constraint:,
+            declared: declared.map { |iface, var| "#{iface} #{var}" }.join(', '),
+          )
+        end
+
+        def cross_module_error(entry, interface, fn_name, constraint)
+          Error::CrossModuleRequirement.new(
+            entry.name,
+            nil,
+            interface:,
+            fn_name:,
+            constraint:,
+          )
+        end
+
+        def amend_all(entry, pending)
+          pending.reduce(entry) do |acc, ((interface, fn_name), constraints)|
+            amend_method(acc, interface, fn_name, constraints)
+          end
+        end
+
+        def amend_method(entry, interface_qname, fn_name, constraints)
+          symbol = entry.defined_types[interface_qname.split('.').last]
+          return entry unless symbol.is_a?(Symbol::Interface)
+
+          symbol
+            .functions
+            .map { it.name == fn_name ? with_constraints(it, constraints) : it }
+            .then { symbol.with(functions: it) }
+            .then { |iface| iface.functions.reduce(entry.define(iface)) { |acc, fn| acc.define(fn) } }
+        end
+
+        def with_constraints(fn, constraints)
+          fn.with(constraints: (fn.constraints + constraints).uniq)
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/state.rb

@@ -1,9 +1,17 @@
 module Jade
   module Frontend
     module TypeChecking
-      State = Data.define(:env, :errors, :skip_constraints) do
+      State = Data.define(:env, :errors, :skip_constraints, :impl_requirements) do
         def self.init(env, skip_constraints: false)
-          new(env, [], skip_constraints)
+          new(env, [], skip_constraints, {})
+        end
+
+        def require_impl(key, constraints)
+          return self if constraints.empty?
+
+          impl_requirements
+            .merge(key => constraints) { |_, old, new| (old + new).uniq }
+            .then { with(impl_requirements: it) }
         end
 
         def unify_result(result, right, rigid_vars = [], &block)

data/lib/jade/frontend/type_checking.rb

@@ -8,6 +8,7 @@ require 'jade/frontend/type_checking/expected'
 require 'jade/frontend/type_checking/inference'
 require 'jade/frontend/type_checking/loader'
 require 'jade/frontend/type_checking/port_resolution'
+require 'jade/frontend/type_checking/requirements'
 require 'jade/frontend/type_checking/result'
 require 'jade/frontend/type_checking/state'
 require 'jade/frontend/type_checking/substitution'
@@ -26,11 +27,16 @@ module Jade
           .load(entry, registry)
           .then { collect_constraints(entry, registry, it) }
           .then { check_node(entry.ast, registry, State.init(it), Expected.infer(it.fresh)) }
-          .then { finalize(*it, registry) }
+          .then { |state, _| Requirements.reconcile(entry, registry, state) }
+          .then { |amended, state| complete(amended, state, registry) }
+          .and_then { PortResolution.resolve(it, registry) }
+      end
+
+      def complete(entry, state, registry)
+        finalize(state, registry)
           .map { Canonicalize.run(entry.ast, it, registry) }
           .map { it.canonicalize_node_types }
           .map { entry.with(env: it) }
-          .and_then { PortResolution.resolve(it, registry) }
       end
 
       # A collecting pass walks declarations in source order, so a call to a
@@ -76,7 +82,7 @@ module Jade
           .then { it + 1 }
       end
 
-      def finalize(state, result, registry)
+      def finalize(state, registry)
         state.env => { bindings:, entry_name: }
 
         errors = bindings

data/lib/jade/parsing/type.rb

@@ -10,7 +10,7 @@ module Jade
       }
 
       parser(:type_atom) {
-        type_application | type_var | type_tuple | grouped(lazy { type_function })
+        type_application | type_var | type_tuple | grouped(lazy { type_expression })
       }
 
       parser(:type_tuple) {

data/lib/jade/parsing.rb

@@ -753,10 +753,23 @@ module Jade
     }
 
     parser(:interface_function_decl) {
+      constraint =
+        (
+          constant >>
+          type(:lparen).skip >>
+          type_param >>
+          type(:rparen).skip
+        ).map(&AST.interface_constraint)
+
+      constraints =
+        type(:with).skip >>
+        at_least_one(constraint, separated_by: type(:comma).skip)
+
       (
         (type(:identifier) | (type(:lparen).skip >> operator >> type(:rparen).skip)) >>
         type(:colon).skip >>
-        type_expression
+        type_expression >>
+        optional(constraints, default: []).map { [it] }
       ).map(&AST.interface_function_decl)
     }
 

data/lib/jade/stdlib/decode.rb

@@ -268,6 +268,17 @@ module Jade
 
       # Constrained helpers — pick the decoder via Decodable.
 
+      function(
+        'decoder',
+        {},
+        'Decoder(a)',
+        constraints: [['Decode.Decodable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: [],
+          body: [:impl_arg, 0, 'decoder'],
+        ),
+      )
+
       function(
         'from_value',
         { value: 'Value' },

data/lib/jade/symbol/interface_function.rb

@@ -6,7 +6,8 @@ module Jade
       :interface,
       :params,
       :return_type,
-      :decl_span
+      :decl_span,
+      :constraints
     ) do
       include Base
 

data/lib/jade/symbol/stdlib_function.rb

@@ -8,7 +8,7 @@ module Jade
       end
 
       def constant?
-        params.empty? && constraints.empty?
+        params.empty?
       end
     end
   end

data/lib/jade/symbol.rb

@@ -134,8 +134,8 @@ module Jade
       Interface[nil, name, type_var, functions, default, span]
     end
 
-    def interface_function(name, inteface, params, return_type, span)
-      InterfaceFunction[nil, name, inteface, params, return_type, span]
+    def interface_function(name, inteface, params, return_type, span, constraints = [])
+      InterfaceFunction[nil, name, inteface, params, return_type, span, constraints]
     end
 
     def implementation(

data/lib/jade/type/function.rb

@@ -1,27 +1,26 @@
 module Jade
   module Type
-    Function = Data.define(:args, :return_type, :display) do
+    Function = Data.define(:args, :return_type) do
       include Base
-      include Displayable
 
-      def initialize(args:, return_type:, display: nil)
-        super
-      end
-
-      def identity
-        [args, return_type]
-      end
+      # `Int, Int -> Int`, the spelling the formatter writes. Parentheses
+      # around a comma list are a tuple, so a nested function keeps its own.
+      def to_s
+        params = args.empty? ? '()' : args.map { delimited(it) }.join(', ')
 
-      def render
-        args
-          .map(&:to_s).join(', ')
-          .then { "(#{it})"} + " -> " + return_type.to_s
+        "#{params} -> #{delimited(return_type)}"
       end
 
       def unbound_vars
         (args.flat_map(&:unbound_vars) + return_type.unbound_vars)
           .to_set.to_a
       end
+
+      private
+
+      def delimited(type)
+        type.is_a?(Function) ? "(#{type})" : type.to_s
+      end
     end
   end
 end

data/lib/jade/type.rb

@@ -178,9 +178,18 @@ module Jade
         constraint = Type
           .constraint(symbol.interface.qualified_name, param_type, nil)
 
-        from_symbol_r(symbol.return_type, registry, var_gen, local_map)
-          .then { |(t, c, _)| [args.empty? ? t : Type.function(args, t), c + arg_cs + [constraint]] }
-          .then { it + [var_map] }
+        ret_type, ret_cs, full_map =
+          from_symbol_r(symbol.return_type, registry, var_gen, local_map)
+
+        extra_cs = symbol.constraints.map { |iface, var_name|
+          Type.constraint(iface, full_map.fetch(var_name), nil)
+        }
+
+        [
+          args.empty? ? ret_type : Type.function(args, ret_type),
+          ret_cs + arg_cs + [constraint] + extra_cs,
+          var_map,
+        ]
 
       in Symbol::Constructor if symbol.args.empty?
         from_symbol_r(symbol.parent, registry, var_gen, var_map)

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.10.0'
+  VERSION = '0.11.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -57,6 +57,7 @@ files:
 - lib/jade/cli/check.rb
 - lib/jade/cli/eject.rb
 - lib/jade/cli/fmt.rb
+- lib/jade/cli/init.rb
 - lib/jade/cli/lsp.rb
 - lib/jade/cli/q.rb
 - lib/jade/clock/runtime.rb
@@ -248,6 +249,7 @@ files:
 - lib/jade/frontend/type_checking/env.rb
 - lib/jade/frontend/type_checking/error.rb
 - lib/jade/frontend/type_checking/error/case_of_branches_type_mismatch.rb
+- lib/jade/frontend/type_checking/error/cross_module_requirement.rb
 - lib/jade/frontend/type_checking/error/derivation_failed.rb
 - lib/jade/frontend/type_checking/error/display.rb
 - lib/jade/frontend/type_checking/error/division_by_zero.rb
@@ -257,6 +259,7 @@ files:
 - lib/jade/frontend/type_checking/error/if_branch_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/if_branches_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/if_condition_type_mismatch.rb
+- lib/jade/frontend/type_checking/error/implementation_function_constraint.rb
 - lib/jade/frontend/type_checking/error/implementation_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/list_item_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/missing_implementation.rb
@@ -266,8 +269,10 @@ files:
 - lib/jade/frontend/type_checking/error/port_not_encodable.rb
 - lib/jade/frontend/type_checking/error/range_pattern_type.rb
 - lib/jade/frontend/type_checking/error/record_access_type_mismatch.rb
+- lib/jade/frontend/type_checking/error/record_update_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/recursive_derivation.rb
 - lib/jade/frontend/type_checking/error/type_mismatch.rb
+- lib/jade/frontend/type_checking/error/undeclared_requirement.rb
 - lib/jade/frontend/type_checking/error/unreachable_branch.rb
 - lib/jade/frontend/type_checking/error/unresolved_constraint.rb
 - lib/jade/frontend/type_checking/expected.rb
@@ -306,6 +311,7 @@ files:
 - lib/jade/frontend/type_checking/loader.rb
 - lib/jade/frontend/type_checking/placeholder.rb
 - lib/jade/frontend/type_checking/port_resolution.rb
+- lib/jade/frontend/type_checking/requirements.rb
 - lib/jade/frontend/type_checking/result.rb
 - lib/jade/frontend/type_checking/scheme.rb
 - lib/jade/frontend/type_checking/state.rb