rigortype 0.2.7 → 0.2.8

data/lib/rigor/trinary.rb

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
 module Rigor
-  # Three-valued logic value object shared by capability queries, relational
-  # queries, and any analyzer surface that distinguishes "proven yes",
-  # "proven no", and "cannot prove either".
+  # Three-valued logic value object shared by capability queries, relational queries, and any
+  # analyzer surface that distinguishes "proven yes", "proven no", and "cannot prove either".
   #
   # See docs/type-specification/relations-and-certainty.md for semantics and
   # docs/internal-spec/internal-type-api.md for the contract.
   class Trinary
     VALUES = %i[yes no maybe].freeze
 
-    # ADR-15 Phase 4b.x — eager singleton instances so the
-    # class-level `@yes` / `@no` / `@maybe` ivars are populated
-    # on the main Ractor at load time. Workers READ the ivars
-    # via `Trinary.yes` etc. without performing the `||=`
-    # write that non-main Ractors are forbidden from doing.
-    # The actual `@yes = new(:yes).freeze` allocation happens
-    # at the bottom of the file, AFTER `def initialize` is
-    # defined.
+    # ADR-15 Phase 4b.x — eager singleton instances so the class-level `@yes` / `@no` /
+    # `@maybe` ivars are populated on the main Ractor at load time. Workers READ the ivars
+    # via `Trinary.yes` etc. without performing the `||=` write that non-main Ractors are
+    # forbidden from doing. The actual `@yes = new(:yes).freeze` allocation happens at the
+    # bottom of the file, AFTER `def initialize` is defined.
     class << self
       attr_reader :yes, :no, :maybe
 
@@ -103,8 +99,8 @@ module Rigor
       raise TypeError, "expected Rigor::Trinary, got #{other.class}"
     end
 
-    # ADR-15 Phase 4b.x eager singletons (see `class << self`
-    # above). Allocated after `initialize` is defined.
+    # ADR-15 Phase 4b.x eager singletons (see `class << self` above). Allocated after
+    # `initialize` is defined.
     @yes = new(:yes).freeze
     @no = new(:no).freeze
     @maybe = new(:maybe).freeze

data/lib/rigor/type/acceptance_router.rb

@@ -4,12 +4,10 @@ module Rigor
   module Type
     # Routes `accepts` through the engine's acceptance dispatcher.
     #
-    # Every carrier's acceptance check is the same fixed forwarding on
-    # `self` — `Inference::Acceptance.accepts(self, other, mode: mode)` —
-    # so it lived as an identical copy in fourteen carriers. The one
-    # exception is `Type::App`, which forwards on its reduced `bound`
-    # type rather than `self`; it keeps its own `accepts` and does not
-    # include this.
+    # Every carrier's acceptance check is the same fixed forwarding on `self` —
+    # `Inference::Acceptance.accepts(self, other, mode: mode)` — so it lived as an identical copy in
+    # fourteen carriers. The one exception is `Type::App`, which forwards on its reduced `bound` type rather
+    # than `self`; it keeps its own `accepts` and does not include this.
     module AcceptanceRouter
       def accepts(other, mode: :gradual)
         Inference::Acceptance.accepts(self, other, mode: mode)

data/lib/rigor/type/accepts_result.rb

@@ -5,23 +5,19 @@ require_relative "../value_semantics"
 
 module Rigor
   module Type
-    # Immutable value object returned by `Rigor::Type#accepts(other, mode:)`.
-    # Carries the three-valued answer alongside the boundary mode the answer
-    # was computed under and an ordered list of textual reasons describing
-    # which rules fired.
+    # Immutable value object returned by `Rigor::Type#accepts(other, mode:)`. Carries the three-valued
+    # answer alongside the boundary mode the answer was computed under and an ordered list of textual
+    # reasons describing which rules fired.
     #
-    # AcceptsResult is the dual of `SubtypeResult` (Slice 5+). Acceptance
-    # answers "is `other` passable to `self` at a method-parameter or
-    # assignment boundary?", consulting the gradual-typing rules in
-    # docs/type-specification/value-lattice.md when `mode` is `:gradual`,
-    # and the strict subset relation when `mode` is `:strict`. Phase 2c
-    # ships full `:gradual` semantics; `:strict` is reserved for later
+    # AcceptsResult is the dual of `SubtypeResult` (Slice 5+). Acceptance answers "is `other` passable to
+    # `self` at a method-parameter or assignment boundary?", consulting the gradual-typing rules in
+    # docs/type-specification/value-lattice.md when `mode` is `:gradual`, and the strict subset relation
+    # when `mode` is `:strict`. Phase 2c ships full `:gradual` semantics; `:strict` is reserved for later
     # slices and currently raises ArgumentError.
     #
-    # Reasons are stored as plain strings for now. Slice 5+ MAY upgrade
-    # them to structured records (rule id, supporting facts, dynamic
-    # provenance); callers MUST treat the reasons array as opaque except
-    # for human-readable logging.
+    # Reasons are stored as plain strings for now. Slice 5+ MAY upgrade them to structured records (rule
+    # id, supporting facts, dynamic provenance); callers MUST treat the reasons array as opaque except for
+    # human-readable logging.
     #
     # See docs/internal-spec/internal-type-api.md ("Result Value Objects").
     class AcceptsResult

data/lib/rigor/type/app.rb

@@ -5,36 +5,29 @@ require_relative "../value_semantics"
 
 module Rigor
   module Type
-    # A defunctionalised higher-kinded type application — the abstract
-    # "apply type-constructor `uri` to argument list `args`" carrier.
+    # A defunctionalised higher-kinded type application — the abstract "apply type-constructor `uri` to
+    # argument list `args`" carrier.
     #
-    # `uri` is a namespaced `Symbol` of the form `:author::name`
-    # (e.g. `:"json::value"`, `:"dry_monads::result"`); the `::`
-    # namespace separator is mandatory per ADR-20 WD1 to prevent
+    # `uri` is a namespaced `Symbol` of the form `:author::name` (e.g. `:"json::value"`,
+    # `:"dry_monads::result"`); the `::` namespace separator is mandatory per ADR-20 WD1 to prevent
     # cross-plugin tag collisions.
     #
-    # `args` is an ordered, frozen `Array` of `Rigor::Type` values
-    # carrying the application's argument list. At least one argument
-    # is required; arity-zero "HKT" forms are not modelled by this
-    # carrier (use a plain type alias instead).
+    # `args` is an ordered, frozen `Array` of `Rigor::Type` values carrying the application's argument
+    # list. At least one argument is required; arity-zero "HKT" forms are not modelled by this carrier
+    # (use a plain type alias instead).
     #
-    # `bound` is a `Rigor::Type` representing the value Rigor MUST
-    # erase to when this `App` cannot be reduced — registered at
-    # `%a{rigor:v1:hkt_register}` time, defaulting to
-    # `Rigor::Type::Dynamic[Rigor::Type::Top]` per ADR-20 D5 / WD2. It
-    # also drives the lattice probes (`top` / `bot` / `dynamic`) and
-    # the acceptance fallback while no reduction is wired (Slice 1).
+    # `bound` is a `Rigor::Type` representing the value Rigor MUST erase to when this `App` cannot be
+    # reduced — registered at `%a{rigor:v1:hkt_register}` time, defaulting to
+    # `Rigor::Type::Dynamic[Rigor::Type::Top]` per ADR-20 D5 / WD2. It also drives the lattice probes
+    # (`top` / `bot` / `dynamic`) and the acceptance fallback while no reduction is wired (Slice 1).
     #
-    # Slice 1 ships the carrier as **opaque**: every operation
-    # delegates to `bound` since no reduction surface exists yet. Slice
-    # 2 introduces the conditional / indexed-access evaluator that
-    # reduces `App` to its registered body before delegating; the
-    # carrier shape stays identical.
+    # Slice 1 ships the carrier as **opaque**: every operation delegates to `bound` since no reduction
+    # surface exists yet. Slice 2 introduces the conditional / indexed-access evaluator that reduces `App`
+    # to its registered body before delegating; the carrier shape stays identical.
     #
-    # Display form per ADR-20 OQ5: bare RBS-style `uri[arg1, arg2]`,
-    # not the wrapped `App[uri, [arg1, arg2]]` faithful form. Two
-    # `App` values are structurally equal iff their `uri`, `args`,
-    # AND `bound` match.
+    # Display form per ADR-20 OQ5: bare RBS-style `uri[arg1, arg2]`, not the wrapped `App[uri, [arg1,
+    # arg2]]` faithful form. Two `App` values are structurally equal iff their `uri`, `args`, AND `bound`
+    # match.
     #
     # See docs/adr/20-lightweight-hkt.md.
     class App
@@ -91,9 +84,8 @@ module Rigor
         "#<Rigor::Type::App #{describe(:short)} (bound=#{bound.describe(:short)})>"
       end
 
-      # ADR-20 Slice 2a — reduce this application against a
-      # registry. Returns the reducer's output (`bound` when
-      # reduction is blocked or fuel exhausts).
+      # ADR-20 Slice 2a — reduce this application against a registry. Returns the reducer's output
+      # (`bound` when reduction is blocked or fuel exhausts).
       def reduce(registry, fuel: nil)
         fuel ||= Inference::HktReducer::DEFAULT_FUEL
         registry.reduce(self, fuel: fuel)

data/lib/rigor/type/bot.rb

@@ -5,13 +5,11 @@ require_relative "acceptance_router"
 
 module Rigor
   module Type
-    # The bottom of the value lattice: contains no values. The result type of
-    # expressions that cannot terminate normally. See
-    # docs/type-specification/special-types.md.
+    # The bottom of the value lattice: contains no values. The result type of expressions that cannot
+    # terminate normally. See docs/type-specification/special-types.md.
     class Bot
-      # ADR-15 Phase 4b.x — eager singleton so workers READ
-      # `@instance` without performing the lazy `||=` write
-      # that non-main Ractors are forbidden from doing.
+      # ADR-15 Phase 4b.x — eager singleton so workers READ `@instance` without performing the lazy `||=`
+      # write that non-main Ractors are forbidden from doing.
       @instance = new.freeze
 
       class << self

data/lib/rigor/type/bound_method.rb

@@ -9,23 +9,18 @@ module Rigor
   module Type
     # A `Method` carrier that tracks the bound `(receiver, name)` pair.
     #
-    # Ruby's `Object#method(name)` returns a `Method` instance whose
-    # later `.call` / `.()` / `[]` dispatches `name` on the original
-    # receiver. The plain RBS `Method` nominal cannot carry that
-    # binding, so call sites on the resulting `Method` collapse to
-    # `untyped` — losing the per-method precision the original
-    # receiver supports.
+    # Ruby's `Object#method(name)` returns a `Method` instance whose later `.call` / `.()` / `[]`
+    # dispatches `name` on the original receiver. The plain RBS `Method` nominal cannot carry that
+    # binding, so call sites on the resulting `Method` collapse to `untyped` — losing the per-method
+    # precision the original receiver supports.
     #
-    # `BoundMethod` keeps the binding so the dispatcher can substitute
-    # the original `(receiver, name)` dispatch at `.call` / `.()` /
-    # `[]` time. The carrier erases to `Method` at the RBS boundary so
-    # downstream RBS interop (e.g. passing the value into a method
-    # whose parameter is typed `::Method`) stays compatible — the
-    # binding is only consulted when Rigor itself dispatches.
+    # `BoundMethod` keeps the binding so the dispatcher can substitute the original `(receiver, name)`
+    # dispatch at `.call` / `.()` / `[]` time. The carrier erases to `Method` at the RBS boundary so
+    # downstream RBS interop (e.g. passing the value into a method whose parameter is typed `::Method`)
+    # stays compatible — the binding is only consulted when Rigor itself dispatches.
     #
-    # See `lib/rigor/inference/method_dispatcher/method_folding.rb`
-    # for the forward (`Object#method(:sym)`) and backward
-    # (`BoundMethod#call`) folding tiers that consume / produce this
+    # See `lib/rigor/inference/method_dispatcher/method_folding.rb` for the forward
+    # (`Object#method(:sym)`) and backward (`BoundMethod#call`) folding tiers that consume / produce this
     # carrier.
     class BoundMethod
       attr_reader :receiver_type, :method_name