jade-lang 0.3.1 → 0.5.0

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:)

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

@@ -0,0 +1,186 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        module Deriving
+          module Show
+            extend self
+            include Helpers
+
+            INTERFACE = 'Show.Show'
+
+            def supports?(interface) = interface == INTERFACE
+
+            def derive(constraint, registry, entry_name, &lookup)
+              resolve_constraint(constraint, registry, entry_name, lookup)
+            end
+
+            private
+
+            # List has no variants to walk, so it is matched by name here rather
+            # than declared as an instance in the Show module. That is a stopgap:
+            # a parameterised stdlib instance needs a registration path the DSL
+            # does not have. Encodable hardcodes List and Maybe for the same
+            # reason. Contained because derivation is private — see
+            # vault jade/plans/jade-test-runner.md for the four layers involved.
+            LIST = 'List.List'
+
+            def special_case(constraint, lookup)
+              case constraint.type
+              in Type::Function
+                Ok[implementation(constraint, { 'show' => constant('<function>') })]
+
+              in Type::Application(constructor: Type::Constructor(name: LIST), args: [inner])
+                list_show(constraint, inner, lookup)
+
+              else
+                nil
+              end
+            end
+
+            def list_show(constraint, inner, lookup)
+              lookup
+                .call(Type.constraint(INTERFACE, inner, constraint.origin))
+                .and_then do |dep|
+                  body = concat([
+                    '[',
+                    [:call, [:stdlib_fn, 'String.join'], [
+                      [:call, [:stdlib_fn, 'List.map'], [[:var, 'list'], [:impl_arg, 0, 'show']]],
+                      ', ',
+                    ]],
+                    ']',
+                  ])
+
+                  Symbol::DerivedFunction
+                    .new(params: ['list'], body:)
+                    .then { Ok[implementation(constraint, { 'show' => it }, deps: [dep])] }
+                end
+            end
+
+            def constant(text)
+              Symbol::DerivedFunction.new(params: ['value'], body: text)
+            end
+
+            def concat(parts)
+              [:call, [:stdlib_fn, 'String.concat'], [[:list, parts]]]
+            end
+
+            def shown(dict_index, expr)
+              [:call, [:impl_arg, dict_index, 'show'], [expr]]
+            end
+
+            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
+
+              return failed(constraint, entry_name) if variants.empty?
+
+              concrete
+                .map { lookup.call(Type.constraint(INTERFACE, it, constraint.origin)) }
+                .then { Results.sequence(it) }
+                .and_then do |deps|
+                  cases = variants.map {
+                    variant_case(it, index_map, concrete, registry)
+                  }
+
+                  show_fn = Symbol::DerivedFunction.new(
+                    params: ['value'],
+                    body: [:case, [:var, 'value'], cases],
+                  )
+
+                  Ok[union_impl(constraint, type_vars, concrete, show_fn, deps)]
+                end
+            end
+
+            def union_impl(constraint, type_vars, concrete, show_fn, deps)
+              return implementation(constraint, { 'show' => show_fn }, deps:) if type_vars.empty?
+
+              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: { 'show' => show_fn },
+              )
+            end
+
+            def variant_case(variant, index_map, concrete, registry)
+              vars = (0...variant.args.length).map { |i| "a#{i}" }
+              name = variant.qualified_name.split('.').last
+              pattern = [:constructor, variant.qualified_name, vars]
+
+              return [pattern, [name]] if vars.empty?
+
+              rendered = variant.args.each_with_index.map do |arg_type, i|
+                idx =
+                  case arg_type
+                  in Symbol::Variable(name: var_name) then index_map[var_name]
+                  else
+                    index_map.size + concrete.index(instantiate(arg_type, {}, registry))
+                  end
+
+                shown(idx, [:var, vars[i]])
+              end
+
+              parts = [name, '('] + intersperse(rendered, ', ') + [')']
+
+              [pattern, [concat(parts)]]
+            end
+
+            def intersperse(items, separator)
+              items.flat_map { [separator, it] }.drop(1)
+            end
+
+            def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)
+              fields = struct_fields(struct_sym, type_args, registry)
+              name = struct_sym.qualified_name.split('.').last
+
+              resolve_field_deps(fields.map { |_, type| type }, lookup, constraint.origin)
+                .and_then do |deps|
+                  rendered = fields.each_with_index.map { |(field, _), idx|
+                    [:call, [:stdlib_fn, 'String.concat'], [[:list, [
+                      "#{field}: ",
+                      shown(idx, [:access, [:var, 'value'], field.to_s]),
+                    ]]]]
+                  }
+
+                  parts = [name, ' { '] + intersperse(rendered, ', ') + [' }']
+
+                  Ok[record_impl(constraint, concat(parts), deps)]
+                end
+            end
+
+            def derive_record(constraint, fields, lookup)
+              resolve_field_deps(fields.values, lookup, constraint.origin)
+                .and_then do |deps|
+                  rendered = fields.keys.each_with_index.map { |field, idx|
+                    [:call, [:stdlib_fn, 'String.concat'], [[:list, [
+                      "#{field}: ",
+                      shown(idx, [:access, [:var, 'value'], field.to_s]),
+                    ]]]]
+                  }
+
+                  parts = ['{ '] + intersperse(rendered, ', ') + [' }']
+
+                  Ok[record_impl(constraint, concat(parts), deps)]
+                end
+            end
+
+            def record_impl(constraint, body, deps)
+              Symbol::DerivedFunction
+                .new(params: ['value'], body:)
+                .then { implementation(constraint, { 'show' => it }, deps:) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ require_relative './deriving/eq.rb'
 require_relative './deriving/decodable.rb'
 require_relative './deriving/encodable.rb'
 require_relative './deriving/sql_mapper.rb'
+require_relative './deriving/show.rb'
 
 module Jade
   module Frontend
@@ -11,7 +12,7 @@ module Jade
         module Deriving
           extend self
 
-          DERIVERS = [Eq, Decodable, Encodable, SqlMapper]
+          DERIVERS = [Eq, Show, Decodable, Encodable, SqlMapper]
 
           def derivable?(interface)
             DERIVERS.any? { it.supports?(interface) }

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

@@ -0,0 +1,38 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class PortNotEncodable < Jade::Error
+          attr_reader :port_name, :position, :type
+
+          def initialize(entry, span, port_name:, position:, type:)
+            @port_name = port_name
+            @position = position
+            @type = type
+            super(entry:, span:)
+          end
+
+          def message
+            "Port `#{@port_name}` cannot encode argument #{@position} (`#{@type}`): " \
+              "no Encodable instance"
+          end
+
+          def label
+            "no Encodable instance for `#{@type}`"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                "implement Encodable for `#{@type}` so it can be encoded on the " \
+                  "way out, or declare the argument as `Decode.Value` to hand " \
+                  "Ruby the value untouched",
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end