jade-lang 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e6f1ff92a99cc704dd81615de9b97ffd0f7e650ca23adac6c7ede429eeb8ffe
-  data.tar.gz: ba35d16db8a3ff88f46ef726df1f19c27fc93a20366d0acd1faec55764690f9c
+  metadata.gz: 1b6d2de0940d8842121c48456180fa3cbc04345d0bf991c31f8e008019c4e017
+  data.tar.gz: 425323f1b3c92b1d817b088a3973b86c94f7743fe185197cb5d60c680281184f
 SHA512:
-  metadata.gz: 9f07bb37ec67df7e734a007eadbf0d4ac0b2309e893f0b29b139ed6f04984478551cab0c5ac7ed0c02a83ffb4cf82353490aed477ec1e51b26c0a5961c3fa799
-  data.tar.gz: 8d87c617b0784d10185cbaaa851d2f34c649ce80ede4b82cafdcde1b4bc569f3e2841e514476fc3c95a4fa6eddf67f09e921f0b838dcf6aa45d8d1bedb34ad3b
+  metadata.gz: 0da5c33762fdac3b212474c72925c1d47c48b915f7b4a6877a6328b3c07ac15430e0f97c5647d714886d498c94850a1a448100ae29cfd73d7f97abc3bfc2248c
+  data.tar.gz: ee26d40ebaa14f0587675692a83d977f6e7eae0ba80c342929847636c9c5509778fa7e19977974deb2421bf7cab0e17a066cafd4188f121d6165347cd1a4b3b4

data/CHANGELOG.md

@@ -6,6 +6,30 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [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/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/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.1'
 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.1
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-09-17 00:00:00.000000000 Z
+date: 2026-09-21 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