errgonomic 0.9.3 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58963c6e1c1cfcf52d8fe4b065dd986acda616f4e55001d7d2bc13cbeab1eb28
-  data.tar.gz: 9d6f93fdd27c94525f2f2a2dc53010eb4f99760dae7514eaf4f035f5c9947869
+  metadata.gz: 543390fc5f85546ffde4785cfc41951400800094506078271cfe32535e9d784a
+  data.tar.gz: 8d5cdf061dbf7026eaab5ba8cab628368c600943699dbad04235c9d1d9bd3f5a
 SHA512:
-  metadata.gz: 2adf6eadd64c94629ba265ea9747d943314616f8c26943ad075ea5399bc86c4747e433946273989640b668e0841c337cdc6f3ecc873fed9006aa82eb439510d9
-  data.tar.gz: 475c6a42553b89700d4de4d0d7257bcbb71388c61d8b12da69a51ce4aa30a75f7074757a498bb20d5074539748b8e799bf8c78303ef3dc8ac33a74306d615aad
+  metadata.gz: ad7cbe42d7f1d65549323c026a3f4486d4e64a9b5274023fc3eebb0a576ceb09c030151d176512220e13ef8d6e1bc3c2bff78162783ecb286bbb6805ac16c8c9
+  data.tar.gz: 4588909f84b800a1c497882d030fd88f23606146fe64b7ae02ecc8b7f4406ba2c5dd749d0c709c7004717de80a9a69e73d6247b2ce11013446fa25db66271c3d

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## [Unreleased]
 
+## [0.10.1] - 2026-09-10
+
+This release makes cross-type equality raise unconditionally and removes the switch that used to turn it on.
+
+### Upgrading from 0.10.0
+
+`Errgonomic.strict_equality=`, `Errgonomic.strict_equality?` and `Errgonomic.with_strict_equality` are removed, along with `rake test:strict`, because cross-type equality always raises now. A `Some(x) == x`, `!= x`, `eql?(x)` or `=== x` anywhere in an application raises `Errgonomic::TypeMismatchError` where 0.10.0 answered `false` unless strict equality was switched on, and so does a collection operation that compares pairwise and asks the wrapper (`[Some(x)].include?(x)`, `Array#index`, `Array#-`, `Array#==`, `Hash#==`, `case x when Some(x)`) and a Minitest `assert_equal` whose expected value is a wrapper. Which operations raise, by which side holds the wrapper, is listed in the README's Strict equality section. Compare wrappers (`opt == Some(x)`), test the inner value (`opt.some_and? { |v| v == x }`), or `unwrap_or` a fallback first. Delete any `Errgonomic.strict_equality = true` in a test helper; it has nothing left to set.
+
+### Changes
+
+- [Behavior change] `==`, `!=`, `eql?` and `===` between an Option or a Result and a value that is not one always raise `Errgonomic::TypeMismatchError`, with the message 0.9.0 gave under the flag. `Some(1) == 1` answering `false` is the silent wrong branch that mirrors a wrapper written into a string, and 0.9.0 had the safe behavior opt-in. `===` is defined so `case 5 when Some(5)` and a pinned pattern raise under the operator that was written. `eql?` is not exempted: Ruby's hashing compares hash values first and asks `eql?` only of a candidate whose hash matches, so `Hash#[]`, `Set` and `uniq` stay quiet while `Array#include?`, `Array#-`, `Array#==` and `case/when` compare pairwise and raise when the wrapper is the operand asked. Strict equality never answers wrong, it only sometimes fails to catch, and `nil == Some(1)` is answered by `NilClass` and cannot be intercepted. The README states the whole surface
+- `Errgonomic.strict_equality=`, `Errgonomic.strict_equality?` and `Errgonomic.with_strict_equality` are removed, which also removes a process-global flag that leaked across threads and whose block form's `ensure` could turn the mode off for a thread that had set it
+- `Errgonomic.lenient_inner_value_comparison?` and `Errgonomic.give_me_lenient_inner_value_comparison=` are removed; nothing read them
+- [Dev, Test] `rake test:strict` is removed, with its support file and CI step: the Rails integration suite runs under strict equality as `rake test`
+
+## [0.10.0] - 2026-09-10
+
+This release gives `deconstruct` the Rust shape and names the four variants at top level, so a pattern reads as `in Some(v)`.
+
+### Upgrading from 0.9.3
+
+`deconstruct` answers `[value]` for a `Some`, an `Ok` and an `Err` and `[]` for a `None`, so a pattern written against 0.9.x's `[self, value]` has to change shape: `in Errgonomic::Option::Some, v` becomes `in Some(v)`, `in Errgonomic::Result::Err, String => msg` becomes `in Err(String => msg)`, and `in Errgonomic::Option::None` stays as it is or becomes `in None`. `Some`, `None`, `Ok` and `Err` are now top-level names for the four variants, for patterns, as well as constructors. An application that defines its own constant under one of those names has to rename it: errgonomic refuses to load over one with a `NameError`, and a `class` or `module` of that name written after it loads raises `TypeError`.
+
+### Changes
+
+- [Behavior change] `deconstruct` answers `[value]` for a `Some`, an `Ok` and an `Err` and `[]` for a `None`, the one-payload shape `Data.define(:value)` and Rust's tuple variants share, where 0.9.x answered `[self, value]` and `[None]`. `in Some(v)` binds the value, `in Ok(Some(v))` nests, a two-branch `case/in` with no `else` is exhaustive, and a wrong type reaches `NoMatchingPatternError`. There is no `deconstruct_keys`: a one-payload sum type has no named field, and a `Some` around a Hash nests as `in Some({ id: })` through the Hash's own protocol
+- A value-less `Err()` deconstructs to `[]`, so `in Err` and `in Err()` match it and `in Err(e)` matches only an `Err` that carries a value. The sentinel `Err()` holds in place of a value is internal, and a pattern variable must never bind it
+- `Some`, `None`, `Ok` and `Err` are defined at top level beside the constructors of the same name, so a pattern reads as it does in Rust. Each is an `Errgonomic::VariantName` rather than the class it names: it matches as that class in a pattern and a `case/when`, and a bare one, written as Rust writes `return None`, refuses to stand in for a value. `to_s`, `to_json`, `as_json` and every ActiveRecord boundary that unwraps an Option raise `Errgonomic::SerializeError` on it, where the class would write `Errgonomic::Option::None` into a string, a column or a query, and a boolean column would store `true`. A constant of the same name that the application already defines stops the gem's load with a `NameError`, and a `class None` written after the gem loads raises `TypeError`, rather than one replacing or reopening the other. Rails defines none of the four
+
 ## [0.9.3] - 2026-09-10
 
 This release removes the public `value` slot from `Some`, `Ok` and `Err`, and freezes every instance as it is constructed, so an Option or a Result is the value the README already said it was.

data/CONTRIBUTING.md

@@ -30,7 +30,6 @@ The inner rungs run constantly; the outer rungs are slower and run when preparin
 bundle exec rubocop        # formatted & lint-clean
 bundle exec yard doctest   # doctests pass — most behavior is specified here
 bundle exec rake test      # unit tests pass (incl. the Rails integration test)
-bundle exec rake test:strict # the same suite with cross-type equality raising
 ```
 
 A change that fails any of these is not ready. Keep formatting-only changes in their own commit so they do not obscure a behavioral diff. `bundle exec rake` runs the full suite (test + yard:doctest) in one shot.
@@ -43,7 +42,7 @@ nix build .#errgonomic           # the gem builds as a derivation; rake runs in
 nix flake check --all-systems    # builds every check on the local system, evaluates all four
 ```
 
-**After push (CI gate):** a push is done when CI is green, not when `git push` succeeds. Check whatever CI this repo runs (`gh run list`, `gh run view --log-failed`); checks take minutes, so it is fine to schedule the check as a followup and keep working — but the change is not landed until they pass. A CI failure is a regression: diagnose it from the logs, reproduce it locally where you can, and capture it as a test so it cannot recur silently. CI earns you the coverage you cannot run locally — a target your machine isn't, a matrix leg, a slower suite — for free. Here, CI (`.github/workflows/main.yml`) runs `yard doctest`, `rake test` and `rake test:strict` on the latest Ruby 3.4.x on ubuntu-latest, matching the Ruby pinned by the flake.
+**After push (CI gate):** a push is done when CI is green, not when `git push` succeeds. Check whatever CI this repo runs (`gh run list`, `gh run view --log-failed`); checks take minutes, so it is fine to schedule the check as a followup and keep working — but the change is not landed until they pass. A CI failure is a regression: diagnose it from the logs, reproduce it locally where you can, and capture it as a test so it cannot recur silently. CI earns you the coverage you cannot run locally — a target your machine isn't, a matrix leg, a slower suite — for free. Here, CI (`.github/workflows/main.yml`) runs `yard doctest` and `rake test` on the latest Ruby 3.4.x on ubuntu-latest, matching the Ruby pinned by the flake.
 
 Tests *are* the requirements: a behavior is defined by the test that asserts it. Prefer doctests where an example clarifies a function's contract — they document and test at once and cannot drift out of date without failing the build. In this repo, the YARD `@example` blocks under `lib/**/*.rb` are the primary suite.
 

data/README.md

@@ -111,17 +111,21 @@ Some(1).each.to_a                # => [1]
 
 `map` wraps whatever the block returns, as Rust's does, so a block that itself returns an Option gives `Some(Some(x))`. `and_then` is the spelling for that block.
 
-Options support pattern matching:
+Options pattern match in the Rust shape. `Some`, `None`, `Ok` and `Err` name the variants in a pattern as well as building them, so a pattern reads as it does in Rust:
 
 ```ruby
 case measurement
-in Errgonomic::Option::Some, value
+in Some(value)
   "Measurement is #{value}"
-in Errgonomic::Option::None
+in None
   "Measurement is not available"
 end
 ```
 
+Leave the `else` off: the two branches cover an Option, and a value that is not one raises `NoMatchingPatternError` where an `else` would take it quietly. When that value is a Result, the error's message refuses to print; see the `case/in` note below. `deconstruct` answers `[value]` for a `Some` and `[]` for a `None`, the one-payload shape `Data.define(:value)` and Rust's tuple variants share, and there is no `deconstruct_keys`, because a one-payload sum type has no named field. Patterns nest through the inner value's own protocol instead: `in Ok(Some(value))` reaches through a Result, and `in Some({ id: })` reaches into a Hash a `Some` wraps.
+
+A bare `Some`, `None`, `Ok` or `Err`, without parentheses, is that name and not a value, where Rust's `return None` is one. It matches as the class it names in a pattern or a `case/when`, and refuses to stand in for a value: interpolation, `to_s`, `join`, `to_json` and `as_json` raise `Errgonomic::SerializeError` (`bare None names a variant for a pattern, not a value; build one with parentheses`), and so does handing one to an ActiveRecord attribute, a bulk write or a `where`. It is not a class, so `is_a?`, `kind_of?` and `instance_of?` raise `TypeError` when given the bare name (`class or module required`), `Some.new`, `Some <= Errgonomic::Option::Any` and `Some.name` raise `NoMethodError`, and Minitest's `assert_kind_of Some, x` raises the same `TypeError` before it can assert anything. Each has a working spelling: check the variant with `x.some?`, `x.none?`, `x.ok?` or `x.err?`, or give the fully qualified class anywhere a class or module is required, as in `x.is_a?(Errgonomic::Option::Some)`, `assert_kind_of Errgonomic::Option::Some, x`, `Errgonomic::Option::Some.new(1)`, `Errgonomic::Option::Some <= Errgonomic::Option::Any` or `Errgonomic::Option::Some.name`. Build with the constructor, `Some(1)`, rather than `.new`. An application constant of the same name collides loudly: defined before errgonomic loads, it stops the load with a `NameError`, and a `class None` or `module Ok` written after raises `TypeError` where it is written. Two forms get past that. `None = …` assigned after the load replaces the name with only Ruby's `already initialized constant` warning, and in a Rails application Zeitwerk skips an autoloaded `app/models/ok.rb` because `Ok` is already defined, so the first call on `Ok` raises `NoMethodError`.
+
 An unhandled Option refuses to leak into your output: `to_s`, `to_json` and `as_json` raise `Errgonomic::SerializeError`, so you handle the inner value deliberately rather than shipping `Some("...")` to a user. The refusal names what it was carrying (`cannot serialize an unwrapped Some("cell-a1b2")`), so a payload built out of many values says which one went unhandled; the value's `inspect` is bounded to 60 characters, with an ellipsis past that. The refusal covers `as_json` because Hash and Array serialization recurses through that method, and an Option nested in a payload would otherwise serialize as `{"value": ...}`. A converted ActiveRecord model is the one exception, at the model boundary: it unwraps each attribute as it serializes, so a record's own `as_json` says what an unconverted record's says. See [Rails integration](#rails-integration).
 
 The `to_s` refusal is the loudest guard of the three, because a string is where a wrapper turns into data: string interpolation, `Array#join`, `format`, `String()`, a bare ERB `<%= %>` and the key of a Hash on its way to JSON all reach the value through `to_s`, and every one of them raises rather than writing `Some("...")` into a hostname, a column or a page. Rust gives `Option` a `Debug` and no `Display`, and `inspect` is the `Debug` here: it renders `Some(1)`, and it is what a log line or a `rescue` should call (`"got #{opt.inspect}"`). The refusal says so: `Some(1) refuses to_s; use inspect for a log line, or unwrap_or / expect! for the value`.
@@ -146,7 +150,7 @@ The remaining present-side helpers are soft-deprecated on Options in favor of th
 
 Four of Rust's methods are deliberately absent: `take`, `replace`, `insert` and `get_or_insert`. Every one of them writes through an `&mut Option`, and an Option here is a value rather than a slot: `Some(1)` is something you pass around and compare, not a cell whose contents you swap out from under another reference. Build the Option you want and assign it where the old one lived. The same rule is why a `Some`, an `Ok` and an `Err` have no `value` reader or writer, and why every instance is frozen as it is constructed. A copy that skips construction, from `dup`, `Marshal.load`, a YAML load or ActiveSupport's `deep_dup`, is not frozen; with no writer, it changes only through `instance_variable_set`. A reader would reach the inner value with no `None` branch, and a writer would move a Hash key out from under its own bucket. Reach in with `unwrap_or`, `expect!`, `map`, `and_then` or a pattern, each of which names what happens on the other branch.
 
-Equality is between Options only: `Some(5) == Some(5)`, but `Some(5) == 5` and `None() == nil` are `false`. That is quiet, never an error, matching how every Ruby object compares across types. Rust rejects `Some(5) == 5` at compile time; Ruby cannot, so guard the idiom in review and tests: compare against a wrapped value (`opt == Some(5)`) or test the inner value (`opt.some_and? { |v| v == 5 }`). `Errgonomic.strict_equality = true` turns that guard into an error, which is what a test suite wants; see [Pedantic runtime checks](#pedantic-runtime-checks).
+Equality is between Options only: `Some(5) == Some(5)` is `true` and `Some(5) == Some(6)` is `false`, and comparing an Option with anything that is not one raises `Errgonomic::TypeMismatchError`. Rust rejects `Some(5) == 5` at compile time; Ruby cannot, and a quiet `false` there is a silent wrong branch, the same failure as a wrapper written into a string. Compare against a wrapped value (`opt == Some(5)`), test the inner value (`opt.some_and? { |v| v == 5 }`), or `unwrap_or` a fallback first. `None() == nil` raises too, pointing at `none?`. See [Strict equality](#strict-equality) for where the raise reaches and where it cannot.
 
 Ordering is between Options too, and unlike equality it says so out loud. `None()` sorts before any `Some` and two `Some`s order by their inner values, so a collection of Options sorts. Ordering one against a bare value raises `Errgonomic::TypeMismatchError` naming both operands and the spellings that work: `Some(read_at) <= Time.current` used to answer `nil` from `<=>`, which `Comparable` turned into an `ArgumentError` naming the Option as the operand at fault. Test the inner value (`read_at.some_and? { |t| t <= Time.current }`) or reach for it with `map` or `unwrap_or`. Two Options whose inner values do not compare still answer `nil`, as Ruby expects. That message is the gem's only where the Option is the receiver: with it on the right (`2 < Some(1)`, `[Some(1), 2].max`) `Integer` answers the comparison itself and Ruby raises its own `ArgumentError: comparison of Integer with Errgonomic::Option::Some failed`. Results order the same way, with `ok_and?` in place of `some_and?`.
 
@@ -172,11 +176,11 @@ Results also pattern match, including against the kind of inner value:
 
 ```ruby
 case result
-in Errgonomic::Result::Ok, value
+in Ok(value)
   "Measurement is #{value}"
-in Errgonomic::Result::Err, String => msg
+in Err(String => msg)
   "Measurement failed with a message: #{msg}"
-in Errgonomic::Result::Err, Exception => e
+in Err(Exception => e)
   "Measurement produced an exception -- #{e.class}: #{e}"
 end
 ```
@@ -253,35 +257,37 @@ Errgonomic.with_ambiguous_downstream_errors do
 end
 ```
 
-Cross-type equality is the other pedantic check, and it is off by default because a quiet `false` is what every Ruby object answers. Turn it on and a comparison between a wrapper and a value that is not one raises `Errgonomic::TypeMismatchError`, naming both classes and the spelling to reach for:
+### Strict equality
 
-```ruby
-Errgonomic.strict_equality = true
+Cross-type equality is the other pedantic check, and there is no switch for it. A comparison between a wrapper and a value that is not one raises `Errgonomic::TypeMismatchError`, naming both classes and the spelling to reach for:
 
+```ruby
 Some(5) == 5        # => raises Errgonomic::TypeMismatchError
 Some(5) != 5        # => raises
 Some(5).eql?(5)     # => raises
+Some(5) === 5       # => raises, so `case 5 when Some(5)` raises too
 None() == nil       # => raises, pointing at none?
 Ok(1) == 1          # => raises
 Some(1) == Ok(1)    # => raises: an Option and a Result are different containers
-Some(5) == Some(5)  # => true, as always
+Some(5) == Some(5)  # => true
+Some(5) == None()   # => false
 
 1 == Some(1)        # => raises, through Integer's coercion fallback
 nil == None()       # => false, quietly
 "a" == Some("a")    # => false, quietly
 ```
 
-A Result is cross-type for an Option and an Option is cross-type for a Result: they are different containers, neither is the other, and the message says to unwrap whichever one you meant. Two Options, or two Results, compare as they always did, and `hash` is untouched, so an Option stays usable as a Hash key with it on.
+A Result is cross-type for an Option and an Option is cross-type for a Result: they are different containers, neither is the other, and the message says to unwrap whichever one you meant. Two Options, or two Results, compare by variant and inner value, and `hash` is untouched, so an Option is a Hash key like any other value.
 
-Strictness fires when the wrapper is the receiver, and also when the left operand hands the comparison over: `1 == Some(1)` raises because `Integer#==` falls back to asking the right-hand side. `nil == None()` and `"a" == Some("a")` stay quietly false, because `NilClass` and `String` answer for themselves and never consult the operand. Put the wrapper on the left in a test if you want the check to reach every comparison. It is meant for a test suite or CI, not for production, and there is a block form for scoping it the way the ambiguous-error opt-out is scoped:
+The raise surface is uneven, because Ruby's collections reach equality three ways, and which side holds the wrapper decides what happens. The paragraph after this one gives the rule for `==` itself.
 
-```ruby
-Errgonomic.with_strict_equality do
-  assert_equal Some(5), book.pages
-end
-```
+- Pairwise `==`: `Array#include?`, `Array#index`, `Array#delete`, `Array#count`, `Array#==`, `Hash#==`, `case/when` and Minitest's `assert_equal` raise when the wrapper is the one asked: a member of the collection searched (`[Some(1)].include?(1)`), a `when` clause, or `assert_equal`'s expected value, which comes back as an error rather than a failure. With the wrapper on the other side the bare value answers. An Integer or another Numeric hands the comparison back, so `[1].include?(Some(1))` raises too; a String, a Symbol or `nil` answers `false` itself, so `["a"].include?(Some("a"))` and `case Some("a") when "a"` stay quiet, and `assert_equal "a", Some("a")` is an ordinary failure.
+- Pairwise `eql?`: `Array#-`, `Array#&` and `Array#|` compare member by member with `eql?` while the arrays are short, and a bare value's `eql?` never hands the comparison back. `[Some(1)] - [1]`, `[Some(1)] & [1]` and `[1] | [Some(1)]` raise; `[1] - [Some(1)]`, `[1] & [Some(1)]` and `[Some(1)] | [1]` stay quiet. Past Ruby's cutoff of 16 members they hash instead and stay quiet: `-` once both arrays are past it, `&` and `|` once either is.
+- Hashing: `Hash#[]`, `Set#include?`, `uniq` and `group_by` compare hash values first and ask `eql?` only of a candidate whose hash matches, so they stay quiet whichever side holds the wrapper.
+
+Strict equality never answers wrong; it only sometimes fails to catch.
 
-This gem runs its own Rails integration suite that way, as `rake test:strict`.
+Strictness fires when the wrapper is the receiver, and also when the left operand hands the comparison over: `1 == Some(1)` raises because `Integer#==` falls back to asking the right-hand side. `nil == Some(1)`, `nil == None()` and `"a" == Some("a")` stay quietly false, because `NilClass` and `String` answer for themselves and never consult the operand, and nothing in the gem can intercept them. Put the wrapper on the left in a test if you want the check to reach every comparison.
 
 ### Rails integration
 
@@ -409,7 +415,7 @@ It is available on every model, converted or not, because it lifts both ends one
 
 This is the register of where the gem leaves the Rust idiom, and why. ActiveRecord assumes things about accessors that a strict Rust `Option` cannot satisfy, so the integration carries five deliberate compromises, each one forced by a specific piece of ActiveRecord machinery rather than chosen. Everywhere else, treat a departure from Rust's `Option` semantics as a bug; these five are intended:
 
-1. `None#nil?` answers `true`, so ActiveRecord internals and ordinary `.nil?` checks treat an absent value as absent. Equality does not follow suit: `None() == nil` is still `false`. Nor does `Array#compact`, the common collection idiom for dropping absent members: it tests for the `nil` object, so it keeps a `None` where `reject(&:none?)` drops it.
+1. `None#nil?` answers `true`, so ActiveRecord internals and ordinary `.nil?` checks treat an absent value as absent. Equality does not follow suit: `None() == nil` raises `Errgonomic::TypeMismatchError`, pointing at `none?`, and `nil == None()` is `false`, answered by `NilClass`. Nor does `Array#compact`, the common collection idiom for dropping absent members: it tests for the `nil` object, so it keeps a `None` where `reject(&:none?)` drops it.
 2. `Some` delegates `persisted?` and `touch_later` to its record, so a `Some` can stand in for it where ActiveRecord reads an association back through its public reader, as a `belongs_to ..., touch: true` does after a save.
 3. An `Option` is unwrapped where a value enters ActiveRecord, above the column type in every case. Quoting and the predicate builder are patched so an `Option` passed into `where`/`quote` is unwrapped at the SQL boundary: `Some(v)` binds exactly as `v`, and `None()` as `nil`, so a hash condition asks for `IS NULL`. An array of Options unwraps too. An Option interpolated into raw SQL (`where("id = ?", opt)`) still raises, as it should. Assignment unwraps on the same principle. A singular association writer takes an Option of a record: `book.author = Some(author)` assigns it and `book.author = None()` clears the association, while a `Some` of the wrong class still raises `AssociationTypeMismatch`. An attribute writer takes an Option of a value, for every column type, and unwraps before the attribute is built, so `book.isbn = other.isbn` round-trips and nothing behind the reader ever holds a wrapper. A value that reaches the database without passing a writer unwraps where it enters ActiveRecord, above the column type in every case: in the ids and conditions `find` and `find_by` are given, on a class, a relation and an association alike; in the rows `update_all`, `insert_all` and `upsert` take; and in a default declared with `attribute :isbn, :string, default: Some('unassigned')`, unwrapped where it is written.
 4. `SomeValidator` asks whether a value is there at all, where `presence` asks whether it amounts to anything: `Some('')` passes `validates :x, some: true` and fails `presence: true`. It lifts what it is handed, so it asks the same question of any model, converted or not.

data/Rakefile

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
-require 'shellwords'
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |t|
@@ -17,16 +16,9 @@ YARD::Doctest::RakeTask.new do |task|
   task.pattern = FileList['lib/**/*.rb'].join(' ')
 end
 
-namespace :test do
-  desc 'Run the Rails integration suite with strict equality on'
-  task :strict do
-    ruby '-Ilib', '-Itest', 'test/support/strict_equality.rb', *Shellwords.split(ENV.fetch('TESTOPTS', ''))
-  end
-end
-
 # yard:doctest ends the process when it finishes, so anything after it in
 # the default list would never run.
-task default: %i[test test:strict yard:doctest]
+task default: %i[test yard:doctest]
 
 namespace :gems4nix do
   desc 'Regenerate gem-groups.json after Gemfile/Gemfile.lock changes'

data/lib/errgonomic/option.rb

@@ -2,6 +2,7 @@
 
 require 'set'
 require 'stringio'
+require_relative 'variant_name'
 
 module Errgonomic
   module Option
@@ -65,61 +66,84 @@ module Errgonomic
       end
 
       # An Option equals another Option of the same class with an equal inner
-      # value. Anything else, including nil and the raw inner value, is not
-      # equal: quietly false, never an error. Rust rejects Some(5) == 5 at
-      # compile time; Ruby cannot, and raising here would break the many
-      # places Ruby compares heterogeneous operands (Array#include?,
-      # assertion diffs, dirty tracking). Compare Options (opt == Some(5)) or
-      # test the inner value (opt.some_and? { |v| v == 5 }) instead.
+      # value. Comparing it with anything that is not an Option raises
+      # Errgonomic::TypeMismatchError, naming both sides and the spelling to
+      # reach for. Some(5) == 5 is the comparison Rust rejects at compile
+      # time, and a quiet false there is a silent wrong branch, the same
+      # failure as a wrapper written into a string. The raise reaches ==, !=,
+      # eql? and ===, and through them every collection operation that
+      # compares pairwise. Ruby's hashing compares hash values first and asks
+      # eql? only of a candidate whose hash matches, so a Hash lookup, a Set
+      # and uniq stay quiet with a wrong-typed key: strict equality never
+      # answers wrong, it only sometimes fails to catch. nil == Some(1) is
+      # answered by NilClass and cannot be intercepted.
       #
-      # None() == nil is likewise false: None is a value that represents
-      # absence, not an absence Ruby can see. (The Rails integration
-      # separately makes None#nil? answer true, as an ActiveRecord
-      # compromise; equality does not follow it.)
+      # None() == nil raises too: None is a value that represents absence,
+      # not an absence Ruby can see, and the message points at none?. (The
+      # Rails integration separately makes None#nil? answer true, as an
+      # ActiveRecord compromise; equality does not follow it.)
       #
       # @example
       #   Some(1) == Some(1) # => true
       #   Some(1) == Some(2) # => false
       #   Some(1) == None() # => false
       #   None() == None() # => true
-      #   Some(1) == 1 # => false
-      #   None() == nil # => false
-      #
-      # @example strict equality makes a cross-type comparison an error
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Some(5) == 5
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.class
-      #     end
-      #   end # => Errgonomic::TypeMismatchError
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Some(5) != 5
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.message.include?("!=")
-      #     end
-      #   end # => true
-      #   Errgonomic.with_strict_equality { Some(5) == Some(5) } # => true
-      #   Errgonomic.with_strict_equality { Some(5) == None() } # => false
+      #
+      # @example a cross-type comparison is an error, never a quiet false
+      #   Some(5) == 5 # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::Some == Integer, which strict equality refuses.\nCompare Options (opt == Some(5)), test the inner value (opt.some_and? { |v| v == 5 }), or unwrap_or a fallback first."
+      #   Some(5) != 5 # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::Some != Integer, which strict equality refuses.\nCompare Options (opt == Some(5)), test the inner value (opt.some_and? { |v| v == 5 }), or unwrap_or a fallback first."
+      #   Some(5) === 5 # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::Some === Integer, which strict equality refuses.\nCompare Options (opt == Some(5)), test the inner value (opt.some_and? { |v| v == 5 }), or unwrap_or a fallback first."
+      #   Some(5) === Some(5) # => true
+      #   1 == Some(1) # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::Some == Integer, which strict equality refuses.\nCompare Options (opt == Some(1)), test the inner value (opt.some_and? { |v| v == 1 }), or unwrap_or a fallback first."
       #
       # @example a Result is another container, not another Option
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Some(1) == Ok(1)
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.message.include?("different containers")
-      #     end
-      #   end # => true
+      #   Some(1) == Ok(1) # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::Some == Errgonomic::Result::Ok, which strict equality refuses.\nAn Option and a Result are different containers, and neither is the other. Unwrap the one you meant (opt.unwrap_or(nil) == res.unwrap_or(nil))."
       #
       # @example nil is another type, and absence here is the discriminant
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       None() == nil
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.message.include?("none?")
+      #   None() == nil # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::None == NilClass, which strict equality refuses.\nAbsence here is the discriminant: ask none?, or nil? under the Rails integration."
+      #
+      # @example the raise reaches every operation that compares pairwise
+      #   begin
+      #     [Some(1)].include?(1)
+      #   rescue Errgonomic::TypeMismatchError => e
+      #     e.class
+      #   end # => Errgonomic::TypeMismatchError
+      #   begin
+      #     [Some(1)] == [1]
+      #   rescue Errgonomic::TypeMismatchError => e
+      #     e.class
+      #   end # => Errgonomic::TypeMismatchError
+      #   begin
+      #     [Some(1), 1] - [1]
+      #   rescue Errgonomic::TypeMismatchError => e
+      #     e.class
+      #   end # => Errgonomic::TypeMismatchError
+      #   begin
+      #     { a: Some(1) } == { a: 1 }
+      #   rescue Errgonomic::TypeMismatchError => e
+      #     e.class
+      #   end # => Errgonomic::TypeMismatchError
+      #   begin
+      #     case 5
+      #     when Some(5) then :hit
       #     end
-      #   end # => true
+      #   rescue Errgonomic::TypeMismatchError => e
+      #     e.class
+      #   end # => Errgonomic::TypeMismatchError
+      #
+      # @example hashing compares hash values first, so these stay quiet
+      #   { Some(1) => :v }[1] # => nil
+      #   Set[Some(1)].include?(1) # => false
+      #   [Some(1), 1].uniq # => [Some(1), 1]
+      #
+      # @example a short array compares member by member with eql?, so the side the wrapper is on decides
+      #   [1] - [Some(1)] # => [1]
+      #   [Some(1)] | [1] # => [Some(1), 1]
+      #   [1] | [Some(1)] # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::Some eql? Integer, which strict equality refuses.\nCompare Options (opt == Some(1)), test the inner value (opt.some_and? { |v| v == 1 }), or unwrap_or a fallback first."
+      #
+      # @example nil and String answer for themselves, and never ask the Option
+      #   nil == Some(1) # => false
+      #   "a" == Some("a") # => false
       def ==(other)
         strict_equality!(other, '==')
         return false if self.class != other.class
@@ -128,6 +152,13 @@ module Errgonomic
         value == other.value
       end
 
+      # Object#=== is ==, so a `case value when Some(5)` and a pinned pattern
+      # reach the same check, named for the operator that was written.
+      def ===(other)
+        strict_equality!(other, '===')
+        self == other
+      end
+
       # Hash-based collections (Hash keys, Set, uniq, group_by) use eql? and
       # hash, not ==. Follow the inner value's own eql? semantics, so Options
       # behave as keys exactly like their inner values: Some(1) and Some(1.0)
@@ -140,22 +171,9 @@ module Errgonomic
       #   { Some(5) => 1 }[Some(5)] # => 1
       #   [Some(1), Some(1), None(), None()].uniq # => [Some(1), None()]
       #
-      # @example strict equality reaches eql?, and leaves hash alone
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Some(5).eql?(5)
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.class
-      #     end
-      #   end # => Errgonomic::TypeMismatchError
-      #   Errgonomic.with_strict_equality { Some(5).hash == Some(5).hash } # => true
-      # Ruby derives != from ==, so a strict-equality message would name the
-      # operator the caller did not write.
-      def !=(other)
-        strict_equality!(other, '!=')
-        super
-      end
-
+      # @example a cross-type eql? raises as == does, and hash is untouched
+      #   Some(5).eql?(5) # => raise Errgonomic::TypeMismatchError, "Errgonomic::Option::Some eql? Integer, which strict equality refuses.\nCompare Options (opt == Some(5)), test the inner value (opt.some_and? { |v| v == 5 }), or unwrap_or a fallback first."
+      #   Some(5).hash == Some(5).hash # => true
       def eql?(other)
         strict_equality!(other, 'eql?')
         return false if self.class != other.class
@@ -164,6 +182,13 @@ module Errgonomic
         value.eql?(other.value)
       end
 
+      # Ruby derives != from ==, so a strict-equality message would name the
+      # operator the caller did not write.
+      def !=(other)
+        strict_equality!(other, '!=')
+        super
+      end
+
       # @example
       #   Some(5).hash == Some(5).hash # => true
       #   None().hash == None().hash # => true
@@ -174,20 +199,65 @@ module Errgonomic
         [self.class, value].hash
       end
 
+      # The Rust shape: a Some deconstructs to its one payload and a None to
+      # nothing, so `in Some(v)` binds the value and `in None` matches. There
+      # is no deconstruct_keys, because a one-payload sum type has no named
+      # field; a Some wrapping a Hash nests as `in Some({id:})` through the
+      # Hash's own protocol.
+      #
       # @example
-      #   measurement = Errgonomic::Option::Some.new(1)
+      #   Some(1).deconstruct # => [1]
+      #   None().deconstruct # => []
+      #   Some(1).respond_to?(:deconstruct_keys) # => false
+      #
+      # @example a two-branch case/in with no else is exhaustive
+      #   measurement = Some(1)
       #   case measurement
-      #   in Errgonomic::Option::Some, value
+      #   in Some(value)
       #     "Measurement is #{value}"
-      #   in Errgonomic::Option::None
+      #   in None
       #     "Measurement is not available"
-      #   else
-      #     "not matched"
       #   end # => "Measurement is 1"
+      #   case None()
+      #   in Some(value)
+      #     "Measurement is #{value}"
+      #   in None
+      #     "Measurement is not available"
+      #   end # => "Measurement is not available"
+      #
+      # @example the wrong type falls through to Ruby's own exhaustiveness check
+      #   begin
+      #     case 1
+      #     in Some(value) then value
+      #     in None then nil
+      #     end
+      #   rescue NoMatchingPatternError => e
+      #     [e.class, e.message]
+      #   end # => [NoMatchingPatternError, "1"]
+      #
+      # @example a Result that falls through carries a message that refuses to print
+      #   begin
+      #     case Ok(1)
+      #     in Some(value) then value
+      #     in None then nil
+      #     end
+      #   rescue NoMatchingPatternError => e
+      #     [e.class, (e.message rescue $!.class)]
+      #   end # => [NoMatchingPatternError, Errgonomic::SerializeError]
+      #
+      # @example patterns nest through the inner value's own protocol
+      #   case Ok(Some(1))
+      #   in Ok(Some(value)) then value
+      #   end # => 1
+      #   case Some({ id: 7, name: 'x' })
+      #   in Some({ id: }) then id
+      #   end # => 7
+      #   case Some(1)
+      #   in Errgonomic::Option::Some(value) then "bound #{value}"
+      #   else "not matched"
+      #   end # => "bound 1"
       def deconstruct
-        return [self, value] if some?
-
-        [Errgonomic::Option::None]
+        to_a
       end
 
       # Options order like Rust's: None sorts before any Some, and Somes
@@ -820,7 +890,6 @@ module Errgonomic
       end
 
       def strict_equality!(other, operator)
-        return unless Errgonomic.strict_equality?
         return if other.is_a?(Errgonomic::Option::Any)
 
         raise Errgonomic::TypeMismatchError,
@@ -961,3 +1030,8 @@ end
 def None
   Errgonomic::Option::None.new
 end
+
+# The variants under their short names, so a pattern reads as it does in
+# Rust: `in Some(v)`, `in None`.
+Errgonomic::VariantName.define(:Some, Errgonomic::Option::Some)
+Errgonomic::VariantName.define(:None, Errgonomic::Option::None)

data/lib/errgonomic/rails/active_record_optional.rb

@@ -18,9 +18,10 @@ module Errgonomic
     #
     # 1. None#nil? answers true, so AR internals and ordinary nil checks
     #    treat an absent value as absent. Equality does not follow suit:
-    #    None() == nil stays false. Nor does Array#compact, the common
-    #    collection idiom for dropping absent members: it tests for the
-    #    nil object, so it keeps a None where reject(&:none?) drops it.
+    #    None() == nil raises, as any cross-type comparison does. Nor does
+    #    Array#compact, the common collection idiom for dropping absent
+    #    members: it tests for the nil object, so it keeps a None where
+    #    reject(&:none?) drops it.
     # 2. Some delegates persisted? and touch_later to its record, so a Some
     #    can stand in for it where ActiveRecord reads an association back
     #    through its public reader.
@@ -516,10 +517,10 @@ module Errgonomic
     #   Errgonomic::Rails.unwrap_options(1) # => 1
     def self.unwrap_options(value)
       case value
-      when Errgonomic::Option::Any
-        value.unwrap_or(nil)
+      when Errgonomic::Option::Any, Errgonomic::VariantName
+        unwrap_option(value)
       when Array
-        value.any? { |v| v.is_a?(Errgonomic::Option::Any) } ? value.map { |v| unwrap_options(v) } : value
+        value.any? { |v| unwrapped_at_boundary?(v) } ? value.map { |v| unwrap_options(v) } : value
       else
         value
       end
@@ -527,13 +528,16 @@ module Errgonomic
 
     # Take the value inside an Option, and a None as nil, where the boundary
     # takes one value: an attribute is a single typed field, so a collection
-    # that happens to hold an Option is that collection.
+    # that happens to hold an Option is that collection. A bare variant name
+    # is refused here, since a boolean column would cast it to true.
     #
     # @example
     #   Errgonomic::Rails.unwrap_option(Some(1)) # => 1
     #   Errgonomic::Rails.unwrap_option(None()) # => nil
     #   Errgonomic::Rails.unwrap_option([Some(1)]) # => [Some(1)]
+    #   Errgonomic::Rails.unwrap_option(None) # => raise Errgonomic::SerializeError, "bare None names a variant for a pattern, not a value; build one with parentheses"
     def self.unwrap_option(value)
+      value.refuse! if value.is_a?(Errgonomic::VariantName)
       value.is_a?(Errgonomic::Option::Any) ? value.unwrap_or(nil) : value
     end
 
@@ -548,7 +552,7 @@ module Errgonomic
     #   plain = { title: 'x' }
     #   Errgonomic::Rails.unwrap_option_values(plain).equal?(plain) # => true
     def self.unwrap_option_values(hash)
-      return hash unless hash.each_value.any?(Errgonomic::Option::Any)
+      return hash unless hash.each_value.any? { |value| unwrapped_at_boundary?(value) }
 
       hash.transform_values { |value| unwrap_option(value) }
     end
@@ -561,11 +565,17 @@ module Errgonomic
     #   plain = [{ title: 'x' }]
     #   Errgonomic::Rails.unwrap_option_rows(plain).equal?(plain) # => true
     def self.unwrap_option_rows(rows)
-      return rows unless rows.any? { |row| row.is_a?(Hash) && row.each_value.any?(Errgonomic::Option::Any) }
+      return rows unless rows.any? { |row| row.is_a?(Hash) && row.each_value.any? { |v| unwrapped_at_boundary?(v) } }
 
       rows.map { |row| row.is_a?(Hash) ? unwrap_option_values(row) : row }
     end
 
+    # An Option, or a bare variant name, which a boundary refuses rather than
+    # let a column type cast it.
+    def self.unwrapped_at_boundary?(value)
+      value.is_a?(Errgonomic::Option::Any) || value.is_a?(Errgonomic::VariantName)
+    end
+
     # A declared default that is a Proc is not a value yet: ActiveModel calls
     # it with no arguments each time a record is built. Wrap it rather than
     # unwrap it, so what it returns meets the type where a literal default

data/lib/errgonomic/result.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'variant_name'
+
 module Errgonomic
   module Result
     # The base class for Result's Ok and Err class variants. We implement as
@@ -105,7 +107,11 @@ module Errgonomic
         RUST_SPELLINGS.key?(name) || super
       end
 
-      # Equality comparison for Result objects is based on value not reference.
+      # A Result equals another Result of the same variant with an equal
+      # inner value. Comparing it with anything that is not a Result raises
+      # Errgonomic::TypeMismatchError, on the terms Option#== states: the
+      # raise reaches ==, !=, eql? and ===, hashing stays quiet, and a bare
+      # value on the left answers for itself.
       #
       # @param other [Object]
       #
@@ -113,34 +119,23 @@ module Errgonomic
       #   Ok(1) == Ok(1) # => true
       #   Ok(1) == Err(1) # => false
       #   Ok(1).object_id == Ok(1).object_id # => false
-      #   Ok(1) == 1 # => false
-      #   Err() == nil # => false
-      #
-      # @example strict equality makes a cross-type comparison an error
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Ok(1) == 1
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.class
-      #     end
+      #
+      # @example a cross-type comparison is an error, never a quiet false
+      #   Ok(1) == 1 # => raise Errgonomic::TypeMismatchError, "Errgonomic::Result::Ok == Integer, which strict equality refuses.\nCompare Results (res == Ok(1)), test the inner value (res.ok_and? { |v| v == 1 }), or unwrap_or a fallback first."
+      #   Ok(1) != 1 # => raise Errgonomic::TypeMismatchError, "Errgonomic::Result::Ok != Integer, which strict equality refuses.\nCompare Results (res == Ok(1)), test the inner value (res.ok_and? { |v| v == 1 }), or unwrap_or a fallback first."
+      #   Ok(1) === 1 # => raise Errgonomic::TypeMismatchError, "Errgonomic::Result::Ok === Integer, which strict equality refuses.\nCompare Results (res == Ok(1)), test the inner value (res.ok_and? { |v| v == 1 }), or unwrap_or a fallback first."
+      #   Err() == nil # => raise Errgonomic::TypeMismatchError, "Errgonomic::Result::Err == NilClass, which strict equality refuses.\nCompare Results (res == Ok(nil)), test the inner value (res.ok_and? { |v| v == nil }), or unwrap_or a fallback first."
+      #   Ok(1) === Ok(1) # => true
+      #   begin
+      #     [Ok(1)].include?(1)
+      #   rescue Errgonomic::TypeMismatchError => e
+      #     e.class
       #   end # => Errgonomic::TypeMismatchError
-      #   Errgonomic.with_strict_equality { Ok(1) == Ok(1) } # => true
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Ok(1) != 1
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.message.include?("!=")
-      #     end
-      #   end # => true
+      #   { Ok(1) => :v }[1] # => nil
+      #   nil == Err() # => false
       #
       # @example an Option is another container, not another Result
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Ok(1) == Some(1)
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.message.include?("different containers")
-      #     end
-      #   end # => true
+      #   Ok(1) == Some(1) # => raise Errgonomic::TypeMismatchError, "Errgonomic::Result::Ok == Errgonomic::Option::Some, which strict equality refuses.\nA Result and an Option are different containers, and neither is the other.\nUnwrap the one you meant (res.unwrap_or(nil) == opt.unwrap_or(nil))."
       def ==(other)
         strict_equality!(other, '==')
         return false if self.class != other.class
@@ -148,6 +143,13 @@ module Errgonomic
         value == other.value
       end
 
+      # Object#=== is ==, so a `case value when Ok(1)` and a pinned pattern
+      # reach the same check, named for the operator that was written.
+      def ===(other)
+        strict_equality!(other, '===')
+        self == other
+      end
+
       # Hash-based collections (Hash keys, Set, uniq, group_by) use eql? and
       # hash, not ==. Follow the inner value's own eql? semantics, so Results
       # behave as keys exactly like their inner values.
@@ -159,15 +161,14 @@ module Errgonomic
       #   { Ok(5) => 1 }[Ok(5)] # => 1
       #   [Err(:a), Err(:a)].uniq # => [Err(:a)]
       #
-      # @example strict equality reaches eql?, and leaves hash alone
-      #   Errgonomic.with_strict_equality do
-      #     begin
-      #       Ok(5).eql?(5)
-      #     rescue Errgonomic::TypeMismatchError => e
-      #       e.class
-      #     end
-      #   end # => Errgonomic::TypeMismatchError
-      #   Errgonomic.with_strict_equality { Ok(5).hash == Ok(5).hash } # => true
+      # @example a cross-type eql? raises as == does, and hash is untouched
+      #   Ok(5).eql?(5) # => raise Errgonomic::TypeMismatchError, "Errgonomic::Result::Ok eql? Integer, which strict equality refuses.\nCompare Results (res == Ok(5)), test the inner value (res.ok_and? { |v| v == 5 }), or unwrap_or a fallback first."
+      #   Ok(5).hash == Ok(5).hash # => true
+      def eql?(other)
+        strict_equality!(other, 'eql?')
+        self.class == other.class && value.eql?(other.value)
+      end
+
       # Ruby derives != from ==, so a strict-equality message would name the
       # operator the caller did not write.
       def !=(other)
@@ -175,11 +176,6 @@ module Errgonomic
         super
       end
 
-      def eql?(other)
-        strict_equality!(other, 'eql?')
-        self.class == other.class && value.eql?(other.value)
-      end
-
       # @example
       #   Ok(5).hash == Ok(5).hash # => true
       #   Ok(5).hash == Err(5).hash # => false
@@ -471,27 +467,79 @@ module Errgonomic
         pp.text(inspect)
       end
 
-      # @example simple pattern match with variable capture of the value
-      #   result = Errgonomic::Result::Ok.new(1)
-      #   case result
-      #   in Errgonomic::Result::Ok, value
+      # The Rust shape: each variant deconstructs to its one payload, so
+      # `in Ok(v)` binds the value and `in Err(e)` binds the error. A
+      # value-less Err deconstructs to nothing: the sentinel behind it is
+      # internal and must never bind to a pattern variable.
+      #
+      # @example
+      #   Ok(1).deconstruct # => [1]
+      #   Err(:e).deconstruct # => [:e]
+      #   Err().deconstruct # => []
+      #   Ok(1).respond_to?(:deconstruct_keys) # => false
+      #
+      # @example a value-less Err matches `in Err` and `in Err()`, never `in Err(e)`
+      #   case Err()
+      #   in Err(e) then e
+      #   in Err then :no_value
+      #   end # => :no_value
+      #   case Err()
+      #   in Err() then :no_value
+      #   end # => :no_value
+      #   case Err(:x)
+      #   in Err(e) then e
+      #   in Err then :no_value
+      #   end # => :x
+      #   begin
+      #     case Err()
+      #     in Err(e) then e
+      #     end
+      #   rescue NoMatchingPatternError => e
+      #     e.class
+      #   end # => NoMatchingPatternError
+      #
+      # @example a two-branch case/in with no else is exhaustive
+      #   case Ok(1)
+      #   in Ok(value)
       #     "Measurement is #{value}"
-      #   in Errgonomic::Result::Err, err
+      #   in Err(err)
       #     "Measurement is not available"
       #   end # => "Measurement is 1"
       #
-      # @example more advanced pattern match against the kind of value
-      #   result = Errgonomic::Result::Err.new(StandardError.new("nope"))
+      # @example the wrong type falls through to Ruby's own exhaustiveness check
+      #   begin
+      #     case :done
+      #     in Ok(value) then value
+      #     in Err(err) then err
+      #     end
+      #   rescue NoMatchingPatternError => e
+      #     [e.class, e.message]
+      #   end # => [NoMatchingPatternError, "done"]
+      #
+      # @example an Option that falls through carries a message that refuses to print
+      #   begin
+      #     case Some(1)
+      #     in Ok(value) then value
+      #     in Err(err) then err
+      #     end
+      #   rescue NoMatchingPatternError => e
+      #     [e.class, (e.message rescue $!.class)]
+      #   end # => [NoMatchingPatternError, Errgonomic::SerializeError]
+      #
+      # @example a pattern reaches the kind of value inside the variant
+      #   result = Err(StandardError.new("nope"))
       #   case result
-      #   in Errgonomic::Result::Ok, value
+      #   in Ok(value)
       #     "Measurement is #{value}"
-      #   in Errgonomic::Result::Err, String => msg
+      #   in Err(String => msg)
       #     "Measurement failed with a message: #{msg}"
-      #   in Errgonomic::Result::Err, Exception => e
+      #   in Err(Exception => e)
       #     "Measurement produced an exception -- #{e.class}: #{e}"
       #   end # => "Measurement produced an exception -- StandardError: nope"
       def deconstruct
-        [self, value]
+        return [] if value.equal?(Err::Arbitrary)
+
+        [value]
       end
 
       protected
@@ -514,7 +562,6 @@ module Errgonomic
       end
 
       def strict_equality!(other, operator)
-        return unless Errgonomic.strict_equality?
         return if other.is_a?(Errgonomic::Result::Any)
 
         raise Errgonomic::TypeMismatchError,
@@ -595,7 +642,7 @@ module Errgonomic
       # @example
       #   Err(:nope).inspect # => "Err(:nope)"
       #   Err().inspect # => "Err()"
-      #   Errgonomic.with_strict_equality { Err(Some(1)).inspect } # => "Err(Some(1))"
+      #   Err(Some(1)).inspect # => "Err(Some(1))"
       def inspect
         return 'Err()' if value.equal?(Arbitrary)
 
@@ -643,3 +690,8 @@ end
 def Err(value = Errgonomic::Result::Err::Arbitrary)
   Errgonomic::Result::Err.new(value)
 end
+
+# The variants under their short names, so a pattern reads as it does in
+# Rust: `in Ok(v)`, `in Err(e)`.
+Errgonomic::VariantName.define(:Ok, Errgonomic::Result::Ok)
+Errgonomic::VariantName.define(:Err, Errgonomic::Result::Err)

data/lib/errgonomic/variant_name.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Errgonomic
+  # What a bare `Some`, `None`, `Ok` or `Err` evaluates to. Rust writes a
+  # value as `return None`, where here the value is `None()`; the bare name
+  # is for patterns. It matches as the class it names, and refuses to become
+  # a string, so a missing pair of parentheses raises rather than writing a
+  # class name into a column. It is not a class, so an application's own
+  # `class None` fails where it is written instead of reopening the gem's.
+  #
+  # @example
+  #   case Some(1)
+  #   in Some(value) then value
+  #   end # => 1
+  #   None === None() # => true
+  #   None === Some(1) # => false
+  #   None.inspect # => "Errgonomic::Option::None"
+  #   "tier-#{None}" # => raise Errgonomic::SerializeError, "bare None names a variant for a pattern, not a value; build one with parentheses"
+  #   [Ok].join # => raise Errgonomic::SerializeError, "bare Ok names a variant for a pattern, not a value; build one with parentheses"
+  #   Some(1).is_a?(Some) # => raise TypeError, "class or module required"
+  #   Some(1).is_a?(Errgonomic::Option::Some) # => true
+  class VariantName
+    # Name a variant at top level, refusing a constant the application
+    # already holds there rather than replacing it.
+    def self.define(name, variant)
+      if Object.const_defined?(name, false)
+        existing = Object.const_get(name)
+        return if existing.is_a?(VariantName) && existing.names?(variant)
+
+        raise NameError.new("#{name} is already defined as #{existing.inspect}; errgonomic defines #{name} " \
+                            "at top level to name #{variant} in patterns, so rename the application's constant", name)
+      end
+      Object.const_set(name, new(name, variant))
+    end
+
+    def initialize(name, variant)
+      @name = name
+      @variant = variant
+      freeze
+    end
+
+    def names?(variant)
+      @variant.equal?(variant)
+    end
+
+    def ===(other)
+      @variant === other # rubocop:disable Style/CaseEquality
+    end
+
+    def inspect
+      @variant.inspect
+    end
+
+    # Refuse to stand in for a value.
+    def refuse!(*_args)
+      raise Errgonomic::SerializeError,
+            "bare #{@name} names a variant for a pattern, not a value; build one with parentheses"
+    end
+    alias to_s refuse!
+    alias to_json refuse!
+    alias as_json refuse!
+  end
+end

data/lib/errgonomic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Errgonomic
-  VERSION = '0.9.3'
+  VERSION = '0.10.1'
 end

data/lib/errgonomic.rb

@@ -85,41 +85,4 @@ module Errgonomic
   ensure
     @give_me_ambiguous_downstream_errors = original_value
   end
-
-  # Cross-type equality is quiet by default, as it is for every Ruby object.
-  # Strict equality turns it into an error instead, for a test suite or CI:
-  # `Some(5) == 5` is the comparison Rust rejects at compile time, and it is
-  # silently false here otherwise.
-  #
-  # @example
-  #   Errgonomic.strict_equality? # => false
-  #   Errgonomic.with_strict_equality { Errgonomic.strict_equality? } # => true
-  #   Errgonomic.strict_equality? # => false
-  def self.strict_equality?
-    !!@strict_equality
-  end
-
-  class << self
-    # Turn cross-type equality into an error for the rest of the process.
-    attr_writer :strict_equality
-  end
-
-  # Turn cross-type equality into an error for the duration of the block.
-  def self.with_strict_equality
-    original_value = @strict_equality
-    @strict_equality = true
-    yield
-  ensure
-    @strict_equality = original_value
-  end
-
-  # Lenient inner value comparison means the inner value of a Some or Ok can be
-  # compared to some other non-Result or non-Option value.
-  def self.lenient_inner_value_comparison?
-    @lenient_inner_value_comparison ||= true
-  end
-
-  def self.give_me_lenient_inner_value_comparison=(value)
-    @lenient_inner_value_comparison = value
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: errgonomic
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.10.1
 platform: ruby
 authors:
 - Nick Zadrozny
@@ -90,6 +90,7 @@ files:
 - lib/errgonomic/rails/active_record_optional.rb
 - lib/errgonomic/result.rb
 - lib/errgonomic/type.rb
+- lib/errgonomic/variant_name.rb
 - lib/errgonomic/version.rb
 - sig/errgonomic.rbs
 homepage: https://omc.io/