jade-lang 0.3.0 → 0.4.0

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/env.rb

@@ -53,6 +53,9 @@ module Jade
             in Placeholder => placeholder
               Scheme[placeholder.free_vars, placeholder.type, placeholder.constraints]
                 .then { Instantiation.instantiate(it, var_gen) }
+
+            in nil
+              fail "no type binding for `#{key}`"
             end
 
           Result.init(type, constraints)

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

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

@@ -2,15 +2,18 @@ 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'
+require 'jade/frontend/type_checking/error/port_not_encodable'
 
 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.
+      # Resolves the instances each port needs to convert at the boundary:
+      # Decode.Decodable for its ok/err arms, Encode.Encodable for its
+      # arguments. 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` / `encoders` fields
+      # so codegen can emit straight away.
       module PortResolution
         extend self
 
@@ -46,28 +49,61 @@ module Jade
         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.
+          # Single Type.from_symbol over the whole port so a var appearing in
+          # more than one position gets the same Type::Var id. PortCodec 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])
+            .from_symbol(port_symbol(interop_fn), registry, VarGen.new)
+            .first => Type::Function(args: param_types, return_type: 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)
+          encoders, param_errors = resolve_params(interop_fn, param_types, entry, registry)
 
           [
-            interop_fn.with(decoders: { ok:, err: }),
-            ok_errors + err_errors,
+            interop_fn.with(decoders: { ok:, err: }, encoders:),
+            ok_errors + err_errors + param_errors,
           ]
         end
 
+        # Without the constraints the shared VarGen would still hand every
+        # position its own var; `from_symbol` only ties them together through
+        # the map it threads across params and return.
+        def port_symbol(interop_fn)
+          Symbol.function_type(interop_fn.params, interop_fn.return_type)
+        end
+
+        def resolve_params(interop_fn, param_types, entry, registry)
+          interop_fn
+            .params
+            .zip(param_types)
+            .each_with_index
+            .map { |(sym, type), index| resolve_param(sym, type, interop_fn, index, entry, registry) }
+            .then { |results| [results.map(&:first), results.flat_map(&:last)] }
+        end
+
+        def resolve_param(type_sym, type, interop_fn, index, entry, registry)
+          return [Symbol::InteropFunction::PASS, []] if pass_through?(type_sym)
+
+          case type
+          in Type::Var(name:)
+            constraint_index_for(interop_fn, 'Encode.Encodable', name)
+              .then { [Symbol::InteropFunction::Dict.new(constraint_index: it), []] }
+
+          else
+            Type
+              .constraint('Encode.Encodable', type, nil)
+              .then { Constraints.resolve(it, registry, entry.name) }
+              .then { encoder_result(it, interop_fn, index, entry, type, span_of(type_sym, interop_fn)) }
+          end
+        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)
+            constraint_index_for(interop_fn, 'Decode.Decodable', name)
               .then { [Symbol::InteropFunction::Dict.new(constraint_index: it), []] }
 
           else
@@ -81,11 +117,11 @@ module Jade
           end
         end
 
-        def constraint_index_for(interop_fn, var_name)
+        def constraint_index_for(interop_fn, interface, var_name)
           interop_fn
             .constraints
-            .index { |_iface, name| name == var_name }
-            .tap { fail "no Decodable constraint for #{var_name.inspect}" if it.nil? }
+            .index { |iface, name| iface == interface && name == var_name }
+            .tap { fail "no #{interface} constraint for #{var_name.inspect}" if it.nil? }
         end
 
         def decoder_result(constraint_result, interop_fn, arm, entry, type, span)
@@ -100,6 +136,18 @@ module Jade
           end
         end
 
+        def encoder_result(constraint_result, interop_fn, index, entry, type, span)
+          case constraint_result
+          in Ok[impl]
+            [impl, []]
+
+          in Err
+            Error::PortNotEncodable
+              .new(entry, span, port_name: interop_fn.name, position: index + 1, type:)
+              .then { [nil, [it]] }
+          end
+        end
+
         def span_of(type_sym, interop_fn)
           case type_sym
           in Symbol::TypeApplication(span:) then span

data/lib/jade/interop/runtime.rb

@@ -3,7 +3,7 @@ require 'jade/interop/error'
 module Jade
   module Interop
     module Runtime
-      def task_call(interop_module_name, function_name, ok_decoder, err_decoder)
+      def task_call(interop_module_name, function_name, ok_decoder, err_decoder, arg_encoders)
         ->(*args) do
           interop_module_name
             .send(function_name)
@@ -12,13 +12,21 @@ module Jade
                 fail(Interop::PortNotRegistered.new(interop_module_name, function_name))
 
               Jade::Task::Decoded.new(
-                Jade::Task::Dispatch.new(port, args),
+                Jade::Task::Dispatch.new(port, encode_args(args, arg_encoders)),
                 ok_decoder,
                 err_decoder,
               )
             end
         end
       end
+
+      # Ports are the boundary in the other direction: what Ruby gets handed is
+      # encoded the same way a return value is decoded on the way back.
+      def encode_args(args, encoders)
+        args
+          .each_with_index
+          .map { |arg, i| encoders.fetch(i).call(arg) }
+      end
     end
   end
 end

data/lib/jade/module_loader.rb

@@ -51,13 +51,37 @@ module Jade
         .modules_in_topo_order
         .reject { Stdlib.is_stdlib?(it) }
         .reduce([registry, {}]) do |(acc, digests), entry|
-          compiled, digest = compile_with_cache(entry, acc, digests, cache_dir, tolerant)
-
-          [acc.update_module(compiled), digests.merge(entry.name => digest)]
+          case broken_dependency(entry, acc)
+          in String => dependency
+            [acc.update_module(blocked(entry, dependency)), digests]
+
+          else
+            compile_with_cache(entry, acc, digests, cache_dir, tolerant)
+              .then { |(compiled, digest)| [acc.update_module(compiled), digests.merge(entry.name => digest)] }
+          end
         end
         .first
     end
 
+    def broken_dependency(entry, registry)
+      direct_deps(entry.name, registry)
+        .filter_map { registry.modules[it] }
+        .find { it.diagnostics.any_errors? }
+        &.name
+    end
+
+    def blocked(entry, dependency)
+      Diagnostics::List
+        .empty
+        .add(
+          Diagnostics::Diagnostic.error(
+            "Not checked: #{dependency} failed to compile",
+            primary: nil,
+          ),
+        )
+        .then { entry.with(diagnostics: it) }
+    end
+
     def compile_with_cache(entry, registry, digests, cache_dir, tolerant)
       return [compile_one(entry, registry, tolerant:), nil] unless cache_dir
 

data/lib/jade/parsing/error.rb

@@ -58,11 +58,20 @@ module Jade
         super
       end
 
+      # Blocks whose entries are comma-separated, so a newline between two of
+      # them reads as the end of the block.
+      COMMA_SEPARATED_BLOCKS = [
+        'interop import declaration',
+        'interface declaration',
+        'implementation',
+      ].freeze
+
       def hint
         return leading_pipe_hint if leading_pipe_in_type_decl?
         return reserved_keyword_hint if reserved_keyword_as_name?
         return colon_not_eq_hint if eq_where_colon_expected?
         return record_eq_hint if eq_where_record_pipe_expected?
+        return missing_comma_hint if entry_after_unterminated_entry?
         nil
       end
 
@@ -115,6 +124,16 @@ module Jade
       def record_eq_hint
         "(record fields use `:`, not `=` — write `{ name: value }`)"
       end
+
+      def entry_after_unterminated_entry?
+        expected == :end &&
+          [:identifier, :lparen].include?(actual.type) &&
+          (@context & COMMA_SEPARATED_BLOCKS).any?
+      end
+
+      def missing_comma_hint
+        "(entries here are separated by `,` — add one to the line above)"
+      end
     end
 
     # Specific case-branch shape: `in <pat> <body>` on the same source

data/lib/jade/runtime.rb

@@ -1,3 +1,4 @@
+require 'jade/debug'
 require 'base64'
 
 require 'jade/interop/runtime'

data/lib/jade/stdlib/debug.rb

@@ -0,0 +1,12 @@
+require 'jade/debug'
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Debug
+      extend Intrinsics
+
+      function(:log, { label: 'String', value: 'a' }, 'a') { |l, v| Jade::Debug.log(l, v) }
+    end
+  end
+end

data/lib/jade/stdlib/decode.rb

@@ -10,6 +10,7 @@ module Jade
       import Result
       import List
       import Dict
+      import Set
 
       union :DecodeError
       variant :MissingField, of: :DecodeError, args: ['String']
@@ -46,6 +47,13 @@ module Jade
         Jade::Decode::Decoder[Jade::Decode::Desc::Bool[]]
       }
 
+      # Keeps whatever came in. `Value` is the un-decoded value, so this is
+      # what makes it usable nested — `List(Value)`, a field of a struct —
+      # and not only as a whole arm.
+      function('value', {}, 'Decoder(Value)') {
+        Jade::Decode::Decoder[Jade::Decode::Desc::Pass[]]
+      }
+
       # Structural
 
       function(
@@ -88,6 +96,19 @@ module Jade
         Jade::Decode::Decoder[Jade::Decode::Desc::Lst[decoder.desc]]
       }
 
+      # Reads the same shape a list does, dropping duplicates. Like
+      # `Decode.dict`, it builds the keyed structure directly, so it asks
+      # nothing of the element beyond being decodable.
+      function(
+        'set',
+        { decoder: 'Decoder(a)' },
+        'Decoder(Set(a))',
+      ) { |decoder|
+        Jade::Decode::Desc::Lst[decoder.desc]
+          .then { Jade::Decode::Desc::Map[->(vs) { Jade::Set::Set[vs.to_h { [it, true] }] }, it] }
+          .then { Jade::Decode::Decoder[it] }
+      }
+
       # Decodes either a Hash (natural Ruby/JSON object form) or a list
       # of `[k, v]` pairs (what Encode.dict emits — also the only shape
       # that round-trips non-String key types).
@@ -328,6 +349,7 @@ module Jade
       implementation('Decodable', 'Basics.Float',  'decoder' => 'float')
       implementation('Decodable', 'Basics.Bool',   'decoder' => 'bool')
       implementation('Decodable', 'String.String', 'decoder' => 'string')
+      implementation('Decodable', 'Decode.Value',  'decoder' => 'value')
     end
   end
 end

data/lib/jade/stdlib/encode.rb

@@ -10,6 +10,7 @@ module Jade
       import List
       import Tuple
       import Dict
+      import Set
 
       interface(
         'Encodable',
@@ -25,6 +26,11 @@ module Jade
       function('bool', { b: 'Bool' }, 'Value') { it }
       function('null', {}, 'Value') { nil }
 
+      # A `Value` is already encoded, so its encoder is identity. Ports and
+      # boundaries take it as the opt-out; the instance is what carries that
+      # through `List(Value)` and friends.
+      function('value', { v: 'Value' }, 'Value') { it }
+
       # Structural
 
       function(
@@ -57,6 +63,16 @@ module Jade
         dict.hash.map { |k, v| [k_enc.call(k), v_enc.call(v)] }
       }
 
+      # A set is its elements, in insertion order, with no duplicates —
+      # the same shape a list encodes to.
+      function(
+        'set',
+        { encoder: 'a -> Value', set: 'Set(a)' },
+        'Value',
+      ) { |encoder, set|
+        set.hash.keys.map { encoder.call(it) }
+      }
+
       function(
         'object',
         { pairs: 'List(Tuple2(String, Value))' },
@@ -138,6 +154,7 @@ module Jade
       implementation('Encodable', 'Basics.Float',  'encoder' => 'float')
       implementation('Encodable', 'Basics.Bool',   'encoder' => 'bool')
       implementation('Encodable', 'String.String', 'encoder' => 'string')
+      implementation('Encodable', 'Decode.Value',  'encoder' => 'value')
     end
   end
 end

data/lib/jade/stdlib/intrinsics.rb

@@ -256,6 +256,9 @@ module Jade
 
         in 'Encodable'
           'Encode'
+
+        in 'Show'
+          'Show'
         end
           .then { Symbol.type_ref(it, interface.to_s) }
       end

data/lib/jade/stdlib/show.rb

@@ -0,0 +1,40 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Show
+      extend Intrinsics
+
+      import Basics
+      import Char
+      import String
+
+      interface(
+        'Show',
+        'a',
+        { 'show' => 'a -> String' },
+      )
+
+      implementation('Show', 'Int',    'show' => 'int_show')
+      implementation('Show', 'Float',  'show' => 'float_show')
+      implementation('Show', 'Bool',   'show' => 'bool_show')
+      implementation('Show', 'String', 'show' => 'str_show')
+      implementation('Show', 'Char',   'show' => 'char_show')
+
+      # Never is uninhabited, so this can only be reached by a compiler bug.
+      # The instance exists because the constraint does: without it no
+      # `Result(a, Never)` — the shape every port-free task returns — can be
+      # shown, and the error surfaces as an unresolved constraint far from
+      # its cause.
+      implementation('Show', 'Never',  'show' => 'never_show')
+
+      function('int_show',   { n: 'Int' },    'String')
+      function('float_show', { f: 'Float' },  'String')
+      function('bool_show',  { b: 'Bool' },   'String')
+      function('str_show',   { s: 'String' }, 'String')
+      function('char_show',  { c: 'Char' },   'String')
+
+      function('never_show', { n: 'Never' },  'String')
+    end
+  end
+end