jade-lang 0.1.0

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

@@ -0,0 +1,123 @@
+require 'jade/type'
+require 'jade/frontend/type_checking/constraints'
+require 'jade/frontend/type_checking/var_gen'
+require 'jade/frontend/type_checking/error/port_not_decodable'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      # Resolves the Decode.Decodable instances each port needs for its ok/err
+      # arms. Runs at the end of type-checking, when registry.implementations
+      # is fully populated. The resolved Symbol::Implementation (or the :pass
+      # sentinel for Decode.Value / Never) is stamped onto each
+      # InteropFunction's `decoders` field so codegen can emit straight away.
+      module PortResolution
+        extend self
+
+        def resolve(entry, registry)
+          entry
+            .defined_values
+            .reduce([{}, []]) do |(values, errors), (name, sym)|
+              new_sym, new_errors = resolve_value(sym, entry, registry)
+              [
+                values.merge(name => new_sym),
+                errors + new_errors,
+              ]
+            end
+            .then { |values, errors|
+              errors.empty? \
+                ? Ok[entry.with(defined_values: values)]
+                : Err[errors]
+            }
+        end
+
+        private
+
+        def resolve_value(sym, entry, registry)
+          case sym
+          in Symbol::InteropFunction(return_type: Symbol::TypeApplication)
+            resolve_port(sym, entry, registry)
+
+          else
+            [sym, []]
+          end
+        end
+
+        def resolve_port(interop_fn, entry, registry)
+          interop_fn.return_type => Symbol::TypeApplication(args: [ok_sym, err_sym])
+
+          # Single Type.from_symbol on the whole return so a var that appears
+          # in both arms gets the same Type::Var id. PortDecoder relies on
+          # those ids to build the call-site synthetic dict_env.
+          Type
+            .from_symbol(interop_fn.return_type, registry, VarGen.new)
+            .first => Type::Application(args: [ok_type, err_type])
+
+          ok, ok_errors = resolve_arm(ok_sym, ok_type, interop_fn, :ok, entry, registry)
+          err, err_errors = resolve_arm(err_sym, err_type, interop_fn, :err, entry, registry)
+
+          [
+            interop_fn.with(decoders: { ok:, err: }),
+            ok_errors + err_errors,
+          ]
+        end
+
+        def resolve_arm(type_sym, type, interop_fn, arm, entry, registry)
+          return [Symbol::InteropFunction::PASS, []] if pass_through?(type_sym)
+
+          case type
+          in Type::Var(name:)
+            constraint_index_for(interop_fn, name)
+              .then { [Symbol::InteropFunction::Dict.new(constraint_index: it), []] }
+
+          else
+            # Concrete OR compound-with-free-var. Resolve succeeds with a
+            # partial Implementation (marker deps for free vars) thanks to
+            # the deriver fallback in decodable.rb.
+            Type
+              .constraint('Decode.Decodable', type, nil)
+              .then { Constraints.resolve(it, registry, entry.name) }
+              .then { decoder_result(it, interop_fn, arm, entry, type, span_of(type_sym, interop_fn)) }
+          end
+        end
+
+        def constraint_index_for(interop_fn, var_name)
+          interop_fn
+            .constraints
+            .index { |_iface, name| name == var_name }
+            .tap { fail "no Decodable constraint for #{var_name.inspect}" if it.nil? }
+        end
+
+        def decoder_result(constraint_result, interop_fn, arm, entry, type, span)
+          case constraint_result
+          in Ok[impl]
+            [impl, []]
+
+          in Err
+            Error::PortNotDecodable
+              .new(entry, span, port_name: interop_fn.name, arm:, type:)
+              .then { [nil, [it]] }
+          end
+        end
+
+        def span_of(type_sym, interop_fn)
+          case type_sym
+          in Symbol::TypeApplication(span:) then span
+          in Symbol::Variable(decl_span:) then decl_span
+          else interop_fn.return_type.span
+          end
+        end
+
+        def pass_through?(type_sym)
+          case type_sym
+          in Symbol::TypeApplication(constructor: Symbol::TypeRef(module_name:, name:))
+            [module_name, name] in ['Basics', 'Never'] | ['Decode', 'Value']
+
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      Result = Data.define(:type, :constraints) do
+        def self.init(type, constraints = [])
+          new(type, constraints)
+        end
+
+        def apply(substitution)
+          with(type: substitution.apply(type))
+            .with(constraints: constraints.map { substitution.apply(it) })
+        end
+
+        def map(&block)
+          block
+            .call(type)
+            .then { with(type: it) }
+        end
+
+        def attach_origin(node)
+          constraints
+            .map { it.with(origin: node) }
+            .then { with(constraints: it) }
+        end
+
+        def self.accumulator
+          ResultAcc[[], []]
+        end
+      end
+
+      ResultAcc = Data.define(:types, :constraints) do
+        def add(result)
+          with(
+            types: types + [result.type],
+            constraints: constraints + result.constraints,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      Scheme = Data.define(:quantified, :type, :constraints) do
+        def unbound_vars
+          type.unbound_vars
+        end
+
+        def free_vars
+          type.unbound_vars - quantified
+        end
+
+        def self.mono(type)
+          Scheme[[], type, []]
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,52 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      State = Data.define(:env, :errors, :skip_constraints) do
+        def self.init(env, skip_constraints: false)
+          new(env, [], skip_constraints)
+        end
+
+        def unify_result(result, right, rigid_vars = [], &block)
+          unify(result.type, right, rigid_vars, &block)
+            .then { [it, result.apply(it.env.substitution)] }
+        end
+
+        def unify(left, right, rigid_vars = [], &block)
+          applied_left = env.substitution.apply(left)
+          applied_right = env.substitution.apply(right)
+
+          case Unification.unify(applied_left, applied_right, env, Unification::Context[rigid_vars])
+          in Ok(sub)
+            with(env: env.composose_substitution(sub))
+
+          in Err(error)
+            with(
+              env: env.composose_substitution(error.partial_sub),
+              errors: errors + [block.call(error)],
+            )
+          end
+        end
+
+        def add_errors(more_errors)
+          with(errors: errors + more_errors)
+        end
+
+        def fresh
+          env.fresh
+        end
+
+        def bind(key, value)
+          with(env: env.bind(key, value))
+        end
+
+        def to_result
+          if errors.any?
+            Err[errors]
+          else
+            Ok[env]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      Substitution = Data.define(:mappings) do
+        def initialize(mappings: {})
+          super
+        end
+
+        def empty?
+          mappings.empty?
+        end
+
+        def self.empty
+          EMPTY
+        end
+
+        def apply(type)
+          case type
+          in Type::Constraint(type: constraint_type)
+            type.with(type: apply(constraint_type))
+
+          in Type::Function(args:, return_type:)
+            type.with(
+              args: args.map { apply(it) },
+              return_type: apply(return_type),
+            )
+
+          in Type::Constructor
+            type
+
+          in Type::Var(id:)
+            mapping = mappings[id]
+
+            return type unless mapping
+
+            case mapping
+            in Type::Var(id: ^id)
+              mapping
+
+            else
+              apply(mapping)
+            end
+
+          in Type::PartialApplication(constructor:, args:)
+            type.with(constructor: apply(constructor), args: args.map { apply(it) })
+
+          in Type::Application(args:)
+            case apply(type.constructor)
+            in Type::PartialApplication(constructor:, args: tail_args)
+              Type::Application[constructor, args.map { apply(it) } + tail_args]
+
+            in constructor
+              type.with(constructor:, args: args.map { apply(it) })
+            end
+
+          in Type::AnonymousRecord(fields:, row_var:)
+            applied_fields = fields.transform_values { apply(it) }
+
+            return type.with(fields: applied_fields) if type.closed?
+
+            case apply(row_var)
+            in Type::AnonymousRecord(fields: extra_fields, row_var: new_row_var)
+              Type.anonymous_record(applied_fields.merge(extra_fields), new_row_var)
+
+            in Type::Var => applied_row_var
+              type.with(fields: applied_fields, row_var: applied_row_var)
+
+            in Type::Application => struct
+              # `{γ | fields}` whose row resolved to a nominal struct
+              # collapses to the struct — the open record was always a
+              # structural query against it.
+              struct
+
+            end
+          end
+        end
+
+        def bind(name, type)
+          with(mappings: mappings.merge(name => type))
+        end
+
+        def compose(other)
+          return self if other.mappings.empty?
+          return other if mappings.empty?
+
+          Substitution[mappings.merge(other.mappings)]
+        end
+      end
+
+      Substitution::EMPTY = Substitution[{}].freeze
+    end
+  end
+end

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

@@ -0,0 +1,282 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Unification
+        extend self
+
+        Context = Data.define(:rigid_vars) do
+          def self.empty
+            new([])
+          end
+
+          def rigid?(type)
+            rigid_ids = rigid_vars.map(&:id).to_set
+            type.unbound_vars.any? { rigid_ids.include?(it.id) }
+          end
+        end
+
+        def unify(type1, type2, env, ctx = Context.empty)
+          return Ok[Substitution::EMPTY] if never?(type1) || never?(type2)
+
+          case [type1, type2]
+          in [Type::Application, Type::Application]
+            case [type1.constructor, type2.constructor]
+            in [Type::Var, _] if type1.args.length < type2.args.length
+              unify_partial(type1, type2, env, ctx)
+                .map_error { UnificationError.new(type1, type2) }
+
+            in [_, Type::Var] if type2.args.length < type1.args.length
+              unify_partial(type2, type1, env, ctx)
+                .map_error { UnificationError.new(type1, type2) }
+
+            else
+              unify(type1.constructor, type2.constructor, env, ctx)
+                .map_error { UnificationError.new(type1, type2) }
+                .and_then do |cons|
+                  unify_many(type1.args.map { cons.apply(it) }, type2.args.map { cons.apply(it) }, env, ctx)
+                    .map_both { cons.compose(it) }
+                    .map_error do |final_sub|
+                      UnificationError.new(
+                        final_sub.apply(type1),
+                        final_sub.apply(type2),
+                      )
+                    end
+                end
+            end
+
+          in [Type::Var, _]
+            return Ok[Substitution::EMPTY] if type1 == type2
+
+            if ctx.rigid?(type1)
+              if type2.is_a?(Type::Var) && !ctx.rigid?(type2)
+                return Err[UnificationError.new(type2, type1)] if occurs_in?(type2, type1)
+
+                return Ok[Substitution::EMPTY.bind(type2.id, type1)]
+              end
+
+              return Err[UnificationError.new(type1, type2)]
+            end
+
+            return Err[UnificationError.new(type1, type2)] if occurs_in?(type1, type2)
+
+            Ok[Substitution::EMPTY.bind(type1.id, type2)]
+
+          in [_, Type::Var]
+            unify(type2, type1, env, ctx)
+              .map_error(&:flip)
+
+          in [Type::Function, Type::Function]
+            unless type1.args.size == type2.args.size
+              return Err[UnificationError.new(type1, type2)]
+            end
+
+            unify_many(type1.args, type2.args, env, ctx)
+              .then do |args_r|
+                args_sub = substitution_of(args_r)
+                unify(args_sub.apply(type1.return_type), args_sub.apply(type2.return_type), env, ctx)
+                  .on_err { args_r.and_then { Err[it] } }
+                  .and_then { |sub| args_r.map_both { it.compose(sub) } }
+              end
+              .map_error do |final_sub|
+                UnificationError.new(
+                  final_sub.apply(type1),
+                  final_sub.apply(type2),
+                  final_sub,
+                )
+              end
+
+          in [Type::Constructor, Type::Constructor]
+            type1 == type2 ?
+              Ok[Substitution::EMPTY] :
+              Err[UnificationError.new(type1, type2)]
+
+          in [Type::AnonymousRecord, Type::AnonymousRecord]
+            f1 = type1.field_names
+            f2 = type2.field_names
+
+            if type1.closed? && (f2 - f1).any?
+              return Err[UnificationError.new(type1, type2)]
+            end
+
+            if type2.closed? && (f1 - f2).any?
+              return Err[UnificationError.new(type1, type2)]
+            end
+
+            unify_shared_fields(type1, type2, env, ctx)
+              .map_error do |final_sub|
+                UnificationError.new(
+                  final_sub.apply(type1),
+                  final_sub.apply(type2),
+                )
+              end
+              .and_then do |fields_r|
+                if type1.open? && type2.open?
+                  fresh_type = env.fresh
+
+                  Type
+                    .anonymous_record(type1.fields.merge(type2.fields), env.fresh)
+                    .then { Substitution::EMPTY.bind(fresh_type.id, it)}
+                    .bind(type1.row_var.id, fresh_type)
+                    .bind(type2.row_var.id, fresh_type)
+                    .compose(fields_r)
+                    .then { Ok[it] }
+
+                elsif type1.open?
+                  unify(type1.row_var, type2, env, ctx)
+                    .map { fields_r.compose(it) }
+
+                elsif type2.open?
+                  unify(type2.row_var, type1, env, ctx)
+                    .map { fields_r.compose(it) }
+
+                else
+                  Ok[fields_r]
+                end
+              end
+
+          in [Type::AnonymousRecord, Type::Application]
+            # Only OPEN anon records (record-access queries like `{a | x: T}`)
+            # can match a nominal struct. Closed records are distinct types.
+            return Err[UnificationError.new(type1, type2)] if type1.closed?
+
+            expanded = env.lookup_def(type2.constructor.name)
+
+            return Err[UnificationError.new(type1, type2)] unless expanded.is_a?(StructDef)
+
+            expanded
+              .type_params.map(&:id).zip(type2.args).to_h
+              .reduce(Substitution::EMPTY) do |acc, (k, v)|
+                acc.bind(k, v)
+              end
+              .apply(expanded.body)
+              .then { unify(type1, it, env, ctx) }
+              .and_then do |body_r|
+                unify(type1.row_var, type2, env, ctx).map { body_r.compose(it) }
+              end
+              .on_err { Err[UnificationError.new(type1, type2)] }
+
+
+          in [Type::Application, Type::AnonymousRecord]
+            unify(type2, type1, env, ctx)
+              .map_error(&:flip)
+
+          else
+            Err[UnificationError.new(type1, type2)]
+          end
+        end
+
+        private
+
+        def never?(type)
+          case type
+          in Type::Application(constructor: Type::Constructor(name: 'Basics.Never'))
+            true
+          else
+            false
+          end
+        end
+
+        def occurs_in?(var, type)
+          case type
+          in Type::Var(id:)
+            var.id == id
+
+          in Type::Application(args:)
+            occurs_in?(var, type.constructor) || args.any? { occurs_in?(var, it) }
+
+          in Type::Function(args:, return_type:)
+            args.any? { occurs_in?(var, it) } || occurs_in?(var, return_type)
+
+          in Type::PartialApplication(constructor:, args:)
+            occurs_in?(var, constructor) || args.any? { occurs_in?(var, it) }
+
+          in Type::Constraint(type: inner)
+            occurs_in?(var, inner)
+
+          in Type::AnonymousRecord(fields:, row_var:)
+            fields.values.any? { occurs_in?(var, it) } ||
+              (row_var ? occurs_in?(var, row_var) : false)
+
+          in Type::Constructor | Type::TypeUnit
+            false
+          end
+        end
+
+        def substitution_of(result)
+          case result
+          in Ok(sub) then sub
+          in Err(sub) then sub
+          end
+        end
+
+        def unify_partial(var_side, concrete_side, env, ctx)
+          head, *tail = concrete_side.args
+          partial_c   = tail.empty? ? concrete_side.constructor : Type::PartialApplication[concrete_side.constructor, tail]
+
+          unify(var_side.constructor, partial_c, env, ctx)
+            .and_then do |cons|
+              unify_many(var_side.args.map { cons.apply(it) }, [cons.apply(head)], env, ctx)
+                .map_both { cons.compose(it) }
+            end
+        end
+
+        def unify_shared_fields(type1, type2, env, ctx)
+          shared_fields = type1.field_names & type2.field_names
+          fields1 = type1.fields
+          fields2 = type2.fields
+
+          shared_fields
+            .reduce(Ok[Substitution::EMPTY]) do |subs_r, key|
+              sub = substitution_of(subs_r)
+
+              case unify(fields1[key], fields2[key], env, ctx)
+              in Err
+                next subs_r.and_then { Err[it] }
+              in Ok(k_sub)
+                subs_r.map_both { it.compose(k_sub) }
+              end
+            end
+        end
+
+        def unify_many(types1, types2, env, ctx)
+          types1
+            .zip(types2)
+            .reduce(Ok[Substitution::EMPTY]) do |subs_r, args|
+              args_r = args
+                .map { substitution_of(subs_r).apply(it) }
+                .then { unify(*it, env, ctx) }
+
+              case args_r
+              in Err
+                next subs_r.and_then { Err[it] }
+
+              in Ok(arg_sub)
+                subs_r.map_both { it.compose(arg_sub) }
+              end
+            end
+        end
+
+        class UnificationError
+          attr_reader :expected, :actual, :partial_sub
+
+          def initialize(actual, expected, partial_sub = nil)
+            @actual = actual
+            @expected = expected
+            @partial_sub = partial_sub || Substitution::EMPTY
+          end
+
+          def flip
+            old_expected = @expected
+            @expected = @actual
+            @actual = old_expected
+            self
+          end
+
+          def message
+            "Cannot unify #{expected} with #{actual}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      # Type-var ids must be unique across every scheme that ever flows
+      # through unification. Per-instance counters made cross-module
+      # imports fragile: a fresh id from one module could equal a
+      # quantified id from another, aliasing them through
+      # Substitution.apply. A class-level counter makes collisions
+      # impossible by construction.
+      class VarGen
+        @counter = 0
+
+        class << self
+          attr_accessor :counter
+        end
+
+        def fresh_id
+          "t#{self.class.counter += 1}"
+        end
+
+        def fresh(name = nil)
+          fresh_id
+            .then { Type.var(it, name) }
+        end
+
+        def next(name)
+          "#{name}#{self.class.counter += 1}"
+            .then { Type.var(it, name) }
+        end
+      end
+    end
+  end
+end