rigortype 0.2.7 → 0.2.8

data/lib/rigor/inference/fallback.rb

@@ -5,21 +5,17 @@ module Rigor
     FALLBACK_FAMILIES = %i[prism virtual].freeze
     private_constant :FALLBACK_FAMILIES
 
-    # Immutable value object recorded by the typer whenever Scope#type_of
-    # falls back to Dynamic[Top] for a node it does not yet recognise. The
-    # contract for emitting these events lives in
+    # Immutable value object recorded by the typer whenever Scope#type_of falls back to Dynamic[Top] for a
+    # node it does not yet recognise. The contract for emitting these events lives in
     # docs/internal-spec/inference-engine.md (Fail-Soft Policy).
     #
     # Fields:
-    # - node_class: the Ruby class of the node that triggered the
-    #   fallback (e.g. Prism::CallNode, or a Rigor::AST::Node subclass).
-    # - location: the Prism source location for real Prism nodes, or
-    #   nil for synthetic nodes.
-    # - family: :prism for real Prism nodes, :virtual for nodes
-    #   that include Rigor::AST::Node.
-    # - inner_type: the Rigor::Type returned to the caller (currently
-    #   always Dynamic[Top]; later slices may carry richer fallback
-    #   types).
+    # - node_class: the Ruby class of the node that triggered the fallback (e.g. Prism::CallNode, or a
+    #   Rigor::AST::Node subclass).
+    # - location: the Prism source location for real Prism nodes, or nil for synthetic nodes.
+    # - family: :prism for real Prism nodes, :virtual for nodes that include Rigor::AST::Node.
+    # - inner_type: the Rigor::Type returned to the caller (currently always Dynamic[Top]; later slices may
+    #   carry richer fallback types).
     class Fallback < Data.define(:node_class, :location, :family, :inner_type, :origin)
       def initialize(node_class:, location:, family:, inner_type:, origin: nil)
         raise ArgumentError, "node_class must be a Class, got #{node_class.class}" unless node_class.is_a?(Class)

data/lib/rigor/inference/fallback_tracer.rb

@@ -4,16 +4,10 @@ require_relative "fallback"
 
 module Rigor
   module Inference
-    # Mutable observer that accumulates Rigor::Inference::Fallback events
-    # emitted by the type-inference engine. Pass an instance to
-    # Rigor::Scope#type_of(node, tracer: ...) to record every fail-soft
-    # fallback. The tracer MUST NOT change the return value of type_of;
-    # see docs/internal-spec/inference-engine.md (Fail-Soft Policy).
-    #
-    # Future slices may add additional record_* methods (e.g.
-    # record_dispatch_miss for Slice 3, record_budget_cutoff for Slice 5);
-    # the namespaced method names exist so a single tracer can collect
-    # multiple event families without confusing them.
+    # Mutable observer that accumulates Rigor::Inference::Fallback events emitted by the type-inference
+    # engine. Pass an instance to Rigor::Scope#type_of(node, tracer: ...) to record every fail-soft fallback.
+    # The tracer MUST NOT change the return value of type_of; see docs/internal-spec/inference-engine.md
+    # (Fail-Soft Policy).
     class FallbackTracer
       def initialize
         @events = []

data/lib/rigor/inference/flow_tracer.rb

@@ -2,21 +2,16 @@
 
 module Rigor
   module Inference
-    # Thread-local event recorder behind `rigor trace`: while a block runs
-    # under {record}, the inference engine emits a flat, ordered event
-    # stream describing HOW it typed the program — expression enter/result
-    # pairs, scope binds, union formation, and method-dispatch outcomes.
-    # The CLI replays that stream as a terminal animation (or dumps it as
-    # JSON); the engine itself never reads the events back, so recording
-    # is purely observational and MUST NOT change any inferred type.
+    # Thread-local event recorder behind `rigor trace`: while a block runs under {record}, the inference engine
+    # emits a flat, ordered event stream describing HOW it typed the program — expression enter/result pairs, scope
+    # binds, union formation, and method-dispatch outcomes. The CLI replays that stream as a terminal animation (or
+    # dumps it as JSON); the engine itself never reads the events back, so recording is purely observational and
+    # MUST NOT change any inferred type.
     #
-    # Modelled on {Analysis::DependencyRecorder}: thread-local state, a
-    # module-level activation count so the disabled fast path ({active?})
-    # is a plain integer read, and a frozen snapshot for consumers. The
-    # instrumented hot paths (`ExpressionTyper#type_of`,
-    # `Scope#with_local`, `Type::Combinator.union`,
-    # `MethodDispatcher.dispatch`) each guard their emit behind {active?},
-    # so a normal (non-tracing) run pays one integer comparison.
+    # Modelled on {Analysis::DependencyRecorder}: thread-local state, a module-level activation count so the
+    # disabled fast path ({active?}) is a plain integer read, and a frozen snapshot for consumers. The instrumented
+    # hot paths (`ExpressionTyper#type_of`, `Scope#with_local`, `Type::Combinator.union`, `MethodDispatcher.dispatch`)
+    # each guard their emit behind {active?}, so a normal (non-tracing) run pays one integer comparison.
     module FlowTracer
       KEY = :__rigor_flow_tracer__
       private_constant :KEY
@@ -25,18 +20,16 @@ module Rigor
       #
       # kind     :enter | :result | :bind | :union | :dispatch
       # depth    expression-recursion depth at emit time (0 = statement level)
-      # location frozen Hash with :start_line/:start_column/:end_line/
-      #          :end_column/:start_offset/:end_offset, or nil. Events
-      #          without a node of their own (:bind, :union) inherit the
-      #          innermost in-flight expression node's location so the
-      #          replayer can still highlight the source being evaluated.
+      # location frozen Hash with :start_line/:start_column/:end_line/:end_column/:start_offset/:end_offset, or nil.
+      #          Events without a node of their own (:bind, :union) inherit the innermost in-flight expression
+      #          node's location so the replayer can still highlight the source being evaluated.
       # stack    frozen Array of short node-class names, outermost first
-      # data     frozen kind-specific Hash (types pre-rendered as Strings
-      #          via `describe(:short)` so events serialise to JSON as-is)
+      # data     frozen kind-specific Hash (types pre-rendered as Strings via `describe(:short)` so events
+      #          serialise to JSON as-is)
       Event = Data.define(:kind, :depth, :location, :stack, :data)
 
-      # Mutable per-thread accumulator; only ever touched by the thread
-      # that activated it, so no locking is needed on the emit path.
+      # Mutable per-thread accumulator; only ever touched by the thread that activated it, so no locking is needed
+      # on the emit path.
       class Recorder
         attr_reader :events
 
@@ -45,9 +38,8 @@ module Rigor
           @stack = []
         end
 
-        # Brackets one `ExpressionTyper#type_of` recursion: emits :enter,
-        # runs the real inference, emits :result with the inferred type,
-        # and returns the type unchanged.
+        # Brackets one `ExpressionTyper#type_of` recursion: emits :enter, runs the real inference, emits :result
+        # with the inferred type, and returns the type unchanged.
         def node(node)
           location = location_of(node)
           name = short_name(node.class)
@@ -100,9 +92,8 @@ module Rigor
 
       module_function
 
-      # Activates recording on the current thread for the duration of the
-      # block and returns the frozen event list. Nests safely; restores
-      # the previous recorder on exit.
+      # Activates recording on the current thread for the duration of the block and returns the frozen event list.
+      # Nests safely; restores the previous recorder on exit.
       def record
         previous = Thread.current[KEY]
         recorder = Recorder.new
@@ -120,9 +111,8 @@ module Rigor
         @active_count.positive?
       end
 
-      # Brackets one expression-typing recursion. Falls through to the
-      # bare block when the current thread is not recording (another
-      # thread may have flipped {active?}).
+      # Brackets one expression-typing recursion. Falls through to the bare block when the current thread is not
+      # recording (another thread may have flipped {active?}).
       def trace_node(node, &)
         recorder = Thread.current[KEY]
         return yield unless recorder
@@ -135,8 +125,7 @@ module Rigor
         Thread.current[KEY]&.emit(:bind, data: { name: name.to_s, type: describe(type) })
       end
 
-      # `Type::Combinator.union` — the moment branch types merge
-      # (including degenerate collapses like `1 | 1 → 1`).
+      # `Type::Combinator.union` — the moment branch types merge (including degenerate collapses like `1 | 1 → 1`).
       def union(members, result)
         Thread.current[KEY]&.emit(
           :union,
@@ -144,8 +133,8 @@ module Rigor
         )
       end
 
-      # `MethodDispatcher.dispatch` — resolution or the fail-soft `nil`
-      # ("no rule matched"; the caller will widen to `Dynamic[Top]`).
+      # `MethodDispatcher.dispatch` — resolution or the fail-soft `nil` ("no rule matched"; the caller will widen
+      # to `Dynamic[Top]`).
       def dispatch(receiver:, method_name:, args:, result:, location: nil)
         recorder = Thread.current[KEY]
         return unless recorder

data/lib/rigor/inference/hkt_body.rb

@@ -2,45 +2,35 @@
 
 module Rigor
   module Inference
-    # ADR-20 Slice 2a — node types for the parsed body of a
-    # type-function `Definition`. Each node represents one
-    # piece of a Rigor-side type expression that the reducer
-    # ({HktReducer}) walks against a concrete argument list.
+    # ADR-20 Slice 2a — node types for the parsed body of a type-function `Definition`. Each node
+    # represents one piece of a Rigor-side type expression that the reducer ({HktReducer}) walks
+    # against a concrete argument list.
     #
-    # Slice 2a ships a programmatic constructor surface; plugin
-    # and Rigor-bundled overlay authors may build a body tree
-    # by hand using these node types. The string-grammar parser
-    # (`HktBodyParser`, Slice 2b, shipped) reads `Definition#body`
-    # (populated by Slice 1's `HktDirectives.parse_define`) into
-    # this node tree; `body_tree` is the evaluable form.
+    # Slice 2a ships a programmatic constructor surface; plugin and Rigor-bundled overlay authors
+    # may build a body tree by hand using these node types. The string-grammar parser
+    # (`HktBodyParser`, Slice 2b, shipped) reads `Definition#body` (populated by Slice 1's
+    # `HktDirectives.parse_define`) into this node tree; `body_tree` is the evaluable form.
     #
-    # The nine node types cover JSON.parse, dry-monads, and the
-    # ADR-20 § D3 conditional / membership forms (shipped):
+    # The nine node types cover JSON.parse, dry-monads, and the ADR-20 § D3 conditional /
+    # membership forms (shipped):
     #
-    # - {TypeLeaf}    — wraps a fully-built `Rigor::Type`
-    #   (use for atoms like `nil`, `Constant<true>`,
-    #   `Nominal[Integer]`).
-    # - {Param}       — reference to a formal parameter
-    #   declared in the enclosing `Definition#params` list
-    #   (e.g. `K` in `json::value[K]`). The reducer
-    #   substitutes from the application's `args`.
-    # - {AppRef}      — abstract HKT application; the reducer
-    #   resolves it via the registry, or returns the `App`
-    #   carrier as-is when the reference is self-recursive
-    #   (lazy "tying-the-knot" handling that lets recursive
-    #   sums like `json::value` reduce without infinite
-    #   expansion).
+    # - {TypeLeaf}    — wraps a fully-built `Rigor::Type` (use for atoms like `nil`,
+    #   `Constant<true>`, `Nominal[Integer]`).
+    # - {Param}       — reference to a formal parameter declared in the enclosing
+    #   `Definition#params` list (e.g. `K` in `json::value[K]`). The reducer substitutes from the
+    #   application's `args`.
+    # - {AppRef}      — abstract HKT application; the reducer resolves it via the registry, or
+    #   returns the `App` carrier as-is when the reference is self-recursive (lazy
+    #   "tying-the-knot" handling that lets recursive sums like `json::value` reduce without
+    #   infinite expansion).
     # - {Union}       — N-ary union of arms.
-    # - {NominalApp}  — parameterised nominal class
-    #   (`Array[X]`, `Hash[K, V]`) whose type args are
+    # - {NominalApp}  — parameterised nominal class (`Array[X]`, `Hash[K, V]`) whose type args are
     #   themselves body nodes.
     #
-    # Every node is a frozen `Data.define` value; structural
-    # equality is by-field.
+    # Every node is a frozen `Data.define` value; structural equality is by-field.
     module HktBody
-      # Wraps a pre-built `Rigor::Type` value. Use for atoms
-      # that need no substitution (e.g. `Nominal[Integer]`,
-      # `Constant<nil>`).
+      # Wraps a pre-built `Rigor::Type` value. Use for atoms that need no substitution
+      # (e.g. `Nominal[Integer]`, `Constant<nil>`).
       TypeLeaf = Data.define(:type) do
         def initialize(type:)
           raise ArgumentError, "type must not be nil" if type.nil?
@@ -49,12 +39,10 @@ module Rigor
         end
       end
 
-      # Reference to a formal parameter the enclosing
-      # `Definition#params` declared. The reducer substitutes
-      # this node with the matching positional arg from the
-      # `App` being reduced; an unknown name raises during
-      # reduction (the parser, when it ships, MUST reject
-      # unknown names earlier).
+      # Reference to a formal parameter the enclosing `Definition#params` declared. The reducer
+      # substitutes this node with the matching positional arg from the `App` being reduced; an
+      # unknown name raises during reduction (the parser, when it ships, MUST reject unknown names
+      # earlier).
       Param = Data.define(:name) do
         def initialize(name:)
           raise ArgumentError, "name must be a Symbol, got #{name.class}" unless name.is_a?(Symbol)
@@ -63,11 +51,9 @@ module Rigor
         end
       end
 
-      # Abstract HKT application — the reducer's primary
-      # recursion point. `uri` is a namespaced Symbol
-      # matching some `Registration` in the registry; `args`
-      # is an Array of body nodes (each gets substituted /
-      # resolved before being used).
+      # Abstract HKT application — the reducer's primary recursion point. `uri` is a namespaced
+      # Symbol matching some `Registration` in the registry; `args` is an Array of body nodes
+      # (each gets substituted / resolved before being used).
       AppRef = Data.define(:uri, :args) do
         def initialize(uri:, args:)
           raise ArgumentError, "uri must be a Symbol, got #{uri.class}" unless uri.is_a?(Symbol)
@@ -79,9 +65,8 @@ module Rigor
         end
       end
 
-      # N-ary union. The reducer builds the result through
-      # `Type::Combinator.union(*reduced_arms)` so
-      # normalization (flattening, dedup, Bot drop) applies.
+      # N-ary union. The reducer builds the result through `Type::Combinator.union(*reduced_arms)`
+      # so normalization (flattening, dedup, Bot drop) applies.
       Union = Data.define(:arms) do
         def initialize(arms:)
           raise ArgumentError, "arms must be an Array, got #{arms.class}" unless arms.is_a?(Array)
@@ -91,12 +76,9 @@ module Rigor
         end
       end
 
-      # Parameterised nominal class. `class_name` is the
-      # Ruby class name (`"Array"`, `"Hash"`); `args` is an
-      # Array of body nodes for the type arguments. The
-      # reducer builds the result through
-      # `Type::Combinator.nominal_of(class_name, type_args:
-      # reduced_args)`.
+      # Parameterised nominal class. `class_name` is the Ruby class name (`"Array"`, `"Hash"`);
+      # `args` is an Array of body nodes for the type arguments. The reducer builds the result
+      # through `Type::Combinator.nominal_of(class_name, type_args: reduced_args)`.
       NominalApp = Data.define(:class_name, :args) do
         def initialize(class_name:, args:)
           unless class_name.is_a?(String) && !class_name.empty?
@@ -109,17 +91,14 @@ module Rigor
         end
       end
 
-      # ADR-20 § D3 — conditional type form. `test` is a
-      # {TestSubtype} / {TestEquality} / {TestMembership}
-      # value object the reducer evaluates against the
-      # current bindings; `then_branch` / `else_branch` are
-      # body nodes. The reducer's trinary handling:
+      # ADR-20 § D3 — conditional type form. `test` is a {TestSubtype} / {TestEquality} /
+      # {TestMembership} value object the reducer evaluates against the current bindings;
+      # `then_branch` / `else_branch` are body nodes. The reducer's trinary handling:
       #
       # - test = `yes` → return the reduced `then_branch`.
       # - test = `no` → return the reduced `else_branch`.
-      # - test = `maybe` → widen to the union of both
-      #   reduced branches (per ADR-20 WD7 / robustness
-      #   principle).
+      # - test = `maybe` → widen to the union of both reduced branches (per ADR-20 WD7 /
+      #   robustness principle).
       Conditional = Data.define(:test, :then_branch, :else_branch) do
         def initialize(test:, then_branch:, else_branch:)
           raise ArgumentError, "test must not be nil" if test.nil?
@@ -130,8 +109,8 @@ module Rigor
         end
       end
 
-      # `left <: right` — subtype check. `left` is typically
-      # a {Param} reference; `right` is any body expression.
+      # `left <: right` — subtype check. `left` is typically a {Param} reference; `right` is any
+      # body expression.
       TestSubtype = Data.define(:left, :right) do
         def initialize(left:, right:)
           raise ArgumentError, "left/right must not be nil" if left.nil? || right.nil?
@@ -140,9 +119,8 @@ module Rigor
         end
       end
 
-      # `left == right` — structural equality. Useful for
-      # discriminating against literal constants
-      # (`E == :symbol`).
+      # `left == right` — structural equality. Useful for discriminating against literal
+      # constants (`E == :symbol`).
       TestEquality = Data.define(:left, :right) do
         def initialize(left:, right:)
           raise ArgumentError, "left/right must not be nil" if left.nil? || right.nil?
@@ -151,9 +129,8 @@ module Rigor
         end
       end
 
-      # `left in [opt1, opt2, ...]` — set membership. Each
-      # `option` is a body node; the test passes iff `left`
-      # is structurally equal to any of the options.
+      # `left in [opt1, opt2, ...]` — set membership. Each `option` is a body node; the test
+      # passes iff `left` is structurally equal to any of the options.
       TestMembership = Data.define(:left, :options) do
         def initialize(left:, options:)
           raise ArgumentError, "left must not be nil" if left.nil?

data/lib/rigor/inference/hkt_body_parser.rb

@@ -5,17 +5,13 @@ require_relative "../type"
 
 module Rigor
   module Inference
-    # ADR-20 slice 2b — parses the body of an
-    # `HktRegistry::Definition` (a `String`, as populated by
-    # Slice 1's `HktDirectives.parse_define` from
-    # `%a{rigor:v1:hkt_define}` payloads) into the `HktBody`
-    # node tree the Slice 2a reducer evaluates against.
+    # ADR-20 slice 2b — parses the body of an `HktRegistry::Definition` (a `String`, as populated
+    # by Slice 1's `HktDirectives.parse_define` from `%a{rigor:v1:hkt_define}` payloads) into the
+    # `HktBody` node tree the Slice 2a reducer evaluates against.
     #
-    # The grammar implements the full ADR-20 § D3 subset:
-    # union-of-atoms/parameterised-forms for `JSON.parse`'s
-    # `json::value` recursive sum, plus the conditional and
-    # membership forms shipped in subsequent slices. Indexed-access
-    # forms remain deferred (no concrete demand yet).
+    # The grammar implements the full ADR-20 § D3 subset: union-of-atoms/parameterised-forms for
+    # `JSON.parse`'s `json::value` recursive sum, plus the conditional and membership forms
+    # shipped in subsequent slices. Indexed-access forms remain deferred (no concrete demand yet).
     #
     # ## Grammar
     #
@@ -37,22 +33,17 @@ module Rigor
     #
     # ## Disambiguation
     #
-    # The same syntactic UCNAME spells both a parameter
-    # reference (`K` when `params = [:K]`) and a nominal class
-    # name (`Integer`). The parser resolves by checking the
-    # `params` set passed to {.parse}; an unknown UCNAME is
-    # treated as a nominal class name. `App` is reserved at
-    # the head position of an `App[...]` form; using `App` as
-    # a class name is therefore not supported.
+    # The same syntactic UCNAME spells both a parameter reference (`K` when `params = [:K]`) and
+    # a nominal class name (`Integer`). The parser resolves by checking the `params` set passed
+    # to {.parse}; an unknown UCNAME is treated as a nominal class name. `App` is reserved at the
+    # head position of an `App[...]` form; using `App` as a class name is therefore not
+    # supported.
     #
-    # Atoms are kept verbatim as `HktBody::TypeLeaf` nodes
-    # wrapping the appropriate `Rigor::Type::*` carrier:
-    # `nil` / `true` / `false` produce `Constant` carriers;
-    # `bool` produces the `Constant<true> | Constant<false>`
-    # union; `untyped` produces `Combinator.untyped`
-    # (i.e. `Dynamic[Top]`). Nominal class names produce raw
-    # `Type::Nominal` carriers (no `name_scope` resolution at
-    # this slice — the reducer trusts the name verbatim).
+    # Atoms are kept verbatim as `HktBody::TypeLeaf` nodes wrapping the appropriate
+    # `Rigor::Type::*` carrier: `nil` / `true` / `false` produce `Constant` carriers; `bool`
+    # produces the `Constant<true> | Constant<false>` union; `untyped` produces
+    # `Combinator.untyped` (i.e. `Dynamic[Top]`). Nominal class names produce raw `Type::Nominal`
+    # carriers (no `name_scope` resolution at this slice — the reducer trusts the name verbatim).
     module HktBodyParser
       class ParseError < StandardError; end
 
@@ -159,14 +150,11 @@ module Rigor
         #     conditional := "(" test "?" union ":" union ")"
         #     test        := type_expr ("<:" | "==") type_expr
         #
-        # Parens delimit a conditional unambiguously — bare
-        # `(type_expr)` grouping is not supported at this slice
-        # (no use case yet). Branches can be unions; test sides
-        # are single arms (wrap in `App[my_union, ...]` if you
-        # need a union there). `in [opt1, opt2]` membership
-        # tests are programmatically supported via
-        # `HktBody::TestMembership` but the parser does not yet
-        # recognise the `in` keyword (no concrete demand yet).
+        # Parens delimit a conditional unambiguously — bare `(type_expr)` grouping is not
+        # supported at this slice (no use case yet). Branches can be unions; test sides are
+        # single arms (wrap in `App[my_union, ...]` if you need a union there). `in [opt1, opt2]`
+        # membership tests are programmatically supported via `HktBody::TestMembership` but the
+        # parser does not yet recognise the `in` keyword (no concrete demand yet).
         def parse_conditional
           expect!(:lparen)
           test = parse_test
@@ -196,11 +184,9 @@ module Rigor
           end
         end
 
-        # `left in [opt1, opt2, ...]` membership test.
-        # Distinguished from a lowercase atom by the
-        # subsequent `[` — the only place an identifier
-        # `in` is permitted at this position is membership
-        # syntax.
+        # `left in [opt1, opt2, ...]` membership test. Distinguished from a lowercase atom by the
+        # subsequent `[` — the only place an identifier `in` is permitted at this position is
+        # membership syntax.
         def parse_in_membership(left, op_token:)
           unless op_token.value == "in"
             raise ParseError,
@@ -243,11 +229,9 @@ module Rigor
           parse_nominal_or_param_with_args
         end
 
-        # Returns true when the current UCName is followed by
-        # `::` (qualified class name continuation) or `[`
-        # (parameterised application). In either case the
-        # token is a nominal, not a param ref — Slice 2b's
-        # `Param` nodes are always single bare identifiers.
+        # Returns true when the current UCName is followed by `::` (qualified class name
+        # continuation) or `[` (parameterised application). In either case the token is a
+        # nominal, not a param ref — Slice 2b's `Param` nodes are always single bare identifiers.
         def class_continuation?
           next_tok = @tokens[@pos + 1]
           next_tok && %i[sep lb].include?(next_tok.kind)
@@ -266,8 +250,8 @@ module Rigor
         end
 
         def parse_classname_with_leading_sep
-          # The leading "::" form (`::Foo::Bar`). Consume the
-          # separator so the rest threads through parse_class_name.
+          # The leading "::" form (`::Foo::Bar`). Consume the separator so the rest threads
+          # through parse_class_name.
           consume
           tok = peek
           raise ParseError, "expected class name after `::`" if tok.nil? || tok.kind != :ucname
@@ -307,13 +291,10 @@ module Rigor
           parts.join("::").to_sym
         end
 
-        # Arg list for `Foo[A, B, C]` and `App[uri, A, B]`
-        # forms. Each arg is parsed as a union so per-arg
-        # `A | B` forms work (`Array[K | nil]`); the COMMA
-        # at the top level still separates args, so
-        # `Hash[K, V]` reads as two args (each a single-arm
-        # union that collapses to the arm) rather than one
-        # union of two.
+        # Arg list for `Foo[A, B, C]` and `App[uri, A, B]` forms. Each arg is parsed as a union so
+        # per-arg `A | B` forms work (`Array[K | nil]`); the COMMA at the top level still
+        # separates args, so `Hash[K, V]` reads as two args (each a single-arm union that
+        # collapses to the arm) rather than one union of two.
         def parse_arg_list
           args = [parse_union]
           while peek_kind == :comma