jade-lang 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38f4067e761c85016ad9baa6c733e6567aa93eea5cc0ffb755c0ac469a6a0002
-  data.tar.gz: 97dd4372b13bcb7e23bdc3ac2dcbe231d067410e9a99634afbbd3bd1a485452e
+  metadata.gz: 7b817b13aad1b314b6a8bf578f8a604246d19091712a77375376515732b6dcbc
+  data.tar.gz: 7be6b4091ac7c57c6befe21fb0ffbea302b9e33bd2940479b7c4227dd37cd1b6
 SHA512:
-  metadata.gz: 415bcc6027fbefa912960d30c004d3d442000b37d6b3e6a27485b9ef9a12685bad3dc79855f7ccd99378987ea38fb6810fafe8f371dad5c50ce9b605c464f756
-  data.tar.gz: 8891cbe3dfe48e80cdb2ae73ec96a13b09a3adc8287adf812e7a30639ca4918b417cc02e45148222bacd2f7b1d412b58ce78d15f783dceed0868d0175e194daf
+  metadata.gz: 9b758da80e8b9033dd6b5ce840188f7d69a8d482cf496a3731c4a4f7b5bcb90ddd0119e5b5eb6e9b1763bddffca4f3df49b6cba7d6a26d9304538efde7a8aa49
+  data.tar.gz: 22abc8374f37d7f9ff3c03f5f2a35861322f234227c3d0932e80c56e17bb49de5ce6ac67dc7c1f0b1896ce2b9a5c3562a2d8197f697f74fdd5d18e5db64094f6

data/CHANGELOG.md

@@ -6,10 +6,60 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Added
+
+- **`Jade::Extensions`, where a gem hooks into compilation.** Two kinds, both
+  read-only: a *deriver* builds an implementation for an interface it owns,
+  and a *check* reads a call site and returns errors. Checks register against
+  a named phase — `:call` today — and receive the call's AST node alongside
+  its resolved argument types, because types alone cannot see a raw SQL
+  string's placeholders or a constant predicate. Only gems named in
+  `Extensions::ALLOWED` may register, so the compiler knows who extends it and
+  nothing about what they do.
+
+### Changed
+
+- **The `Sql.Assignable` deriver moves to jade-sql.** The deriver list named
+  jade-sql's interface outright, with a comment apologising for it; it now
+  holds only the built-ins and whatever an allowed gem registers.
+
+### Fixed
+
+- **A long chain of `Task.and_then` no longer exhausts the Ruby stack.** Each
+  `and_then` ran the next task from inside the previous one's `run`, so depth
+  cost a stack frame and anything built by recursion, a batch loop or a retry,
+  died with `SystemStackError` somewhere past ten thousand links. `run` now
+  drives an explicit stack of continuations from one loop, so a chain is
+  bounded by memory: 500,000 links run where 100,000 used to fail.
+
+- **Two implementations for the same head type is now an error.** An
+  implementation is registered under `[interface, head type]`, so a second
+  `implements Assignable(Box(Cols2, Val2))` overwrote
+  `implements Assignable(Box(Cols, Val))` and every call — including ones whose
+  types matched the first — dispatched to the second. It compiled clean and
+  died at run time in the implementation body, or worse, didn't. The second
+  declaration is now reported, with the first as a secondary label and a note
+  that type arguments do not select between implementations. Duplicates can
+  only arise within one module: the orphan rule and cycle detection between
+  them rule out the cross-module case.
+
 ## [0.8.0]
 
 ### Added
 
+- **A struct written to a table is checked against its columns.** jade-sql maps
+  a struct's fields onto columns by name, and the mapping derives, so nothing
+  compared the two — a field the table has no column for reached Postgres as
+  invalid SQL, and a field whose type disagreed with its column failed at
+  decode. Calls to `Sql.Mutation.insert`, `insert_all` and `update` now report
+  both at compile time, naming the field. Both types are concrete at the call
+  site, so this is a check rather than anything the type system has to carry.
+  A call through a generic helper of your own has neither type in hand and
+  stays unchecked. Inert without jade-sql, since nothing else declares those
+  functions.
+
+### 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
@@ -83,7 +133,6 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   anonymous record. A project that CI-checks committed artifacts will see a
   diff.
 
-
 ## [0.6.0]
 
 ### Fixed

data/lib/jade/error.rb

@@ -21,6 +21,10 @@ module Jade
       []
     end
 
+    def secondary
+      []
+    end
+
     def queried_name
       nil
     end
@@ -39,6 +43,7 @@ module Jade
       Jade::Diagnostics::Diagnostic.error(
         message,
         primary: Jade::Diagnostics::Label[source, span, label],
+        secondary: secondary.map { |sp, text| Jade::Diagnostics::Label[source, sp, text] },
         annotations: notes + did_you_mean_notes,
       )
     end

data/lib/jade/extensions.rb

@@ -0,0 +1,70 @@
+module Jade
+  # Where an extension gem hooks into compilation. Only gems named in ALLOWED
+  # may register, so jade knows who extends it and nothing about what they do.
+  module Extensions
+    extend self
+
+    ALLOWED = %w[jade-sql].freeze
+    PHASES = %i[call].freeze
+
+    class NotAllowed < StandardError
+      def initialize(gem_name)
+        super(
+          "#{gem_name} may not extend the compiler; " \
+            "allowed: #{ALLOWED.join(', ')}"
+        )
+      end
+    end
+
+    class UnknownPhase < StandardError
+      def initialize(phase)
+        super("no such check phase #{phase.inspect}; known: #{PHASES.join(', ')}")
+      end
+    end
+
+    def register_deriver(gem_name, deriver)
+      allow!(gem_name)
+      @derivers = derivers | [deriver]
+    end
+
+    # A `:call` check answers `watches -> [qualified name]` and
+    # `check(context) -> [error]`. Watching by name keeps every other call in
+    # the program off the check's path entirely.
+    def register_check(gem_name, phase, check)
+      allow!(gem_name)
+      fail UnknownPhase.new(phase) unless PHASES.include?(phase)
+
+      @call_checks = check
+        .watches
+        .reduce(call_checks) { |acc, name| acc.merge(name => acc.fetch(name, []) | [check]) }
+    end
+
+    def derivers = @derivers ||= []
+
+    def call_checks = @call_checks ||= {}
+
+    # The node travels with the types because a literal's value — a SQL string,
+    # a constant predicate — is not in them.
+    CallContext = Data.define(:name, :arg_types, :node, :registry, :entry_name, :span)
+
+    def check_call(name, arg_types, node, registry, entry_name, span)
+      call_checks[name].then do |watching|
+        next [] if watching.nil?
+
+        CallContext[name, arg_types, node, registry, entry_name, span]
+          .then { |ctx| watching.flat_map { it.check(ctx) } }
+      end
+    end
+
+    def reset!
+      @derivers = []
+      @call_checks = {}
+    end
+
+    private
+
+    def allow!(gem_name)
+      fail NotAllowed.new(gem_name) unless ALLOWED.include?(gem_name)
+    end
+  end
+end

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

@@ -24,9 +24,37 @@ module Jade
             end
 
           analyze_in_sequence(expressions, registry, scope, entry)
-            .add_errors(duplicate_errors)
+            .add_errors(duplicate_errors + duplicate_implementation_errors(expressions, entry))
             .map_node { node.with(expressions: it) }
         end
+
+        private
+
+        def duplicate_implementation_errors(expressions, entry)
+          expressions
+            .select { it.is_a?(AST::Implementation) }
+            .group_by { implementation_key(it, entry) }
+            .reject { |key, impls| key.nil? || impls.size < 2 }
+            .flat_map do |(interface, type), (first, *rest)|
+              rest.map do |dup|
+                Error::DuplicateImplementation.new(
+                  entry.name,
+                  dup.range,
+                  interface:,
+                  type:,
+                  first_span: first.range,
+                  parameterized: dup.applied_type.args.any?,
+                )
+              end
+            end
+        end
+
+        def implementation_key(node, entry)
+          interface = entry.lookup_type(node.interface)
+          type = lookup_applied_type(node.applied_type, entry)
+
+          [interface.qname, type.qname] if interface && type
+        end
       end
     end
   end

data/lib/jade/frontend/semantic_analysis/error/duplicate_implementation.rb

@@ -0,0 +1,39 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class DuplicateImplementation < Jade::Error
+          def initialize(entry, span, interface:, type:, first_span:, parameterized:)
+            @interface = interface
+            @type = type
+            @first_span = first_span
+            @parameterized = parameterized
+            super(entry:, span:)
+          end
+
+          def message
+            "Duplicate implementation of #{@interface} for #{@type}"
+          end
+
+          def label
+            "already implemented"
+          end
+
+          def secondary
+            [[@first_span, 'first implemented here']]
+          end
+
+          def notes
+            return [] unless @parameterized
+
+            [Jade::Diagnostics::Annotation[
+              :note,
+              "an implementation is chosen by the head type `#{@type}` alone — " \
+                'its type arguments do not select between implementations',
+            ]]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,7 @@ require 'jade/frontend/semantic_analysis/error/constructor_pattern_arity_mismatc
 require 'jade/frontend/semantic_analysis/error/duplicate_field'
 require 'jade/frontend/semantic_analysis/error/placeholder_not_allowed'
 require 'jade/frontend/semantic_analysis/error/duplicate_function_declaration'
+require 'jade/frontend/semantic_analysis/error/duplicate_implementation'
 require 'jade/frontend/semantic_analysis/error/duplicate_record_field'
 require 'jade/frontend/semantic_analysis/error/invalid_list_rest_pattern'
 require 'jade/frontend/semantic_analysis/error/kwargs_on_non_constructor'

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

@@ -49,6 +49,16 @@ module Jade
           Result[results.map(&:node), results.flat_map(&:errors), scope]
         end
 
+        private def lookup_applied_type(applied_type, entry)
+          case applied_type.constructor
+          in AST::TypeName(type:)
+            entry.lookup_type(type)
+          in AST::QualifiedTypeName(path:)
+            *module_parts, type_name = path
+            entry.lookup_qualified_type(module_parts.join('.'), type_name)
+          end
+        end
+
         def analyze_duplicate_fields(fields, entry)
           fields
             .group_by(&:key)

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

@@ -73,16 +73,6 @@ module Jade
 
         private
 
-        def lookup_applied_type(applied_type, entry)
-          case applied_type.constructor
-          in AST::TypeName(type:)
-            entry.lookup_type(type)
-          in AST::QualifiedTypeName(path:)
-            *module_parts, type_name = path
-            entry.lookup_qualified_type(module_parts.join('.'), type_name)
-          end
-        end
-
         def local_type_name(applied_type)
           case applied_type.constructor
           in AST::TypeName(type:) then type

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

@@ -2,7 +2,6 @@ require_relative './deriving/helpers.rb'
 require_relative './deriving/eq.rb'
 require_relative './deriving/decodable.rb'
 require_relative './deriving/encodable.rb'
-require_relative './deriving/assignable.rb'
 require_relative './deriving/show.rb'
 
 module Jade
@@ -12,14 +11,16 @@ module Jade
         module Deriving
           extend self
 
-          DERIVERS = [Eq, Show, Decodable, Encodable, Assignable]
+          BUILTIN = [Eq, Show, Decodable, Encodable].freeze
+
+          def derivers = BUILTIN + Extensions.derivers
 
           def derivable?(interface)
-            DERIVERS.any? { it.supports?(interface) }
+            derivers.any? { it.supports?(interface) }
           end
 
           def derive(constraint, registry, entry_name, &lookup)
-            DERIVERS
+            derivers
               .find { it.supports?(constraint.interface) }
               .then { it.derive(constraint, registry, entry_name, &lookup) }
           end

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

@@ -102,8 +102,17 @@ module Jade
                   end
                 end
 
+              column_errors = Extensions.check_call(
+                callee_name(callee),
+                args_acc.types.map { st.env.substitution.apply(it) },
+                node,
+                registry,
+                st.env.entry_name,
+                node.range,
+              )
+
               st
-                .add_errors(callee_errors + args_errors)
+                .add_errors(callee_errors + args_errors + column_errors)
                 .then { [it, base_rs.with(constraints: propagated)] }
             end
           end
@@ -114,6 +123,17 @@ module Jade
           # 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.
+          # A call through a local binding or a lambda has no name to give a
+          # check, which asks by qualified name.
+          def callee_name(callee)
+            case callee
+            in AST::VariableReference(symbol: Symbol::Variable) then nil
+            in AST::VariableReference(symbol:) then symbol.qualified_name
+            in AST::QualifiedAccess(symbol:) then symbol.qualified_name
+            else nil
+            end
+          end
+
           def propagate(constraint, registry, entry_name)
             return [constraint] if constraint.type.is_a?(Type::Var)
             return [] if constraint.unbound_vars.empty?

data/lib/jade/task.rb

@@ -2,101 +2,121 @@ require 'jade/tasks'
 
 module Jade
   module Task
-    Literal = Data.define(:result) do
-      include Task
-
-      def run
-        result
-      end
-    end
-
-    Dispatch = Data.define(:task_def, :args) do
-      include Task
-
-      def run
-        Jade::Tasks.dispatch(task_def, *args)
-      end
-    end
-
-    Map = Data.define(:task, :fn) do
-      include Task
-
-      def run
-        case task.run
-        in Jade::Result::Ok[value]  then Jade::Result::Ok[fn.call(value)]
-        in Jade::Result::Err => err then err
+    # Every node is a value describing work, and `run` drives them from one
+    # loop with an explicit stack of continuations. Composing tasks therefore
+    # costs heap, not Ruby stack, so a chain built by recursion (a batch loop,
+    # a retry) is bounded by memory rather than by SystemStackError.
+    def run
+      task = self
+      pending = []
+
+      loop do
+        case task
+        in AndThen[inner, fn]
+          task = inner
+          pending << [:ok, fn]
+
+        in OnError[inner, fn]
+          task = inner
+          pending << [:err, fn]
+
+        in Map[inner, fn]
+          task = inner
+          pending << [:map, fn]
+
+        in MapError[inner, fn]
+          task = inner
+          pending << [:map_err, fn]
+
+        in Decoded[inner, ok_decoder, err_decoder]
+          task = inner
+          pending << [:decode, [ok_decoder, err_decoder]]
+
+        else
+          result = task.step
+          return result if pending.empty?
+
+          task = resume(result, pending)
+          return task if task.is_a?(Jade::Result::Ok) || task.is_a?(Jade::Result::Err)
         end
       end
     end
 
-    AndThen = Data.define(:task, :fn) do
-      include Task
-
-      def run
-        case task.run
-        in Jade::Result::Ok[value]  then fn.call(value).run
-        in Jade::Result::Err => err then err
-        end
+    private
+
+    # Applies continuations to a settled result until one of them produces a
+    # fresh task to run, or the stack empties.
+    def resume(result, pending)
+      until pending.empty?
+        kind, fn = pending.pop
+
+        result =
+          case [kind, result]
+          in [:decode, _] then Decoded.decode_result(result, *fn)
+          in [:ok, Jade::Result::Ok[value]] then return fn.call(value)
+          in [:err, Jade::Result::Err[error]] then return fn.call(error)
+          in [:map, Jade::Result::Ok[value]] then Jade::Result::Ok[fn.call(value)]
+          in [:map_err, Jade::Result::Err[error]] then Jade::Result::Err[fn.call(error)]
+          else result
+          end
       end
+
+      result
     end
 
-    OnError = Data.define(:task, :fn) do
+    Literal = Data.define(:result) do
       include Task
 
-      def run
-        case task.run
-        in Jade::Result::Ok => ok    then ok
-        in Jade::Result::Err[error]  then fn.call(error).run
-        end
+      def step
+        result
       end
     end
 
-    MapError = Data.define(:task, :fn) do
+    Dispatch = Data.define(:task_def, :args) do
       include Task
 
-      def run
-        case task.run
-        in Jade::Result::Ok => ok    then ok
-        in Jade::Result::Err[error]  then Jade::Result::Err[fn.call(error)]
-        end
+      def step
+        Jade::Tasks.dispatch(task_def, *args)
       end
     end
 
     Sequence = Data.define(:tasks) do
       include Task
 
-      def run
+      def step
         values = []
+
         tasks.each do |task|
           case task.run
           in Jade::Result::Ok[value] then values << value
           in Jade::Result::Err => err then return err
           end
         end
+
         Jade::Result::Ok[values]
       end
     end
 
+    Map = Data.define(:task, :fn) { include Task }
+    AndThen = Data.define(:task, :fn) { include Task }
+    OnError = Data.define(:task, :fn) { include Task }
+    MapError = Data.define(:task, :fn) { include Task }
+
     Decoded = Data.define(:task, :ok_decoder, :err_decoder) do
       include Task
 
-      def run
-        case task.run
-        in Jade::Result::Ok[value]
-          Jade::Result::Ok[decode(ok_decoder, value)]
-        in Jade::Result::Err[error]
-          Jade::Result::Err[decode(err_decoder, error)]
+      def self.decode_result(result, ok_decoder, err_decoder)
+        case result
+        in Jade::Result::Ok[value]  then Jade::Result::Ok[decode(ok_decoder, value)]
+        in Jade::Result::Err[error] then Jade::Result::Err[decode(err_decoder, error)]
         end
       end
 
-      private
-
-      def decode(decoder, value)
+      def self.decode(decoder, value)
         Jade::Decode::Runner.run!(decoder, value) do |error|
           fail Jade::Interop::DecodeError.new(error, value, source: :port_return)
         end
       end
     end
-
   end
 end

data/lib/jade/version.rb

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

data/lib/jade.rb

@@ -1,4 +1,5 @@
 require 'jade/version'
+require 'jade/extensions'
 require 'jade/project'
 require 'jade/did_you_mean'
 require 'jade/symbol'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-08-19 00:00:00.000000000 Z
+date: 2026-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -93,6 +93,7 @@ files:
 - lib/jade/did_you_mean.rb
 - lib/jade/entry.rb
 - lib/jade/error.rb
+- lib/jade/extensions.rb
 - lib/jade/formatter.rb
 - lib/jade/formatter/accesses.rb
 - lib/jade/formatter/bindings.rb
@@ -157,6 +158,7 @@ files:
 - lib/jade/frontend/semantic_analysis/error/constructor_pattern_arity_mismatch.rb
 - lib/jade/frontend/semantic_analysis/error/duplicate_field.rb
 - lib/jade/frontend/semantic_analysis/error/duplicate_function_declaration.rb
+- lib/jade/frontend/semantic_analysis/error/duplicate_implementation.rb
 - lib/jade/frontend/semantic_analysis/error/duplicate_record_field.rb
 - lib/jade/frontend/semantic_analysis/error/invalid_list_rest_pattern.rb
 - lib/jade/frontend/semantic_analysis/error/kwargs_on_non_constructor.rb
@@ -218,7 +220,6 @@ 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

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

@@ -1,170 +0,0 @@
-module Jade
-  module Frontend
-    module TypeChecking
-      module Constraints
-        module Deriving
-          # 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 Assignable
-            extend self
-            include Helpers
-
-            INTERFACE = 'Sql.Assignable'
-            ASSIGNMENT = 'Sql.Assignment'
-            ASSIGNMENT_FIELDS = %w[col value_sql params].freeze
-
-            def supports?(interface) = interface == INTERFACE
-
-            def derive(constraint, registry, entry_name, &lookup)
-              return failed(constraint, entry_name) unless assignment_matches?(registry)
-
-              case constraint.type
-              in Type::Application(constructor: Type::Constructor(name:), args:)
-                Symbol
-                  .type_ref_from_qualified_name(name)
-                  .then { registry.lookup(it) }
-                  .then { derive_for(constraint, it, args, registry, lookup, entry_name) }
-
-              else
-                failed(constraint, entry_name)
-              end
-            end
-
-            private
-
-            # The interface is matched by name, so some other module called
-            # `Sql` would otherwise be derived against as though it were
-            # jade-sql — building its Assignment with the wrong arity, and
-            # failing at runtime rather than here.
-            def assignment_matches?(registry)
-              Symbol
-                .type_ref_from_qualified_name(ASSIGNMENT)
-                .then { registry.lookup(it) }
-                .then do
-                  it in Symbol::Struct(record_type: { fields: }) and
-                    fields.keys.map(&:to_s) == ASSIGNMENT_FIELDS
-                end
-            end
-
-            def derive_for(constraint, symbol, args, registry, lookup, entry_name)
-              case symbol
-              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
-            end
-
-            # One column per variant, so each variant carries exactly the
-            # value that column is set to.
-            def single_payload?(union_sym, registry)
-              variants(union_sym, registry)
-                .then { it.any? && it.all? { it.args.size == 1 } }
-            end
-
-            def derive_union(constraint, union_sym, registry, lookup, entry_name)
-              vs = variants(union_sym, registry)
-
-              vs
-                .map { encodable_dep(it, registry) }
-                .map { lookup.call(it) }
-                .then { Results.sequence(it) }
-                .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
-                .first
-                .then { instantiate(it, {}, registry) }
-                .then { Type.constraint('Encode.Encodable', it, nil) }
-            end
-
-            def union_body(variants)
-              variants
-                .each_with_index
-                .map { |v, idx| [[:constructor, v.qualified_name, ['x']], [assignment(v, idx)]] }
-                .then { [:case, [:var, 'f'], it] }
-            end
-
-            def assignment(variant, idx)
-              [:call,
-                [:struct_constructor, ASSIGNMENT, 3],
-                [
-                  wire_name(variant),
-                  '?',
-                  [:list, [[:call, [:impl_arg, idx, 'encoder'], [[:var, 'x']]]]],
-                ],
-              ]
-                .then { [:list, [it]] }
-            end
-
-            def failed(constraint, entry_name)
-              Err[
-                Error::DerivationFailed.new(
-                  entry_name, constraint.origin&.range, constraint:, trace: [],
-                )
-              ]
-            end
-
-            def implementation(constraint, body, deps)
-              Symbol::Implementation.new(
-                module_name: nil,
-                interface: Symbol.type_ref_from_qualified_name(constraint.interface),
-                type: constraint.type,
-                type_params: [],
-                constraints: [],
-                functions: { 'to_assigns' => Symbol::DerivedFunction.new(params: ['f'], body:) },
-                deps:,
-                extends: [],
-                decl_span: nil,
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end