errgonomic 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d39f466feedb411b53780fa853b509dc6a40db2f12aef63235a6817881ce2d95
-  data.tar.gz: bc81bba0f57ddaac60178b0319533feeb054be296614332b8a9744d72b0ae9d1
+  metadata.gz: 543390fc5f85546ffde4785cfc41951400800094506078271cfe32535e9d784a
+  data.tar.gz: 8d5cdf061dbf7026eaab5ba8cab628368c600943699dbad04235c9d1d9bd3f5a
 SHA512:
-  metadata.gz: 26b24e1089898ad573927824616829559a6c9fa5c169abf71addcad1284a345597ae12928f4a22153ce1d06f64db3572e7e4d0d6c596df2dffef4a1eb260e72e
-  data.tar.gz: 5f20b741f3feb1c4f5b84daee2f3934edc09f89f962a459c485dfed8356d63e84297f778b3b74f761ada2c1be2ea5c371c73b318a2ef5aa54c8ba635612ba450
+  metadata.gz: ad7cbe42d7f1d65549323c026a3f4486d4e64a9b5274023fc3eebb0a576ceb09c030151d176512220e13ef8d6e1bc3c2bff78162783ecb286bbb6805ac16c8c9
+  data.tar.gz: 4588909f84b800a1c497882d030fd88f23606146fe64b7ae02ecc8b7f4406ba2c5dd749d0c709c7004717de80a9a69e73d6247b2ce11013446fa25db66271c3d

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [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)`.

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

@@ -150,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?`.
 
@@ -257,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
 
@@ -413,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

@@ -66,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
@@ -129,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)
@@ -141,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
@@ -165,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
@@ -866,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,

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.

data/lib/errgonomic/result.rb

@@ -107,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]
       #
@@ -115,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
@@ -150,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.
@@ -161,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)
@@ -177,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
@@ -568,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,
@@ -649,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)
 

data/lib/errgonomic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Errgonomic
-  VERSION = '0.10.0'
+  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.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Nick Zadrozny