jade-lang 0.3.0 → 0.4.0

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

@@ -3,21 +3,36 @@ module Jade
     module SemanticAnalysis
       module Error
         class ConstructorNotFound < Jade::Error
+          # `fix` is where the `(..)` is missing: `:expose` when the module
+          # that owns the type keeps its constructors to itself, `:import`
+          # when it exposes them and this module's import didn't ask for them.
+          Hint = Data.define(:module_name, :type_name, :fix)
+
           attr_reader :candidates
 
-          def initialize(entry, span, name:, exposed_type_module: nil, candidates: [])
+          def initialize(entry, span, name:, hint: nil, candidates: [])
             @name = name
-            @exposed_type_module = exposed_type_module
+            @hint = hint
             @candidates = candidates
             super(entry:, span:)
           end
 
           def message
             base = "I cannot find a `#{@name}` constructor"
-            return base unless @exposed_type_module
 
-            "#{base}. The type `#{@name}` is exposed by `#{@exposed_type_module}` but its " \
-              "constructor is private — add `#{@name}(..)` to that module's `exposing` list."
+            case @hint
+            in nil
+              base
+
+            in Hint(module_name:, type_name:, fix: :expose)
+              "#{base}. The type `#{type_name}` is exposed by `#{module_name}` but its " \
+                "constructor is private — add `#{type_name}(..)` to that module's " \
+                "`exposing` list."
+
+            in Hint(module_name:, type_name:, fix: :import)
+              "#{base}. `#{module_name}` exposes it — add `#{type_name}(..)` to this " \
+                "module's `import #{module_name} exposing (...)`."
+            end
           end
 
           def label

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

@@ -11,13 +11,23 @@ module Jade
 
             def supports?(interface) = interface == INTERFACE
 
+            # One decoder combinator per structural type, taking a decoder per
+            # element. `Tuple2(a, b)` is `Decode.tuple(dec_a, dec_b)` the same
+            # way `List(a)` is `Decode.list(dec_a)`.
+            STRUCTURAL = {
+              'List.List' => 'Decode.list',
+              'Maybe.Maybe' => 'Decode.nullable',
+              'Set.Set' => 'Decode.set',
+              'Dict.Dict' => 'Decode.dict',
+              'Tuple.Tuple2' => 'Decode.tuple',
+              'Tuple.Tuple3' => 'Decode.tuple3',
+              'Tuple.Tuple4' => 'Decode.tuple4',
+            }.freeze
+
             def derive(constraint, registry, entry_name, &lookup)
               case constraint.type
-              in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [inner])
-                derive_unary(constraint, inner, 'Decode.list', lookup, entry_name)
-
-              in Type::Application(constructor: Type::Constructor(name: 'Maybe.Maybe'), args: [inner])
-                derive_unary(constraint, inner, 'Decode.nullable', lookup, entry_name)
+              in Type::Application(constructor: Type::Constructor(name:), args:) if STRUCTURAL.key?(name)
+                derive_structural(constraint, args, STRUCTURAL.fetch(name), lookup, entry_name)
 
               in Type::Application(constructor: Type::Constructor(name:), args:)
                 resolved_sym = Symbol
@@ -56,19 +66,17 @@ module Jade
               ]
             end
 
-            def derive_unary(constraint, inner_type, stdlib_fn, lookup, entry_name)
-              dep = Type.constraint(INTERFACE, inner_type, nil)
-
-              resolve_dep(dep, lookup, entry_name).and_then do |dep_impl|
-                body = [:call,
-                  [:stdlib_fn, stdlib_fn],
-                  [
-                    [:impl_arg, 0, 'decoder'],
-                  ],
-                ]
+            def derive_structural(constraint, inner_types, stdlib_fn, lookup, entry_name)
+              body = [:call,
+                [:stdlib_fn, stdlib_fn],
+                inner_types.each_index.map { [:impl_arg, it, 'decoder'] },
+              ]
 
-                Ok[implementation(constraint, body, [dep_impl])]
-              end
+              inner_types
+                .map { Type.constraint(INTERFACE, it, nil) }
+                .map { resolve_dep(it, lookup, entry_name) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, body, it) }
             end
 
             def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)

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

@@ -13,13 +13,23 @@ module Jade
               interface == INTERFACE
             end
 
+            # One encoder combinator per structural type, taking an encoder per
+            # element plus the value itself. The name is what the emitted
+            # encoder binds its argument to.
+            STRUCTURAL = {
+              'List.List' => ['Encode.list', 'items'],
+              'Maybe.Maybe' => ['Encode.nullable', 'maybe'],
+              'Set.Set' => ['Encode.set', 'set'],
+              'Dict.Dict' => ['Encode.dict', 'dict'],
+              'Tuple.Tuple2' => ['Encode.tuple', 'pair'],
+              'Tuple.Tuple3' => ['Encode.tuple3', 'triple'],
+              'Tuple.Tuple4' => ['Encode.tuple4', 'quad'],
+            }.freeze
+
             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:) if STRUCTURAL.key?(name)
+                derive_structural(constraint, args, *STRUCTURAL.fetch(name), lookup, entry_name)
 
               in Type::Application(constructor: Type::Constructor(name:), args:)
                 resolved_sym = Symbol
@@ -55,36 +65,17 @@ module Jade
               ]
             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'],
-                  ],
-                ]
+            def derive_structural(constraint, inner_types, stdlib_fn, param, lookup, entry_name)
+              body = [:call,
+                [:stdlib_fn, stdlib_fn],
+                inner_types.each_index.map { [:impl_arg, it, 'encoder'] } + [[:var, param]],
+              ]
 
-                Ok[implementation(constraint, params: ['maybe'], body:, deps: [dep_impl])]
-              end
+              inner_types
+                .map { Type.constraint(INTERFACE, it, nil) }
+                .map { lookup.call(it) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, params: [param], body:, deps: it) }
             end
 
             def derive_nullary_union(constraint, union_sym, registry)

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

@@ -12,157 +12,56 @@ module Jade
             def supports?(interface) = interface == INTERFACE
 
             def derive(constraint, registry, entry_name, &lookup)
-              resolve(constraint, registry, entry_name, lookup)
+              resolve_constraint(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)
+            def derive_union(constraint, symbol, registry, lookup, entry_name)
+              type_vars = symbol.type_params.map(&:name)
+              index_map = type_vars.each_with_index.map.to_h
+              variants  = symbol.variants.map { registry.lookup(it) }
+
+              concrete = variants
+                .flat_map(&:args)
+                .reject { it in Symbol::Variable }
+                .map { instantiate(it, {}, registry) }
+                .uniq
 
-                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).on_err { return Err[it] } => Ok[resolved]
-                    resolved
+
+              concrete
+                .map { lookup.call(Type.constraint(INTERFACE, it, constraint.origin)) }
+                .then { Results.sequence(it) }
+                .and_then do |deps|
+                  cases = variants.map {
+                    build_variant_case(it, index_map, concrete, registry, constraint.origin)
                   }
 
-                  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,
+                  eq_fn = Symbol::DerivedFunction.new(
+                    params: ["one", "other"],
+                    body: [:case,
+                      [:list, [[:var, "one"], [:var, "other"]]],
+                      cases + [[[:_], [false]]],
+                    ],
                   )
 
-                else
-                  impl
+                  Ok[build_union_impl(constraint, type_vars, concrete, eq_fn, deps)]
                 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) }
+            def build_union_impl(constraint, type_vars, concrete, eq_fn, deps)
+              return implementation(constraint, { '(==)' => eq_fn }, deps:) if type_vars.empty?
 
-              eq_fn = Symbol::DerivedFunction.new(
-                params: ["one", "other"],
-                body: [:case,
-                  [:list, [[:var, "one"], [:var, "other"]]],
-                  cases + [[[:_], [false]]],
-                ],
+              Symbol::ImplementationTemplate.new(
+                interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                type: constraint.type,
+                type_params: type_vars.map { Type.var(it) },
+                constraints: union_constraints(constraint, type_vars, concrete),
+                functions: { '(==)' => eq_fn },
               )
-
-              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)
+            def build_variant_case(variant, index_map, concrete, registry, origin)
               field_count = variant.args.length
 
               left_vars  = (0...field_count).map { |i| "l#{i}" }
@@ -173,24 +72,17 @@ module Jade
 
               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
+                  idx =
+                    case arg_type
+                    in Symbol::Variable(name:) then index_map[name]
+                    else
+                    index_map.size + concrete.index(instantiate(arg_type, {}, registry))
+                    end
+
+                  [:call,
+                    [:impl_arg, idx, "(==)"],
+                    [[:var, left_vars[i]], [:var, right_vars[i]]]
+                  ]
                 end
 
               body =
@@ -204,7 +96,7 @@ module Jade
               [[:list, [left_pattern, right_pattern]], body]
             end
 
-            def derive_record_eq(constraint, fields, lookup)
+            def derive_record(constraint, fields, lookup)
               field_types = fields.values
               field_keys  = fields.keys
 
@@ -221,7 +113,7 @@ module Jade
               end
             end
 
-            def derive_struct_eq(constraint, struct_sym, type_args, registry, lookup, entry_name)
+            def derive_struct(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 }
@@ -236,27 +128,11 @@ module Jade
               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,
-              )
+              comparisons
+                .then { it.empty? ? true : it.reduce { |a, b| [:and, a, b] } }
+                .then { Symbol::DerivedFunction.new(params: ['one', 'other'], body: it) }
+                .then { implementation(constraint, { '(==)' => it }, deps:) }
             end
           end
         end

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

@@ -33,6 +33,139 @@ module Jade
                 .map { |name, sym| [name, instantiate(sym, subst, registry)] }
             end
 
+            def failed(constraint, entry_name)
+              Err[
+                Error::DerivationFailed
+                  .new(entry_name, constraint.origin.range, constraint:, trace: [])
+              ]
+            end
+
+            def implementation(constraint, functions, deps: [], type_params: [], constraints: [])
+              Symbol::Implementation.new(
+                module_name: nil,
+                interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                type: constraint.type,
+                type_params:,
+                constraints:,
+                functions:,
+                deps:,
+                extends: [],
+                decl_span: nil,
+              )
+            end
+
+            def resolve_field_deps(field_types, lookup, origin)
+              field_types
+                .map { lookup.call(Type.constraint(self::INTERFACE, it, origin)) }
+                .then { Results.sequence(it) }
+            end
+
+            def resolve_constraint(constraint, registry, entry_name, lookup)
+              special = special_case(constraint, lookup)
+              return special if special
+
+              case constraint.type
+              in Type::Application(constructor:, args:)
+                dispatch_type(constraint, constructor, args, registry, lookup, entry_name)
+                  .on_err { return Err[it] } => Ok(impl)
+
+                case impl
+                in Symbol::ImplementationTemplate
+                  instantiate_template(constraint, impl, args, lookup)
+                else
+                  Ok[impl]
+                end
+
+              in Type::AnonymousRecord(fields:)
+                derive_record(constraint, fields, lookup)
+
+              else
+                failed(constraint, entry_name)
+              end
+            end
+
+            def special_case(_constraint, _lookup)
+              nil
+            end
+
+            def dispatch_type(constraint, constructor, args, registry, lookup, entry_name)
+              existing = registry.implementations[[constraint.interface, constructor.name]]
+              return Ok[existing] if existing
+
+              Symbol
+                .type_ref_from_qualified_name(constructor.name)
+                .then { registry.lookup(it) }
+                .then do |symbol|
+                  case symbol
+                  in Symbol::Union
+                    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
+            end
+
+            def instantiate_template(constraint, impl, args, lookup)
+              deps = dependencies_of(impl, args)
+              resolved = deps.filter_map { |dep|
+                next if dep.type in Type::Var
+                lookup.call(dep).on_err { return Err[it] } => Ok[found]
+                found
+              }
+
+              Ok[
+                implementation(
+                  constraint, impl.functions,
+                  deps: resolved, type_params: args, constraints: deps,
+                )
+              ]
+            end
+
+            def union_constraints(constraint, type_vars, concrete)
+              type_vars
+                .map { Type.var(it) }
+                .concat(concrete)
+                .map { Type.constraint(self::INTERFACE, it, constraint.origin) }
+            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 instantiate(sym, subst, registry)
               case sym
               in Symbol::Variable(name:)