jade-lang 0.4.0 → 0.5.0

data/lib/jade/frontend/semantic_analysis/member_access.rb

@@ -55,13 +55,14 @@ module Jade
           import = entry
             .imports
             .find { it.alias == module_name }
+          imported = import&.then { registry.get(it.module_name) }
 
           if import.nil?
             Error::ModuleNotFound
               .new(entry.name, node.target.range, name: import)
 
           else
-            case registry.get(import.module_name).exposed_value(name.name)
+            case imported.exposed_value(name.name)
             in nil
               Error::ValueNotExposed
                 .new(entry.name, name.range, module_name:, name: name.name)
@@ -77,10 +78,19 @@ module Jade
                   node.range,
                   name: [module_name, name.name].join('.'),
                   causes: [it],
+                  candidates: exposed_value_names(imported, module_name),
                 )
             end
             .then { Err[it] }
         end
+
+        def exposed_value_names(imported, module_name)
+          return [] unless imported
+
+          imported
+            .exposes
+            .filter_map { "#{module_name}.#{it.name}" if it.is_a?(Symbol::ValueRef) }
+        end
       end
     end
   end

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

@@ -82,14 +82,14 @@ module Jade
             def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)
               fields = struct_fields(struct_sym, type_args, registry)
 
-              [:struct_constructor, struct_sym.qualified_name, fields.size]
+              [:struct_class, struct_sym.qualified_name]
                 .then { derive_record(constraint, fields, it, lookup, entry_name) }
             end
 
             def derive_anonymous_record(constraint, fields, lookup, entry_name)
               keys = fields.keys.map(&:to_s)
 
-              [:anon_record_constructor, keys]
+              [:anon_record_class, keys]
                 .then { derive_record(constraint, fields.to_a, it, lookup, entry_name) }
             end
 
@@ -121,19 +121,14 @@ module Jade
             end
 
             def record_body(fields, constructor_ref)
-              seed = [:call, [:stdlib_fn, 'Decode.succeed'], [constructor_ref]]
-
-              fields.each_with_index.reduce(seed) do |acc, ((field_name, _), idx)|
-                field_decoder = [:call,
-                  [:stdlib_fn, 'Decode.field'],
-                  [
-                    field_name.to_s,
-                    [:impl_arg, idx, 'decoder'],
-                  ],
-                ]
-
-                [:call, [:stdlib_fn, 'Decode.and_map'], [acc, field_decoder]]
-              end
+              [:call,
+                [:stdlib_fn, 'Decode.record'],
+                [
+                  [:list, fields.map { |name, _| name.to_s }],
+                  [:list, fields.each_index.map { [:impl_arg, it, 'decoder'] }],
+                  constructor_ref,
+                ],
+              ]
             end
 
             # Free-var inner constraints fall back to the constraint marker

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

@@ -97,27 +97,18 @@ module Jade
               field_deps = fields
                 .map { |_, field_type| Type.constraint(INTERFACE, field_type, nil) }
 
-              pair_irs = fields
+              body = fields
                 .each_with_index
                 .map do |(field_name, _), idx|
-                  [:call,
-                    [:stdlib_fn, 'Tuple.pair'],
-                    [
-                      field_name.to_s,
-                      [:call,
-                        [:impl_arg, idx, 'encoder'],
-                        [[:access, [:var, 'rec'], field_name.to_s]],
-                      ],
+                  [
+                    field_name.to_s,
+                    [:call,
+                      [:impl_arg, idx, 'encoder'],
+                      [[:access, [:var, 'rec'], field_name.to_s]],
                     ],
                   ]
                 end
-
-              body = [:call,
-                [:stdlib_fn, 'Encode.object'],
-                [
-                  [:list, pair_irs],
-                ],
-              ]
+                .then { [:hash, it] }
 
               field_deps
                 .map { lookup.call(it) }

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/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/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/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
@@ -148,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)' },
@@ -312,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] }
       }
 
@@ -323,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] }
       }
 
@@ -335,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] }
       }
 
@@ -350,6 +357,22 @@ module Jade
       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
@@ -155,6 +156,14 @@ module Jade
       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

data/lib/jade/stdlib/intrinsics.rb

@@ -76,10 +76,17 @@ module Jade
             constraints:,
           )
           .with(module_name:)
-          .tap { store(it) unless private }
+          .tap { store(it) }
+          .tap { private_names << name.to_s if private }
           .tap { Runtime.register(qualified_fn_name, &impl) }
       end
 
+      # Private means defined but not exposed: codegen and `implementation`
+      # resolve it, user modules cannot name it.
+      def private_names
+        @private_names ||= []
+      end
+
       # Approach A: the inline template is the single source of truth for a
       # function's behaviour. A hand-written block always wins. With no block
       # and a `body:` codegen override the function is codegen/dictionary-only
@@ -219,6 +226,7 @@ module Jade
       def exposes
         @symbols
           .reject { it.is_a?(Symbol::Implementation) }
+          .reject { it.is_a?(Symbol::StdlibFunction) && private_names.include?(it.name) }
           .map { it.to_ref }
       end
 

data/lib/jade/stdlib/result.rb

@@ -111,7 +111,7 @@ module Jade
           def on_error(result: Result(a, e), fn: e -> Result(a, f)) -> Result(a, f)
             case result
             in Err(error) then error |> fn
-            in Ok(_) then result
+            in Ok(value) then Ok(value)
             end
           end
 

data/lib/jade/stdlib/text.rb

@@ -0,0 +1,131 @@
+module Jade
+  module Stdlib
+    # Text representations of stdlib types, read in Ruby. Lives here rather
+    # than in Decimal / Clock / Calendar: those import Decode, so the
+    # instance cannot be registered the other way round. The types are
+    # compiled Jade, so constants resolve on first use.
+    #
+    # Accepts exactly what the Jade parsers did, down to `String.to_int`
+    # being `Integer(s, 10)` — whitespace and underscores included.
+    module Text
+      extend self
+
+      EPOCH_RATA_DIE = 719163
+      DAY_MS = 86_400_000
+
+      def to_decimal(s)
+        coefficient, exponent = s.split('e', 2)
+        return nil unless exponent
+
+        m = int(coefficient)
+        e = int(exponent)
+
+        m && e ? Jade::Decimal::Decimal[m, e] : nil
+      end
+
+      # No timezone offsets: `Clock.from_iso` never took them either.
+      def to_instant(s)
+        date_part, time_part = split_dt(s)
+        return nil unless date_part
+
+        d = to_date(date_part)
+        time = split_time(time_part)
+        return nil unless d && time
+
+        hour, minute, second, sub_ms = time
+        days = Jade::Calendar::Internal.to_rata_die(d) - EPOCH_RATA_DIE
+
+        Jade::Clock::Instant[
+          days * DAY_MS +
+            hour * 3_600_000 + minute * 60_000 + second * 1_000 + sub_ms
+        ]
+      end
+
+      def to_date(s)
+        parts = s.split('-')
+        return nil unless parts.length == 3
+
+        year, month, day = parts.map { int(it) }
+        return nil unless year && month && day
+
+        # Answers Jan outside 1..12 and never validates the day — calling
+        # it keeps that. Don't cache the Months: a second compile
+        # redefines the class.
+        Jade::Calendar::Date[
+          year,
+          Jade::Calendar::Internal.month_from_int(month),
+          day,
+        ]
+      end
+
+      # Seconds precision, always UTC. `rjust` matches `pad_to`, which
+      # left-pads without truncating: a negative year renders "00-5".
+      def from_instant(instant)
+        ms = instant._1
+        day_ms = ms % DAY_MS
+        d = Jade::Calendar::Internal.from_rata_die(ms / DAY_MS + EPOCH_RATA_DIE)
+
+        [
+          pad(d.year, 4),
+          '-', pad(Jade::Calendar::Internal.month_to_int(d.month), 2),
+          '-', pad(d.day, 2),
+          'T', pad(day_ms / 3_600_000, 2),
+          ':', pad(day_ms % 3_600_000 / 60_000, 2),
+          ':', pad(day_ms % 60_000 / 1_000, 2),
+          'Z',
+        ].join
+      end
+
+      private
+
+      def int(s) = Integer(s, 10, exception: false)
+
+      def pad(n, width) = n.to_s.rjust(width, '0')
+
+      def split_dt(s)
+        parts = s.split('T')
+        parts = s.split(' ') unless parts.length == 2
+
+        parts.length == 2 ? parts : nil
+      end
+
+      def split_time(s)
+        parts = strip_z(s).split(':')
+        return nil unless parts.length == 3
+
+        hour = int(parts[0])
+        minute = int(parts[1])
+        second, sub_ms = seconds(parts[2])
+
+        hour && minute && second && sub_ms ? [hour, minute, second, sub_ms] : nil
+      end
+
+      # A stray second "Z" falls through unstripped, as it did before.
+      def strip_z(s)
+        parts = s.split('Z')
+
+        parts.length == 1 || parts.length == 2 ? parts[0] : s
+      end
+
+      def seconds(s)
+        parts = s.split('.')
+
+        case parts.length
+        when 1 then [int(parts[0]), 0]
+        when 2 then [int(parts[0]), millis(int(parts[1]), parts[1].length)]
+        else [nil, nil]
+        end
+      end
+
+      def millis(n, digits)
+        return nil unless n
+
+        case digits <=> 3
+        when 0 then n
+        when -1 then n * 10.pow(3 - digits)
+        else n / 10.pow(digits - 3)
+        end
+      end
+    end
+  end
+end

data/lib/jade/task.rb

@@ -92,9 +92,8 @@ module Jade
       private
 
       def decode(decoder, value)
-        case Jade::Decode::Runner.run(decoder, value)
-        in Jade::Result::Ok[v]  then v
-        in Jade::Result::Err[e] then fail Jade::Interop::DecodeError.new(e, value)
+        Jade::Decode::Runner.run!(decoder, value) do |error|
+          fail Jade::Interop::DecodeError.new(error, value)
         end
       end
     end