jade-lang 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b0d9367dd2a235c282b3e7bbeabc2ee7874fa6899fdbdd746c66d546279cf30
-  data.tar.gz: cf83815353b341a4834b5b17712148db973f96a3a914ac6aa2ae019a00ae84df
+  metadata.gz: b73668e7e5ab3a62df195d2f978ffcba2ef69e3a2e578eb084ab56dccfe0770f
+  data.tar.gz: 6d7420d31cf750127e51ad9191ac068231e92b041779ef4927d0e6feea26fd2f
 SHA512:
-  metadata.gz: 1551750ffbca65f37071206e6eccc559f2d7ae81b5ecf0545c089bc3b0f8d36ba3cc3d98c4c33ce3b2c572c8a650d494c40c9d926f210a1f449c478257ca084c
-  data.tar.gz: 2ec0e124c2057bd34cf99728253b5dbd93765c77694a7f6ca0799be1c56eb1baa6d79e4cbc8268ad56a38fa811877defb5ccbd2f7538ce24e33958754ee90aa6
+  metadata.gz: 0036c6f868f892ff83938bfbf5eda69531d4a4fa11aa1abd27978efafddc936bb64320acd6a181caa0b2f55cccb70957c9ba80aad833584857a4b51dc1083ed1
+  data.tar.gz: 95940e59148590400e15d252ed8bbb4a7a6b67cd3febbc481a8b176fbb373afd2e20069e3a91541af52aafbf510baa6d1c9fb3f5cd2277b76adaff07015a75e8

data/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.0] - 2026-09-15
+
+### Added
+
+- **An interface method may require an interface of another type.** A method
+  can mention a type variable the interface itself does not name, and say what
+  that variable has to satisfy:
+
+      interface Fetchable(x) with
+        projection : x -> Sel(a) with Selectable(a)
+      end
+
+  `a` is settled where `projection` is called, not where the implementation is
+  picked, so each call site resolves the requirement against its own types and
+  passes that dictionary alongside the one for `x`. Left undeclared, the
+  requirement is inferred from the implementations instead. Declared and
+  inferred are reconciled rather than one overriding the other: an
+  implementation may require what the method declares, and anything beyond it
+  is refused by name.
+
+  Two cases stay refused. A requirement *inferred* on an interface from
+  another module, because a declaration is what travels with the interface and
+  there is no foreign entry to amend — declare it and it works across modules.
+  And a requirement on a variable the method's signature never names, which
+  nothing could satisfy.
+
+### Fixed
+
+- **A bare reference to a zero-arg interface method resolves through its
+  dictionary.** Dictionaries were only ever attached where a method was called
+  or passed as an argument, so a function body that was just `selector` — or
+  `Module.selector` — compiled to that name as a Ruby method and died on the
+  first call. It now reads the enclosing function's dictionary, or is a compile
+  error where none is in scope. Code that was silently broken this way may stop
+  compiling.
+
 ## [0.10.1] - 2026-09-11
 
 ### Added

data/lib/jade/ast.rb

@@ -77,7 +77,8 @@ module Jade
     define(:ImplementationFunction, :name, :fn)
 
     define(:InterfaceDeclaration, :name, :type_param, :functions)
-    define(:InterfaceFunctionDecl, :name, :type)
+    define(:InterfaceFunctionDecl, :name, :type, :constraints)
+    define(:InterfaceConstraint, :interface, :type_param)
 
     module Pattern
       extend self
@@ -751,7 +752,7 @@ module Jade
     end
 
     def interface_function_decl
-      ->((name, type)) do
+      ->((name, type, constraints)) do
         canonical_name =
           case name.type
           in :identifier then name.value
@@ -761,7 +762,18 @@ module Jade
         InterfaceFunctionDecl[
           canonical_name,
           type,
-          name.range.begin...type.range.end,
+          constraints,
+          name.range.begin...(constraints.last&.range&.end || type.range.end),
+        ]
+      end
+    end
+
+    def interface_constraint
+      ->((name, type_param)) do
+        InterfaceConstraint[
+          name.value,
+          type_param,
+          name.range.begin...type_param.range.end,
         ]
       end
     end

data/lib/jade/codegen/function_call.rb

@@ -246,15 +246,6 @@ module Jade
         end
       end
 
-      # When a user fn has var-typed constraints, two definitions are emitted:
-      # `name` (Ruby-boundary wrapper, no dicts) and `__name__impl__` (takes
-      # dicts). Jade-internal calls target the latter.
-      def fn_target_name(fn_sym, registry)
-        return fn_sym.name if dict_constraints(fn_sym, registry).empty?
-
-        fn_impl_synthetic_name(fn_sym.name)
-      end
-
       # Returns the list of dict args to pass after regular args. Only
       # Symbol::Function callees take dict params; other branches dispatch
       # via `dictionaries` directly inside generate_callee. dictionaries are
@@ -267,6 +258,7 @@ module Jade
           else callee.symbol
           end
 
+        return interface_dict_args(symbol, dictionaries, registry) if symbol.is_a?(Symbol::InterfaceFunction)
         return "" unless symbol.is_a?(Symbol::Function)
 
         fn_constraints(symbol, registry)
@@ -275,6 +267,14 @@ module Jade
           .join(', ')
       end
 
+      def interface_dict_args(_symbol, dictionaries, registry)
+        dictionaries
+          .drop(1)
+          .compact
+          .filter_map { dispatch_value(it, registry) }
+          .join(', ')
+      end
+
       # Ruby-block intrinsics (Dict's `Eq k`, etc.) ignore dispatches — the
       # `in String` body of `generate_impl_fn` drops them.
       def dispatch_dict(entry, registry)
@@ -356,7 +356,7 @@ module Jade
           "#{internal(fn.module_name)}.#{fn.name}"
 
         in Symbol::Function => fn
-          "#{internal(fn.module_name)}.method(:#{fn.name})"
+          "#{internal(fn.module_name)}.method(:#{fn_target_name(fn, registry)})"
         end
       end
 

data/lib/jade/codegen/function_declaration.rb

@@ -34,10 +34,9 @@ module Jade
 
         var_cs      = dict_constraints(symbol, registry)
         param_names = params.map { generate_node(it, registry) }
-        dict_params = var_cs.each_index.map { dict_synthetic_name(it) }
 
-        body_code = build_dict_env(var_cs)
-          .then { Codegen.with_dict_env(it) { emit_body(body, symbol, param_names, registry) } }
+        dict_params, body_code =
+          with_dict_params(var_cs) { emit_body(body, symbol, param_names, registry) }
 
         target  = var_cs.empty? ? name : fn_impl_synthetic_name(name)
         sig     = (param_names + dict_params).join(', ')
@@ -200,13 +199,6 @@ module Jade
           .then { it.substitution.apply(it.bindings[symbol.qualified_name].type) }
       end
 
-      def build_dict_env(var_cs)
-        var_cs
-          .each_with_index
-          .reduce({}) do |env, (c, i)|
-            env.merge([c.interface, c.type.id] => dict_synthetic_name(i))
-          end
-      end
     end
   end
 end

data/lib/jade/codegen/helpers.rb

@@ -74,6 +74,48 @@ module Jade
           .then { "__#{it}__impl__" }
       end
 
+      def fn_target_name(fn_sym, registry)
+        return fn_sym.name if dict_constraints(fn_sym, registry).empty?
+
+        fn_impl_synthetic_name(fn_sym.name)
+      end
+
+      def with_dict_params(constraints)
+        constraints
+          .each_with_index
+          .to_h { |c, i| [[c.interface, c.type.id], dict_synthetic_name(i)] }
+          .then { |env| Codegen.with_dict_env(env) { yield } }
+          .then { |body| [constraints.each_index.map { dict_synthetic_name(it) }, body] }
+      end
+
+      def body_markers(node)
+        return [] unless node.is_a?(AST::Node)
+
+        node
+          .deconstruct_keys(nil)
+          .each_value
+          .flat_map { marker_children(it) }
+          .flat_map { body_markers(it) }
+          .then { own_markers(node) + it }
+      end
+
+      def own_markers(node)
+        return [] unless node.respond_to?(:dictionaries)
+
+        node
+          .dictionaries
+          .select { it.is_a?(Type::Constraint) && it.type.is_a?(Type::Var) }
+      end
+
+      def marker_children(value)
+        case value
+        in Array then value.flat_map { marker_children(it) }
+        in Hash then value.each_value.flat_map { marker_children(it) }
+        in AST::Node then [value]
+        else []
+        end
+      end
+
       def fn_constraints(fn_symbol, registry)
         env = registry.get(fn_symbol.module_name).env
 

data/lib/jade/codegen/implementation.rb

@@ -106,7 +106,7 @@ module Jade
       end
 
       def generate_defs(node, registry)
-        node => AST::Implementation(interface:, applied_type:, functions:)
+        node => AST::Implementation(interface:, applied_type:, functions:, symbol:)
 
         type_name =
           case applied_type.constructor
@@ -115,7 +115,7 @@ module Jade
           end
 
         functions
-          .filter_map { generate_function(it, registry, interface, type_name) }
+          .filter_map { generate_function(it, registry, interface, type_name, symbol) }
           .join(Pretty.newline(2))
       end
 
@@ -143,7 +143,7 @@ module Jade
         fn_map = symbol.functions.filter_map { |fn_name, ref|
           next unless ref.is_a?(Symbol::ValueRef)
 
-          [fn_name, "->(*args) { #{internal(ref.module_name)}.#{ref.name}(*args) }"]
+          [fn_name, "->(*args) { #{internal(ref.module_name)}.#{registered_target(ref, registry)}(*args) }"]
         }.to_h
 
         return "" if fn_map.empty?
@@ -155,16 +155,41 @@ module Jade
           .join(Pretty.newline)
       end
 
-      def generate_function(impl_fn, registry, interface, type_name)
+      def requirement_markers(body, impl_sym, fn_name, registry)
+        required = registry
+          .lookup(impl_sym.interface)
+          .functions
+          .find { it.name == fn_name }
+          .constraints
+
+        return [] if required.empty?
+
+        body_markers(body)
+          .uniq { [it.interface, it.type.id] }
+          .sort_by { |c| required.index { |iface, _| iface == c.interface } || required.size }
+      end
+
+      def registered_target(ref, registry)
+        case registry.lookup(ref)
+        in Symbol::Function => fn then FunctionCall.fn_target_name(fn, registry)
+        else ref.name
+        end
+      end
+
+      def generate_function(impl_fn, registry, interface, type_name, impl_sym)
         impl_fn => AST::ImplementationFunction(name: fn_name, fn:)
 
         case fn
         in AST::Lambda(params:, body:)
-          synth     = impl_synthetic_name(interface, type_name, fn_name)
-          param_str = params.map { generate_node(it, registry) }.join(', ')
-          sig       = param_str.empty? ? '' : "(#{param_str})"
+          synth = impl_synthetic_name(interface, type_name, fn_name)
+
+          dicts, body_code = requirement_markers(body, impl_sym, fn_name, registry)
+            .then { with_dict_params(it) { generate_node(body, registry) } }
 
-          Pretty.block("def #{synth}#{sig}", generate_node(body, registry))
+          (params.map { generate_node(it, registry) } + dicts)
+            .join(', ')
+            .then { it.empty? ? '' : "(#{it})" }
+            .then { Pretty.block("def #{synth}#{it}", body_code) }
 
         # Bare VariableReference, and the auto-invoke FunctionCall the
         # desugar pass synthesises for zero-arg fn refs, both dispatch via

data/lib/jade/formatter/leaves.rb

@@ -113,7 +113,18 @@ module Jade
       extend Helper
 
       def format(node, indent:, source:)
-        "#{node.name} : #{format_type(node.type)}".then(&and_indent(indent))
+        "#{node.name} : #{format_type(node.type)}#{constraints_clause(node)}"
+          .then(&and_indent(indent))
+      end
+
+      def constraints_clause(node)
+        return '' if node.constraints.empty?
+
+        node
+          .constraints
+          .map { "#{it.interface}(#{it.type_param.name})" }
+          .join(', ')
+          .then { " with #{it}" }
       end
     end
   end

data/lib/jade/frontend/forward_declaration/interface_declaration.rb

@@ -50,10 +50,14 @@ module Jade
         private
 
         def build_interface_function(entry, interface_ref, fn_decl)
-          fn_decl => AST::InterfaceFunctionDecl(name:, type:, range:)
+          fn_decl => AST::InterfaceFunctionDecl(name:, type:, constraints:, range:)
 
           figure_out_type(entry, type)
-            .map do |type_symbol|
+            .and_then do |type_symbol|
+              declared_constraints(entry, constraints)
+                .map { [type_symbol, it] }
+            end
+            .map do |(type_symbol, declared)|
               params, return_type =
                 case type_symbol
                 in Symbol::FunctionType(params:, return_type:)
@@ -63,9 +67,18 @@ module Jade
                 end
 
               Symbol
-                .interface_function(name, interface_ref, params, return_type, range)
+                .interface_function(name, interface_ref, params, return_type, range, declared)
             end
         end
+
+        def declared_constraints(entry, constraints)
+          constraints
+            .map do |constraint|
+              require_type(entry, constraint.interface, constraint.range)
+                .map { [it.to_ref.qualified_name, constraint.type_param.name] }
+            end
+            .then { Results.sequence(it) }
+        end
       end
     end
   end

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

@@ -0,0 +1,36 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class CrossModuleRequirement < Jade::Error
+          def initialize(entry, span, interface:, fn_name:, constraint:)
+            super(entry:, span:)
+            @interface  = interface
+            @fn_name    = fn_name
+            @constraint = constraint
+          end
+
+          def message
+            "Implementation of #{@interface}.#{@fn_name} requires #{@constraint}, " \
+              "but #{@interface} is declared in another module. A requirement " \
+              'can only be added to an interface this module declares'
+          end
+
+          def label
+            "requires #{@constraint}"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                'give the function a concrete type for that parameter, or move ' \
+                  'the implementation into the module that declares the interface',
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class ImplementationFunctionConstraint < Jade::Error
+          def initialize(entry, span, interface:, fn_name:, constraint:)
+            super(entry:, span:)
+            @interface  = interface
+            @fn_name    = fn_name
+            @constraint = constraint
+          end
+
+          def message
+            "Implementation of #{@interface}.#{@fn_name} requires #{@constraint}, " \
+              'whose type is not the one being implemented. An implementation ' \
+              'can only require interfaces of the type it implements'
+          end
+
+          def label
+            "requires #{@constraint}"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                'give the function a concrete type for that parameter, or move ' \
+                  'the requirement onto the type being implemented',
+              ],
+            ]
+          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

@@ -22,4 +22,7 @@ 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/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.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/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.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.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.1'
+  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.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-09-11 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -249,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
@@ -258,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
@@ -270,6 +272,7 @@ files:
 - 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
@@ -308,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