jade-lang 0.4.0 → 0.6.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
 
@@ -51,12 +50,21 @@ module Jade
 
       def hash(label, v)
         case v
-        when ::Hash then v
+        when ::Hash then string_keyed!(label, v)
         when ::Data then v.to_h.transform_keys(&:to_s)
         else type_error!(label, v)
         end
       end
 
+      # Mixed keys are a real shape mismatch; the per-field errors say more
+      # than a guess about intent would.
+      def string_keyed!(label, v)
+        return v if v.empty? || v.keys.any?(::String)
+
+        v.keys.grep(::Symbol)
+          .then { it.empty? ? v : raise(Jade::Interop::SymbolKeys.new(label, it)) }
+      end
+
       def type_error!(label, v)
         raise Jade::Interop::DecodeError.new(
           Jade::Decode::WrongType[label, Jade::Decode.type_name(v)],

data/lib/jade/interop/error.rb

@@ -40,12 +40,31 @@ module Jade
       end
     end
 
+    # Caught where the whole hash is in scope; downstream each field just
+    # reads nil and blames its own type.
+    class SymbolKeys < Error
+      def initialize(label, keys)
+        super(
+          "#{label} expects a Hash with string keys, got symbol keys " \
+            "(#{keys.take(4).map(&:inspect).join(', ')}). " \
+            "Values cross the boundary as wire data — " \
+            "try #{keys.first.to_s.inspect} rather than #{keys.first.inspect}."
+        )
+      end
+    end
+
     class DecodeError < Error
-      attr_reader :decode_error, :value
+      attr_reader :decode_error, :value, :source
+
+      SUBJECTS = {
+        argument: 'Ruby passed a value that failed to decode',
+        port_return: 'Port returned a value that failed to decode',
+      }.freeze
 
-      def initialize(decode_error, value)
+      def initialize(decode_error, value, source: :argument)
         @decode_error = decode_error
         @value = value
+        @source = source
         super(format(decode_error, value))
       end
 
@@ -54,16 +73,17 @@ module Jade
       def format(error, value)
         path, leaf = unwind(error)
         location = path.empty? ? "value" : path.join
+        subject = SUBJECTS.fetch(@source)
 
         case leaf
         in Jade::Decode::WrongType[expected, got]
-          "Port returned a value that failed to decode at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
+          "#{subject} at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
 
         in Jade::Decode::MissingField[key]
-          "Port returned a value that failed to decode at #{location}: missing field `#{key}` (#{value.inspect})"
+          "#{subject} at #{location}: missing field `#{key}` (#{value.inspect})"
 
         in Jade::Decode::Custom[msg]
-          "Port returned a value that failed to decode at #{location}: #{msg} (#{value.inspect})"
+          "#{subject} at #{location}: #{msg} (#{value.inspect})"
 
         in Jade::Decode::Multiple[errors]
           errors

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/module_loader/module_name.rb

@@ -0,0 +1,46 @@
+module Jade
+  module ModuleLoader
+    # A module is keyed by the name its file implies — imports resolve
+    # `Shop.Cart` to `shop/cart.jd` and back. The wrapper takes the declared
+    # name while every type reference inside takes the file's, so a mismatch
+    # emits Ruby referring to a constant that was never defined.
+    module ModuleName
+      extend self
+
+      def check(ast, source)
+        return Ok[ast] unless ast.is_a?(AST::Module)
+
+        source.to_module_name.then do |expected|
+          ast.name == expected ? Ok[ast] : Err[mismatch(ast, source, expected)]
+        end
+      end
+
+      private
+
+      def mismatch(ast, source, expected)
+        Diagnostics::List
+          .empty
+          .error(
+            "Module is declared as `#{ast.name}` but `#{source.uri}` defines `#{expected}`.",
+            source:,
+            span: name_span(ast),
+            label: "expected `#{expected}`",
+          )
+          .help("Rename it to `#{expected}`, or move the file to `#{path_for(ast.name)}`.")
+      end
+
+      # `module` is skipped during parsing, so the node starts at the name.
+      def name_span(ast)
+        ast.range.begin...(ast.range.begin + ast.name.length)
+      end
+
+      def path_for(module_name)
+        module_name
+          .split('.')
+          .map { Source.snake_case(it) }
+          .join('/')
+          .then { "#{it}.jd" }
+      end
+    end
+  end
+end

data/lib/jade/module_loader.rb

@@ -9,6 +9,7 @@ require 'jade/codegen'
 require 'jade/module_loader/cache'
 require 'jade/module_loader/dependency_resolver'
 require 'jade/module_loader/dependency_graph'
+require 'jade/module_loader/module_name'
 require 'jade/module_loader/normalize'
 require 'jade/module_loader/topological_sort'
 require 'jade/diagnostics'
@@ -132,6 +133,10 @@ module Jade
             .then { raise CompilationError.new(it) }
         end => Ok([raw_ast, comments])
 
+      ModuleName
+        .check(raw_ast, source)
+        .on_err { raise CompilationError.new(it) }
+
       Frontend::CommentAttacher
         .attach(raw_ast, comments, source)
         .then { Registry.entry(source.to_module_name).with(ast: it, source:, entry:) }

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