jade-lang 0.3.1 → 0.5.0

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

@@ -12,9 +12,8 @@ module Jade
     # weight at the boundary because failure always raises anyway. Skipping
     # it removes one allocation per arg per Ruby→Jade call.
       def decode_or_raise(decoder, value)
-        case Jade::Decode::Runner.run(decoder, value)
-        in Jade::Result::Ok[v]  then v
-        in Jade::Result::Err[e] then raise Jade::Interop::DecodeError.new(e, value)
+        Jade::Decode::Runner.run!(decoder, value) do |error|
+          raise Jade::Interop::DecodeError.new(error, value)
         end
       end
 

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/lsp/converters.rb

@@ -1,4 +1,5 @@
 require 'uri'
+require 'jade/signature'
 
 module Jade
   module LSP
@@ -432,21 +433,7 @@ module Jade
       end
 
       def render_signature(name, type, constraints)
-        "#{name} : #{constraint_prefix(constraints)}#{type}"
-      end
-
-      def constraint_prefix(constraints)
-        return '' if constraints.empty?
-
-        constraints
-          .map { short_constraint(it) }
-          .uniq
-          .join(', ')
-          .then { "#{it} => " }
-      end
-
-      def short_constraint(constraint)
-        "#{constraint.interface.split('.').last} #{constraint.type}"
+        Signature.render(name, type, constraints)
       end
 
       # First node in the path (innermost-to-outermost) that resolves to a

data/lib/jade/lsp/snippets.rb

@@ -1,7 +1,14 @@
 module Jade
   module LSP
     module Snippets
-      Snippet = Data.define(:label, :detail, :body)
+      TAB_STOP = /\$\{\d+:?([^}]*)\}/
+
+      Snippet = Data.define(:label, :detail, :body) do
+        # Keeps the hint text, drops the tab stops an editor needs.
+        def source
+          body.gsub(TAB_STOP, '\1')
+        end
+      end
 
       ALL = [
         Snippet.new(
@@ -33,11 +40,11 @@ module Jade
         ),
         Snippet.new(
           label: 'case',
-          detail: 'case expression with else fallback',
+          detail: 'case expression, one branch per variant',
           body: <<~SNIP.chomp,
             case ${1:expr}
             in ${2:pattern} then ${3:result}
-            else ${0:fallback}
+            in ${4:pattern} then ${0:result}
             end
           SNIP
         ),
@@ -95,6 +102,17 @@ module Jade
           body: '(${1:args}) -> { ${0:body} }',
         ),
       ].freeze
+
+      module_function
+
+      # Every form, as plain Jade — what `jade q syntax` serves.
+      def catalog
+        ALL.map { { form: it.label, detail: it.detail, source: it.source } }
+      end
+
+      def find(form)
+        catalog.find { it[:form] == form }
+      end
     end
   end
 end

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

@@ -0,0 +1,47 @@
+require 'jade/frontend/type_checking/substitution'
+
+module Jade
+  # One-line rendering of a name and its type, shared by hover and `q api`.
+  module Signature
+    extend self
+
+    LETTERS = ('a'..'z').to_a.freeze
+
+    def render(name, type, constraints)
+      naming(type, constraints)
+        .then { |sub| [sub.apply(type), constraints.map { sub.apply(it) }] }
+        .then { |(renamed, cs)| "#{name} : #{constraint_prefix(cs)}#{renamed}" }
+    end
+
+    # Vars compare by id but print as their name, which nothing keeps unique.
+    def naming(type, constraints)
+      (type.unbound_vars + constraints.flat_map(&:unbound_vars))
+        .uniq(&:id)
+        .reduce([{}, []]) do |(mappings, taken), var|
+          display_name(var, taken)
+            .then { [mappings.merge(var.id => Type.var(var.id, it)), taken + [it]] }
+        end
+        .then { |(mappings, _)| Frontend::TypeChecking::Substitution[mappings] }
+    end
+
+    def display_name(var, taken)
+      return var.name if var.name && !taken.include?(var.name)
+
+      (LETTERS - taken).first || "#{var.name}#{taken.size}"
+    end
+
+    def constraint_prefix(constraints)
+      return '' if constraints.empty?
+
+      constraints
+        .map { short_constraint(it) }
+        .uniq
+        .join(', ')
+        .then { "#{it} => " }
+    end
+
+    def short_constraint(constraint)
+      "#{constraint.interface.split('.').last} #{constraint.type}"
+    end
+  end
+end

data/lib/jade/stdlib/calendar.rb

@@ -317,24 +317,25 @@ module Jade
           end
 
 
+          # Days counted in 400-year eras from March, so the leap day lands
+          # at the end of an era and month lengths repeat; `mp` is the month
+          # in that March-based year, shifted back at the end. Int division
+          # floors, which is what makes it hold before year 1.
           def from_rata_die(rd: Int) -> Date
-            y = bump_year(rd, (rd - 1) / 366 + 1)
-            doy = rd - days_before_year(y)
-            case search_month(y, doy, 12)
-            in (m, d) then from_calendar_date(y, m, d)
-            end
-          end
-
-
-          def bump_year(rd: Int, y: Int) -> Int
-            days_before_year(y + 1) < rd ? bump_year(rd, y + 1) : y
-          end
+            z = rd + 305
+            era = z / 146097
+            doe = z - era * 146097
+            yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365
+            doy = doe - (365 * yoe + yoe / 4 - yoe / 100)
+            mp = (5 * doy + 2) / 153
+            d = doy - (153 * mp + 2) / 5 + 1
+            mi = mp < 10 ? mp + 3 : mp - 9
 
-
-          def search_month(y: Int, doy: Int, mi: Int) -> (Month, Int)
-            m = month_from_int(mi)
-            offset = days_before_month(y, m)
-            doy > offset ? (m, doy - offset) : search_month(y, doy, mi - 1)
+            from_calendar_date(
+              yoe + era * 400 + (mi <= 2 ? 1 : 0),
+              month_from_int(mi),
+              d,
+            )
           end
 
 
@@ -390,9 +391,9 @@ module Jade
           end
 
 
-          implements Decodable(Date) with
-            decoder: -> { Decode.string |> Decode.and_then(parse_date) }
-          end
+          # Decodable(Date) is registered by Decode, which reads this same
+          # wire form in Ruby. `from_iso_string` stays exposed and is what
+          # the native parser is checked against.
 
 
           implements Encodable(Date) with

data/lib/jade/stdlib/clock.rb

@@ -154,7 +154,7 @@ module Jade
 
           def on_date(i: Instant) -> Calendar.Date
             Instant(ms) = i
-            Calendar.from_rata_die(floor_div(ms, 86400000) + 719163)
+            Calendar.from_rata_die(ms / 86400000 + 719163)
           end
 
 
@@ -175,12 +175,6 @@ module Jade
           end
 
 
-          def floor_div(a: Int, b: Int) -> Int
-            q = a / b
-            a < 0 && mod(a, b) != 0 ? q - 1 : q
-          end
-
-
           def to_iso(i: Instant) -> String
             d = on_date(i)
             tod = at_time(i)
@@ -317,14 +311,14 @@ module Jade
           end
 
 
-          implements Decodable(Instant) with
-            decoder: -> { Decode.string |> Decode.and_then(parse_instant) }
-          end
+          # Decodable(Instant) is registered by Decode, which reads this
+          # same wire form in Ruby. `from_iso` is still the parser of
+          # record and stays exposed; the two are differential-tested.
 
 
-          implements Encodable(Instant) with
-            encoder: (i) -> { Encode.string(to_iso(i)) }
-          end
+          # Encodable(Instant) is registered by Encode, which writes this
+          # same string in Ruby. `to_iso` stays exposed and is what the
+          # native writer is differential-tested against.
 
 
           implements Decodable(Duration) with

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

@@ -208,22 +208,9 @@ module Jade
           end
 
 
-          def from_wire(s: String) -> Decoder(Decimal)
-            case String.split(s, "e")
-            in [m, e]
-              case (String.to_int(m), String.to_int(e))
-              in (Just(mi), Just(ei)) then Decode.succeed(of(mi, ei))
-              else Decode.fail("invalid decimal: " ++ s)
-              end
-
-            else Decode.fail("invalid decimal: " ++ s)
-            end
-          end
-
-
-          implements Decodable(Decimal) with
-            decoder: -> { Decode.string |> Decode.and_then(from_wire) }
-          end
+          # Decodable(Decimal) is registered by Decode itself, which reads
+          # this same wire form in Ruby — a numeric column decodes about
+          # three times faster than the Jade version of the parse did.
 
 
           implements Encodable(Decimal) with

data/lib/jade/stdlib/decode.rb

@@ -1,5 +1,6 @@
 require 'jade/stdlib/intrinsics'
 require 'jade/decode'
+require 'jade/stdlib/text'
 
 module Jade
   module Stdlib
@@ -10,6 +11,7 @@ module Jade
       import Result
       import List
       import Dict
+      import Set
 
       union :DecodeError
       variant :MissingField, of: :DecodeError, args: ['String']
@@ -46,6 +48,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 +97,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).
@@ -127,6 +149,21 @@ module Jade
         Jade::Decode::Decoder[Jade::Decode::Desc::AndMap[wrapped.desc, decoder.desc]]
       }
 
+      # `keys` and `decoders` are positionally paired; `ctor` takes one
+      # argument per key. Private because its type cannot be spelled — the
+      # arity of `ctor` is only known to the deriver.
+      function(
+        'record',
+        { keys: 'List(String)', decoders: 'List(Decoder(a))', ctor: 'b' },
+        'Decoder(b)',
+        private: true,
+      ) { |keys, decoders, ctor|
+        keys
+          .zip(decoders)
+          .map { |key, decoder| Jade::Decode::Desc::RecordField[key, key.to_sym, decoder.desc] }
+          .then { Jade::Decode::Decoder[Jade::Decode::Desc::Record[it, ctor]] }
+      }
+
       function(
         'required',
         { wrapped: 'Decoder(a -> b)', key: 'String', field_decoder: 'Decoder(a)' },
@@ -291,9 +328,7 @@ module Jade
         { a: 'Decoder(a)', b: 'Decoder(b)' },
         'Decoder(Tuple2(a, b))',
       ) { |da, db|
-        Jade::Decode::Desc::Succeed[Jade::Tuple::Tuple2.method(:[]).curry(2)]
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[0, da.desc]] }
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[1, db.desc]] }
+        Jade::Decode::Desc::Indexed[[da.desc, db.desc], Jade::Tuple::Tuple2]
           .then { Jade::Decode::Decoder[it] }
       }
 
@@ -302,10 +337,7 @@ module Jade
         { a: 'Decoder(a)', b: 'Decoder(b)', c: 'Decoder(c)' },
         'Decoder(Tuple3(a, b, c))',
       ) { |da, db, dc|
-        Jade::Decode::Desc::Succeed[Jade::Tuple::Tuple3.method(:[]).curry(3)]
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[0, da.desc]] }
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[1, db.desc]] }
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[2, dc.desc]] }
+        Jade::Decode::Desc::Indexed[[da.desc, db.desc, dc.desc], Jade::Tuple::Tuple3]
           .then { Jade::Decode::Decoder[it] }
       }
 
@@ -314,11 +346,7 @@ module Jade
         { a: 'Decoder(a)', b: 'Decoder(b)', c: 'Decoder(c)', d: 'Decoder(d)' },
         'Decoder(Tuple4(a, b, c, d))',
       ) { |da, db, dc, dd|
-        Jade::Decode::Desc::Succeed[Jade::Tuple::Tuple4.method(:[]).curry(4)]
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[0, da.desc]] }
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[1, db.desc]] }
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[2, dc.desc]] }
-          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[3, dd.desc]] }
+        Jade::Decode::Desc::Indexed[[da.desc, db.desc, dc.desc, dd.desc], Jade::Tuple::Tuple4]
           .then { Jade::Decode::Decoder[it] }
       }
 
@@ -328,6 +356,23 @@ 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')
+
+      # Registered here, not by the modules owning the types: they import
+      # Decode, so the instance cannot live the other way round. Private
+      # for the same reason `record` is — Decode cannot name those types
+      # back, and `Decoder(a)` would be a hole if anything could reach it.
+      {
+        'decimal' => [Stdlib::Text.method(:to_decimal), 'Decimal', 'Decimal.Decimal'],
+        'instant' => [Stdlib::Text.method(:to_instant), 'Instant', 'Clock.Instant'],
+        'iso_date' => [Stdlib::Text.method(:to_date), 'Date', 'Calendar.Date'],
+      }.each do |fn_name, (parse, label, type_name)|
+        function(fn_name, {}, 'Decoder(a)', private: true) {
+          Jade::Decode::Decoder[Jade::Decode::Desc::FromString[label, parse]]
+        }
+
+        implementation('Decodable', type_name, 'decoder' => fn_name)
+      end
     end
   end
 end

data/lib/jade/stdlib/encode.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'jade/stdlib/intrinsics'
+require 'jade/stdlib/text'
 
 module Jade
   module Stdlib
@@ -10,6 +11,7 @@ module Jade
       import List
       import Tuple
       import Dict
+      import Set
 
       interface(
         'Encodable',
@@ -25,6 +27,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 +64,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 +155,15 @@ 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')
+
+      # Registered here because Clock imports Encode, so the instance
+      # cannot live the other way round. `Stdlib::Text` writes the string.
+      function('instant', { i: 'a' }, 'Value', private: true) { |i|
+        Stdlib::Text.from_instant(i)
+      }
+
+      implementation('Encodable', 'Clock.Instant', 'encoder' => 'instant')
     end
   end
 end