jade-lang 0.1.0

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

@@ -0,0 +1,144 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        module Deriving
+          module Encodable
+            extend self
+            include Helpers
+
+            INTERFACE = 'Encode.Encodable'
+
+            def supports?(interface)
+              interface == INTERFACE
+            end
+
+            def derive(constraint, registry, entry_name, &lookup)
+              case constraint.type
+              in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [inner])
+                derive_list(constraint, inner, lookup, entry_name)
+
+              in Type::Application(constructor: Type::Constructor(name: 'Maybe.Maybe'), args: [inner])
+                derive_nullable(constraint, inner, lookup, entry_name)
+
+              in Type::Application(constructor: Type::Constructor(name:), args:)
+                resolved_sym = Symbol
+                  .type_ref_from_qualified_name(name)
+                  .then { registry.lookup(it) }
+
+                case resolved_sym
+                in Symbol::Struct
+                  derive_struct(constraint, resolved_sym, args, registry, lookup, entry_name)
+
+                else
+                  failed(constraint, entry_name)
+                end
+
+              else
+                failed(constraint, entry_name)
+              end
+            end
+
+            private
+
+            def failed(constraint, entry_name)
+              Err[
+                Error::DerivationFailed.new(
+                  entry_name,
+                  constraint.origin&.range,
+                  constraint:,
+                  trace: [],
+                )
+              ]
+            end
+
+            def derive_list(constraint, inner_type, lookup, entry_name)
+              dep = Type.constraint(INTERFACE, inner_type, nil)
+
+              lookup.call(dep).and_then do |dep_impl|
+                body = [:call,
+                  [:stdlib_fn, 'Encode.list'],
+                  [
+                    [:impl_arg, 0, 'encoder'],
+                    [:var, 'items'],
+                  ],
+                ]
+
+                Ok[implementation(constraint, params: ['items'], body:, deps: [dep_impl])]
+              end
+            end
+
+            def derive_nullable(constraint, inner_type, lookup, entry_name)
+              dep = Type.constraint(INTERFACE, inner_type, nil)
+
+              lookup.call(dep).and_then do |dep_impl|
+                body = [:call,
+                  [:stdlib_fn, 'Encode.nullable'],
+                  [
+                    [:impl_arg, 0, 'encoder'],
+                    [:var, 'maybe'],
+                  ],
+                ]
+
+                Ok[implementation(constraint, params: ['maybe'], body:, deps: [dep_impl])]
+              end
+            end
+
+            def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)
+              fields = struct_fields(struct_sym, type_args, registry)
+
+              field_deps = fields
+                .map { |_, field_type| Type.constraint(INTERFACE, field_type, nil) }
+
+              resolved_deps = field_deps
+                .map do |dep|
+                  lookup.call(dep) => Ok[impl]
+                  impl
+                end
+
+              pair_irs = fields
+                .each_with_index
+                .map do |(field_name, _), idx|
+                  [:call,
+                    [:stdlib_fn, 'Tuple.pair'],
+                    [
+                      field_name.to_s,
+                      [:call,
+                        [:impl_arg, idx, 'encoder'],
+                        [[:access, [:var, 'rec'], field_name.to_s]],
+                      ],
+                    ],
+                  ]
+                end
+
+              body = [:call,
+                [:stdlib_fn, 'Encode.object'],
+                [
+                  [:list, pair_irs],
+                ],
+              ]
+
+              Ok[implementation(constraint, params: ['rec'], body:, deps: resolved_deps)]
+            end
+
+            def implementation(constraint, params:, body:, deps:)
+              encoder_fn = Symbol::DerivedFunction.new(params:, body:)
+
+              Symbol::Implementation.new(
+                module_name: nil,
+                interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                type: constraint.type,
+                type_params: [],
+                constraints: [],
+                functions: { 'encoder' => encoder_fn },
+                deps:,
+                extends: [],
+                decl_span: nil,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,265 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        module Deriving
+          module Eq
+            extend self
+            include Helpers
+
+            INTERFACE = 'Basics.Eq'
+
+            def supports?(interface) = interface == INTERFACE
+
+            def derive(constraint, registry, entry_name, &lookup)
+              resolve(constraint, registry, entry_name, lookup)
+            end
+
+            private
+
+            def resolve(constraint, registry, entry_name, lookup)
+              case [constraint.interface, constraint.type]
+              in [INTERFACE, Type::Application(constructor:, args:)]
+                registry
+                  .implementations[[constraint.interface, constructor.name]]
+                  .then do
+                    it \
+                      ? Ok[it]
+                      : derive_for_type(constraint, constructor, args, registry, lookup, entry_name)
+                  end
+                  .on_err { return Err[it] } => Ok(impl)
+
+                case impl
+                in Symbol::ImplementationTemplate
+                  deps = dependencies_of(impl, args)
+                  resolved_deps = deps.filter_map { |dep|
+                    next if dep.type in Type::Var
+                    lookup.call(dep) => Ok[resolved]; resolved
+                  }
+
+                  Symbol::Implementation.new(
+                    module_name: nil,
+                    interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                    type: constraint.type,
+                    type_params: args,
+                    constraints: deps,
+                    functions: impl.functions,
+                    deps: resolved_deps,
+                    extends: [],
+                    decl_span: nil,
+                  )
+
+                else
+                  impl
+                end
+                  .then { Ok[it] }
+
+              in [INTERFACE, Type::AnonymousRecord(fields:)]
+                derive_record_eq(constraint, fields, lookup)
+
+              else
+                Err[
+                  Error::DerivationFailed
+                    .new(entry_name, constraint.origin.range, constraint:, trace: [])
+                ]
+              end
+            end
+
+            def dependencies_of(impl, args)
+              subst = impl
+                .type_params
+                .map(&:id)
+                .zip(args)
+                .to_h
+
+              impl
+                .constraints
+                .map { it.with(type: substitute_type(it.type, subst)) }
+            end
+
+            def substitute_type(type, subst)
+              case type
+
+              in Type::Var(id:)
+                subst.fetch(id, type)
+
+              in Type::Application(constructor:, args:)
+                Type::Application.new(
+                  constructor: constructor,
+                  args: args.map { substitute_type(it, subst) }
+                )
+
+              in Type::AnonymousRecord(fields:)
+                Type::AnonymousRecord.new(
+                  fields: fields.transform_values { substitute_type(it, subst) }
+                )
+
+              else
+                type
+              end
+            end
+
+            def derive_for_type(constraint, constructor, args, registry, lookup, entry_name)
+              symbol =
+                Symbol
+                  .type_ref_from_qualified_name(constructor.name)
+                  .then { registry.lookup(it) }
+
+              case symbol
+              in Symbol::Union
+                Ok[derive_union_eq(constraint, symbol, registry, lookup)]
+
+              in Symbol::Struct
+                derive_struct_eq(constraint, symbol, args, registry, lookup, entry_name)
+
+              else
+                Err[
+                  Error::DerivationFailed
+                    .new(entry_name, constraint.origin.range, constraint:, trace: [])
+                ]
+              end
+            end
+
+            def derive_union_eq(constraint, symbol, registry, lookup)
+              type_vars = symbol.type_params.map(&:name)
+              index_map = type_vars.each_with_index.map.to_h
+
+              cases = symbol.variants
+                .map { registry.lookup(it) }
+                .map { build_variant_case(it, index_map, lookup, constraint.origin) }
+
+              eq_fn = Symbol::DerivedFunction.new(
+                params: ["one", "other"],
+                body: [:case,
+                  [:list, [[:var, "one"], [:var, "other"]]],
+                  cases + [[[:_], [false]]],
+                ],
+              )
+
+              if type_vars.empty?
+                Symbol::Implementation.new(
+                  module_name: nil,
+                  interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                  type: constraint.type,
+                  type_params: [],
+                  constraints: [],
+                  functions: { '(==)' => eq_fn },
+                  deps: [],
+                  extends: [],
+                  decl_span: nil,
+                )
+              else
+                Symbol::ImplementationTemplate.new(
+                  interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                  type: constraint.type,
+                  type_params: type_vars.map { Type.var(it) },
+                  constraints: type_vars.map {
+                    Type.constraint(INTERFACE, Type.var(it), constraint.origin)
+                  },
+                  functions: { '(==)' => eq_fn },
+                )
+              end
+            end
+
+            def build_variant_case(variant, index_map, lookup, origin)
+              field_count = variant.args.length
+
+              left_vars  = (0...field_count).map { |i| "l#{i}" }
+              right_vars = (0...field_count).map { |i| "r#{i}" }
+
+              left_pattern  = [:constructor, variant.qualified_name, left_vars]
+              right_pattern = [:constructor, variant.qualified_name, right_vars]
+
+              comparisons =
+                variant.args.each_with_index.map do |arg_type, i|
+                  case arg_type
+
+                  in Symbol::Variable(name:)
+                    idx = index_map[name]
+
+                    [:call,
+                      [:impl_arg, idx, "(==)"],
+                      [[:var, left_vars[i]], [:var, right_vars[i]]]
+                    ]
+
+                  else
+                    lookup.call(Type.constraint(INTERFACE, arg_type, origin)) => Ok[impl]
+
+                    [:call,
+                      [:impl_value, impl, "(==)"],
+                      [[:var, left_vars[i]], [:var, right_vars[i]]]
+                    ]
+                  end
+                end
+
+              body =
+                if comparisons.empty?
+                  [true]
+                else
+                  first_comparison, *rest = comparisons
+                  [rest.reduce(first_comparison) { |acc, item| [:and, acc, item] }]
+                end
+
+              [[:list, [left_pattern, right_pattern]], body]
+            end
+
+            def derive_record_eq(constraint, fields, lookup)
+              field_types = fields.values
+              field_keys  = fields.keys
+
+              resolve_field_deps(field_types, lookup, constraint.origin)
+                .and_then do |deps|
+                  field_keys
+                    .each_with_index.map { |field_name, idx|
+                      left  = [:access, [:var, 'one'],   field_name]
+                      right = [:access, [:var, 'other'], field_name]
+                      [:call, [:impl_arg, idx, '(==)'], [left, right]]
+                    }
+                    .then { build_record_impl(constraint, it, deps) }
+                    .then { Ok[it] }
+              end
+            end
+
+            def derive_struct_eq(constraint, struct_sym, type_args, registry, lookup, entry_name)
+              fields      = struct_fields(struct_sym, type_args, registry)
+              field_types = fields.map { |_, t| t }
+              field_names = fields.map { |k, _| k.to_s }
+
+              resolve_field_deps(field_types, lookup, constraint.origin).and_then do |deps|
+                comparisons = field_names.each_with_index.map { |field_name, idx|
+                  left  = [:access, [:var, 'one'],   field_name]
+                  right = [:access, [:var, 'other'], field_name]
+                  [:call, [:impl_arg, idx, '(==)'], [left, right]]
+                }
+                Ok[build_record_impl(constraint, comparisons, deps)]
+              end
+            end
+
+            def resolve_field_deps(field_types, lookup, origin)
+              field_types
+                .map { lookup.call(Type.constraint(INTERFACE, it, origin)) }
+                .then { Results.sequence(it) }
+            end
+
+            def build_record_impl(constraint, comparisons, deps)
+              body = comparisons.empty? ? true : comparisons.reduce { |a, b| [:and, a, b] }
+              eq_fn = Symbol::DerivedFunction.new(params: ['one', 'other'], body:)
+
+              Symbol::Implementation.new(
+                module_name: nil,
+                interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                type: constraint.type,
+                type_params: [],
+                constraints: [],
+                functions: { '(==)' => eq_fn },
+                deps:,
+                extends: [],
+                decl_span: nil,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        module Deriving
+          module Helpers
+            extend self
+
+            def struct_fields(struct_sym, type_args, registry)
+              record = struct_sym.record_type
+              type_param_names = struct_sym.type_params.map(&:name)
+              subst = type_param_names.zip(type_args).to_h
+
+              record
+                .fields
+                .map { |name, sym| [name, instantiate(sym, subst, registry)] }
+            end
+
+            def instantiate(sym, subst, registry)
+              case sym
+              in Symbol::Variable(name:)
+                subst.fetch(name) { Type.var(nil, name) }
+
+              in Symbol::TypeApplication(constructor:, args:)
+                inner_args = args
+                  .map { instantiate(it, subst, registry) }
+
+                Symbol
+                  .type_ref(constructor.module_name, constructor.name)
+                  .then { registry.lookup(it) }
+                  .then { type_application_to_type(it, inner_args) }
+
+              in Symbol::TypeRef
+                registry
+                  .lookup(sym)
+                  .then { type_application_to_type(it, []) }
+
+              in Symbol::FunctionType(params:, return_type:)
+                Type.function(
+                  params.map { instantiate(it, subst, registry) },
+                  instantiate(return_type, subst, registry),
+                )
+              end
+            end
+
+            def type_application_to_type(sym, args)
+              case sym
+              in Symbol::Union | Symbol::Struct
+                Type
+                  .constructor(sym.qualified_name)
+                  .apply(args)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require_relative './deriving/helpers.rb'
+require_relative './deriving/eq.rb'
+require_relative './deriving/decodable.rb'
+require_relative './deriving/encodable.rb'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        module Deriving
+          extend self
+
+          DERIVERS = [Eq, Decodable, Encodable]
+
+          def derivable?(interface)
+            DERIVERS.any? { it.supports?(interface) }
+          end
+
+          def derive(constraint, registry, entry_name, &lookup)
+            DERIVERS
+              .find { it.supports?(constraint.interface) }
+              .then { it.derive(constraint, registry, entry_name, &lookup) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'jade/frontend/type_checking/constraints/deriving'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        extend self
+
+        def resolve(constraint, registry, entry_name)
+          if constraint.type in Type::Var
+            Error::UnresolvedConstraint
+              .new(entry_name, constraint.origin&.range, constraint:)
+              .then { return Err[it] }
+          end
+
+          if impl = lookup(constraint, registry)
+            impl
+              .extends
+              .map do |iface_ref|
+                Type
+                  .constraint(
+                    iface_ref.qualified_name,
+                    constraint.type,
+                    constraint.origin,
+                  )
+                .then { resolve(it, registry, entry_name) } => Ok[resolved]
+
+                resolved
+              end
+              .then { impl.deps + it }
+              .then { impl.with(deps: it) }
+              .then { return Ok[it] }
+          end
+
+          if Deriving.derivable?(constraint.interface)
+            Deriving
+              .derive(constraint, registry, entry_name) { resolve(it, registry, entry_name) }
+              .then { return it }
+          end
+
+          constraint.origin.range
+            .then { Error::MissingImplementation.new(entry_name, it, constraint:) }
+            .then { Err[it] }
+        end
+
+        # An origin's dictionaries can be touched by multiple inference frames:
+        # the call's own callee constraints attach here, and outer frames
+        # also attach when args bubble up concretely. Var-typed markers' ids
+        # may chain further as inference proceeds; the finalize-time
+        # canonicalize pass walks the AST and rewrites them to their final
+        # form so codegen can read marker.type.id directly.
+        def attach_dictionary(constraint, impl)
+          constraint => Type::Constraint(
+            origin: { dictionaries: dicts },
+            index:,
+          )
+
+          fail "constraint missing index: #{constraint}" if index == :unindex
+
+          return if dicts[index].is_a?(Symbol::Implementation) &&
+                    impl.is_a?(Type::Constraint)
+
+          dicts[index] = impl
+        end
+
+        def solve_at_finalize(constraint, registry, entry_name)
+          resolve(constraint, registry, entry_name)
+            .map { |impl| attach_dictionary(constraint, impl); [] }
+            .on_err(Error::UnresolvedConstraint) { Ok[[]] }
+            .on_err { Ok[[it]] }
+            .with_default([])
+        end
+
+        def solve_at_call_site(constraint, registry, entry_name)
+          resolve(constraint, registry, entry_name)
+            .map { |impl| attach_dictionary(constraint, impl); [] }
+            .on_err(Error::MissingImplementation) { Ok[[it]] }
+            .on_err(Error::DerivationFailed) { Ok[[it]] }
+            .with_default([])
+        end
+
+        private
+
+        def lookup(constraint, registry)
+          key =
+            case constraint.type
+            in Type::Application(constructor:) then constructor.name
+            in Type::PartialApplication(constructor:) then constructor.name
+            in Type::Constructor(name:) then name
+            else constraint.type.to_s
+            end
+
+          case registry.implementations[[constraint.interface, key]]
+          in Symbol::Implementation => impl then impl
+          else nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Jade
+  module Frontend
+    module TypeChecking
+
+      StructDef = Data.define(:name, :type_params, :body)
+      TypeDef = Data.define(:name, :type_params, :constructors) do
+        def opaque?
+          constructors.empty?
+        end
+      end
+      ConstructorDef = Data.define(:name, :parent_name, :args)
+      InterfaceDef = Data.define(:name)
+
+      module Definition
+        extend self
+
+        def from_symbol(sym, var_gen = VarGen.new, registry)
+          # TODO: Don't need a var gen here, definitions don't have identity. they just share the name
+          case sym
+          in Symbol::Struct
+            type_params, type_params_map = sym
+              .type_params
+              .reduce([[], {}]) do |(types, local_map), sym|
+                Type.send(:from_symbol_r, sym, registry, var_gen, local_map)
+                  .then { |(t, _, new_map)| [types + [t], new_map] }
+              end
+
+            Type
+              .send(:from_symbol_r, sym.record_type, registry, var_gen, type_params_map)
+              .first
+              .then { Definition.struct(sym.qualified_name, type_params, it) }
+
+          in Symbol::Union
+            type = Type.from_symbol(sym, registry, var_gen).first
+
+            sym
+              .variants
+              .map do |variant|
+                args = case Type.from_symbol(variant, registry, var_gen).first
+                       in Type::Function(args:) then args
+                       else []
+                       end
+                Definition.constructor(variant.qualified_name, sym.qualified_name, args)
+              end
+              .then { Definition.type(sym.qualified_name, type.args, it) }
+
+          in Symbol::Interface(name:)
+            InterfaceDef[name]
+
+          in Symbol::TypeRef
+            registry
+              .lookup(sym)
+              .then { from_symbol(it, var_gen, registry) }
+          end
+        end
+
+        def constructor(name, parent_name, args)
+          ConstructorDef[name, parent_name, args]
+        end
+
+        def type(name, type_params, constructors)
+          TypeDef[name, type_params, constructors]
+        end
+
+        def struct(name, type_params, body)
+          StructDef[name, type_params, body]
+        end
+      end
+    end
+  end
+end