jade-lang 0.12.0 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e6f1ff92a99cc704dd81615de9b97ffd0f7e650ca23adac6c7ede429eeb8ffe
-  data.tar.gz: ba35d16db8a3ff88f46ef726df1f19c27fc93a20366d0acd1faec55764690f9c
+  metadata.gz: fd36bbcd9dc0af93f281ebf187acafe5eb8b19d9cb868375a4261a2c8346e3c8
+  data.tar.gz: 631ba0267189d7d59bf014fe44fb07bec65d657bc0f87ba809bee8bfd577c503
 SHA512:
-  metadata.gz: 9f07bb37ec67df7e734a007eadbf0d4ac0b2309e893f0b29b139ed6f04984478551cab0c5ac7ed0c02a83ffb4cf82353490aed477ec1e51b26c0a5961c3fa799
-  data.tar.gz: 8d87c617b0784d10185cbaaa851d2f34c649ce80ede4b82cafdcde1b4bc569f3e2841e514476fc3c95a4fa6eddf67f09e921f0b838dcf6aa45d8d1bedb34ad3b
+  metadata.gz: 7343d1d44fc2eab19f07360d5d87369c3707e005b51493a58911c07ef52e6c6832e270a54741e325d0ccbdbd65d7ea5f7b6b744fa21bea6bcc68c7d14d235534
+  data.tar.gz: 31c9091262b1472f3e51a5797bf1b6ab13359693b774f2912b62d3a53e185124260a6c493cff2d1a5cf7f712b87367ce3fcd346da1577e568d349519441331ae

data/CHANGELOG.md

@@ -6,6 +6,45 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.12.2] - 2026-09-24
+
+### Fixed
+
+- **A hoisted dictionary is built on first use, not while the module loads.**
+  One can hold the result of calling a module function, and that function's
+  own body can name another dictionary — emitted as constants in the order
+  they were written, the second was still undefined while the first was being
+  built, and requiring the module raised `uninitialized constant DICT_6`.
+  Whether it happened depended on the order the dictionaries were discovered
+  in, so adding an unrelated function could break a module that compiled
+  yesterday. They are memoised singleton methods now, cleared on each load so
+  a reloaded module does not keep dictionaries closing over classes the
+  reload replaced.
+
+## [0.12.1] - 2026-09-21
+
+Both of these make code compile that should have compiled, so they ride a
+patch rather than waiting for a minor.
+
+### Fixed
+
+- **A pattern in a lambda is checked against the type the caller gives it.**
+  Coverage was decided where the pattern was written, which for a lambda is
+  before the call that types its parameter — so the subject was still a
+  variable and anything but a binding or a wildcard was reported as
+  non-exhaustive. `(a, b) = p` inside a `List.map` is the common shape;
+  `Tuple.first` / `Tuple.second` or a one-armed `case` were the workarounds.
+  Coverage and redundancy now run once inference has finished.
+
+### Added
+
+- **`Show` renders a `Dict` and a `Set`.** Both already had `Eq`, so they
+  compared but could not be printed, and anything that shows a value on
+  failure — a test assertion, a debug line — stopped compiling at
+  `Show cannot be derived for Dict(String, Int)`. Keys, values and elements
+  render through their own instances, so a `String` key keeps its quotes and a
+  nested list prints as a list.
+
 ## [0.12.0] - 2026-09-17
 
 ### Breaking

data/lib/jade/codegen/context.rb

@@ -56,6 +56,20 @@ module Jade
         @dict_consts = prev
       end
 
+      # The module the dictionary methods are defined on, so a reference from
+      # inside `Internal` still finds them.
+      def dict_owner
+        @dict_owner
+      end
+
+      def with_dict_owner(owner)
+        prev = @dict_owner
+        @dict_owner = owner
+        yield
+      ensure
+        @dict_owner = prev
+      end
+
       # When set, references with this name emit as `self` (and field accesses
       # on them as bare method calls). Used to rewrite operator-impl lambda
       # bodies — `(a, b) -> { a.amount == b.amount }` becomes

data/lib/jade/codegen/function_call.rb

@@ -140,7 +140,8 @@ module Jade
         table = Codegen.dict_consts or return source
         return source if Codegen.dict_env.values.any? { source.include?(it) }
 
-        table[source] ||= "DICT_#{table.size}"
+        table[source] ||= "dict_#{table.size}"
+        "::#{Codegen.dict_owner}.#{table[source]}"
       end
 
       # Polymorphic fn referenced as a value (not called). Wraps the fn with

data/lib/jade/codegen/inlines.rb

@@ -178,6 +178,8 @@ module Jade
       # Bodies that don't fit a single Ruby expression.
       NO_INLINE = %w[
         Number.checked
+        Dict.show_with
+        Set.show_with
         List.sort_with
         List.sort_by_with
         List.filter_map

data/lib/jade/codegen.rb

@@ -109,10 +109,12 @@ module Jade
         outer, inner, wrappers =
           with_substitution(registry.get(name).env.substitution) do
             with_dict_consts(dict_consts) do
-              with_boundary_cache(boundary_cache) do
-                with_dispatched_methods(collect_dispatched_methods(body, registry)) do
-                  with_hoisted_records do
-                    partition_module_body(body.expressions, registry, name.count('.'))
+              with_dict_owner(to_qualified(name)) do
+                with_boundary_cache(boundary_cache) do
+                  with_dispatched_methods(collect_dispatched_methods(body, registry)) do
+                    with_hoisted_records do
+                      partition_module_body(body.expressions, registry, name.count('.'))
+                    end
                   end
                 end
               end
@@ -365,9 +367,25 @@ module Jade
     # weighed against its specialized form, say), and a discarded one can
     # still have claimed a constant. Keep the ones that survived, and the
     # ones those refer to.
+    # Memoised methods rather than constants: a dictionary can hold the
+    # result of calling a module function, and that function's own body can
+    # name another dictionary. Constants are evaluated in the order they are
+    # written, so that dependency could reach forward to one not defined
+    # yet; a method body runs when it is first called, by which time every
+    # definition exists.
     def referenced_dicts(table, body)
       reachable_dicts(table, body.join(Pretty.newline))
-        .map { |source, const| "#{const} = #{source}.freeze" }
+        .map { |source, const| dict_method(const, source) }
+    end
+
+    # The nil assignment runs on every load, so a reloaded module rebuilds
+    # its dictionaries rather than keeping ones that close over the classes
+    # the reload just replaced.
+    def dict_method(const, source)
+      [
+        "@#{const} = nil",
+        Pretty.block("def self.#{const}", "@#{const} ||= #{source}.freeze"),
+      ].join(Pretty.newline(2))
     end
 
     # A kept dictionary can name another one, so widen the search text

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

@@ -24,6 +24,8 @@ module Jade
             # reason. Contained because derivation is private — see
             # vault jade/plans/jade-test-runner.md for the four layers involved.
             LIST = 'List.List'
+            DICT = 'Dict.Dict'
+            SET = 'Set.Set'
 
             def special_case(constraint, lookup)
               case constraint.type
@@ -33,6 +35,12 @@ module Jade
               in Type::Application(constructor: Type::Constructor(name: LIST), args: [inner])
                 list_show(constraint, inner, lookup)
 
+              in Type::Application(constructor: Type::Constructor(name: DICT), args: [key, value])
+                container_show(constraint, [key, value], 'Dict.show_with', lookup)
+
+              in Type::Application(constructor: Type::Constructor(name: SET), args: [inner])
+                container_show(constraint, [inner], 'Set.show_with', lookup)
+
               else
                 nil
               end
@@ -57,6 +65,22 @@ module Jade
                 end
             end
 
+            # Threads each element's own `show` into the stdlib function that
+            # renders the container.
+            def container_show(constraint, inners, fn, lookup)
+              inners
+                .map { lookup.call(Type.constraint(INTERFACE, it, constraint.origin)) }
+                .then { Results.sequence(it) }
+                .and_then do |deps|
+                  args = deps.each_index.map { [:impl_arg, it, 'show'] } + [[:var, 'value']]
+
+                  Symbol::DerivedFunction
+                    .new(params: ['value'], body: [:call, [:stdlib_fn, fn], args])
+                    .then { Ok[implementation(constraint, { 'show' => it }, deps:)] }
+                end
+            end
+
+
             def constant(text)
               Symbol::DerivedFunction.new(params: ['value'], body: text)
             end

data/lib/jade/frontend/type_checking/inference/assign.rb

@@ -33,9 +33,8 @@ module Jade
                 [pattern_state, expr_result.constraints]
               end
 
-            PatternAnalysis::Exhaustiveness
-              .assert([pattern], pattern.range, final_state.env, expr_result.type)
-              .then { final_state.add_errors(it) }
+            final_state
+              .defer_patterns([pattern], pattern.range, expr_result.type)
               .unify_result(
                 expr_result.with(constraints: residual_cs),
                 expected.type,

data/lib/jade/frontend/type_checking/inference/case_of.rb

@@ -86,12 +86,7 @@ module Jade
             patterns = branches.map(&:pattern)
             type     = result.apply(state.env.substitution).type
 
-            [
-              PatternAnalysis::Exhaustiveness.assert(patterns, node.range, state.env, type),
-              PatternAnalysis::Redundancy.assert(patterns, state.env, type),
-            ]
-              .flatten
-              .then { state.add_errors(it) }
+            state.defer_patterns(patterns, node.range, type)
           end
 
           def mistyped_patterns?(node, state)

data/lib/jade/frontend/type_checking/inference/lambda.rb

@@ -54,10 +54,7 @@ module Jade
                 in AST::Pattern::Binding | AST::Pattern::Wildcard
                   acc
                 else
-                  concrete_t = body_state.env.substitution.apply(t)
-                  PatternAnalysis::Exhaustiveness
-                    .assert([p], p.range, acc.env, concrete_t)
-                    .then { acc.add_errors(it) }
+                  acc.defer_patterns([p], p.range, t)
                 end
               end
 

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

@@ -0,0 +1,30 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      # The coverage and redundancy of every `case` in a definition, decided
+      # against the substitution inference ended with rather than the one in
+      # scope where the patterns were written.
+      module PatternChecks
+        extend self
+
+        def run(state)
+          state
+            .pattern_checks
+            .flat_map { |(patterns, range, type)| errors_for(patterns, range, type, state.env) }
+            .then { state.add_errors(it) }
+        end
+
+        private
+
+        def errors_for(patterns, range, type, env)
+          resolved = env.substitution.apply(type)
+
+          [
+            PatternAnalysis::Exhaustiveness.assert(patterns, range, env, resolved),
+            PatternAnalysis::Redundancy.assert(patterns, env, resolved),
+          ].flatten
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,16 @@
 module Jade
   module Frontend
     module TypeChecking
-      State = Data.define(:env, :errors, :skip_constraints, :impl_requirements) do
+      State = Data.define(:env, :errors, :skip_constraints, :impl_requirements, :pattern_checks) do
         def self.init(env, skip_constraints: false)
-          new(env, [], skip_constraints, {})
+          new(env, [], skip_constraints, {}, [])
+        end
+
+        # Coverage is decided once inference is done: a pattern in a lambda is
+        # checked before the call that gives the lambda's parameter its type,
+        # so the subject can still be a variable here.
+        def defer_patterns(patterns, range, type)
+          with(pattern_checks: pattern_checks + [[patterns, range, type]])
         end
 
         def require_impl(key, constraints)

data/lib/jade/frontend/type_checking.rb

@@ -8,6 +8,7 @@ require 'jade/frontend/type_checking/expected'
 require 'jade/frontend/type_checking/inference'
 require 'jade/frontend/type_checking/loader'
 require 'jade/frontend/type_checking/narrowing'
+require 'jade/frontend/type_checking/pattern_checks'
 require 'jade/frontend/type_checking/port_resolution'
 require 'jade/frontend/type_checking/requirements'
 require 'jade/frontend/type_checking/result'
@@ -28,7 +29,7 @@ module Jade
           .load(entry, registry)
           .then { collect_constraints(entry, registry, it) }
           .then { check_node(entry.ast, registry, State.init(it), Expected.infer(it.fresh)) }
-          .then { |state, _| Requirements.reconcile(entry, registry, state) }
+          .then { |state, _| Requirements.reconcile(entry, registry, PatternChecks.run(state)) }
           .then { |amended, state| complete(amended, state, registry) }
           .and_then { PortResolution.resolve(it, registry) }
       end

data/lib/jade/stdlib/dict.rb

@@ -69,6 +69,18 @@ module Jade
         end
       end
 
+      function(
+        :show_with,
+        { show_key: 'k -> String', show_value: 'v -> String', dict: 'Dict(k, v)' },
+        'String',
+        private: true,
+      ) do |show_key, show_value, dict|
+        dict.hash
+          .map { |k, v| "#{show_key.call(k)}: #{show_value.call(v)}" }
+          .join(', ')
+          .then { "Dict(#{it})" }
+      end
+
       function(:keys, { dict: 'Dict(k, v)' }, 'List(k)')
       function(:values, { dict: 'Dict(k, v)' }, 'List(v)')
       function(:to_list, { dict: 'Dict(k, v)' }, 'List(Tuple2(k, v))')

data/lib/jade/stdlib/set.rb

@@ -24,6 +24,18 @@ module Jade
         constraints: [['Basics.Eq', 'a']],
       )
 
+      function(
+        :show_with,
+        { show_value: 'a -> String', set: 'Set(a)' },
+        'String',
+        private: true,
+      ) do |show_value, set|
+        set.hash.keys
+          .map { show_value.call(it) }
+          .join(', ')
+          .then { "Set(#{it})" }
+      end
+
       function(:"empty?", { set: 'Set(a)' }, 'Bool')
       function(:size, { set: 'Set(a)' }, 'Int')
 

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.12.0'
+  VERSION = '0.12.2'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.2
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-09-17 00:00:00.000000000 Z
+date: 2026-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -315,6 +315,7 @@ files:
 - lib/jade/frontend/type_checking/instantiation.rb
 - lib/jade/frontend/type_checking/loader.rb
 - lib/jade/frontend/type_checking/narrowing.rb
+- lib/jade/frontend/type_checking/pattern_checks.rb
 - lib/jade/frontend/type_checking/placeholder.rb
 - lib/jade/frontend/type_checking/port_resolution.rb
 - lib/jade/frontend/type_checking/requirements.rb