@@ -36,13 +36,15 @@
     model_field_values,
 )
 from ._ordering import (
+    _SEQUENCES,
     REFUSALS,
     UnorderableError,
     _exact_real,
     broadcasts,
     equal_past,
     held_key,
     holds,
+    integral_kind,
     numpy_duration,
     rational_overflow,
 )
@@ -155,7 +157,11 @@ def _ambiguous_array_operand(value: object, other: object) -> object | None:
     """
     if not hasattr(value, "__array__") and not hasattr(other, "__array__"):
         return None  # fast path: no array-like operand, skip the tuple/loop on every is_equal_to
-    if broadcasts(value, other):
+    if (
+        type(value) is not type(other)
+        and (isinstance(value, _SEQUENCES) or isinstance(other, _SEQUENCES))
+        and broadcasts(value, other)
+    ):
         return None  # a `numpy` scalar against a list, which `_guarded_equal` answers as unequal
     for candidate, counterpart in ((value, other), (other, value)):
         if hasattr(candidate, "__array__"):
@@ -263,7 +269,9 @@ def _guarded_equal(actual, expected, *, method="is_equal_to") -> bool:
     """
     try:
         equal = actual == expected
-        return bool(equal) if type(equal) is bool or not broadcasts(actual, expected, answer=equal) else False
+        if type(equal) is bool or type(actual) is type(expected):
+            return bool(equal)
+        return not broadcasts(actual, expected, answer=equal) and bool(equal)
     except (ValueError, TypeError) as error:
         operand = _find_ambiguous_operand(actual, expected)
         if operand is not None:
@@ -291,6 +299,27 @@ def zero_of(tolerance: Any) -> Any:
     return tolerance - tolerance if type(tolerance) not in (int, float) and numpy_duration(tolerance) else 0
 
 
+def plainly_within(actual, expected, tolerance) -> bool | None:
+    """`_within_tolerance` over three exact `int` or `float` operands, or ``None`` where an `int` overflows a `float`.
+
+    The same rule in its fewest steps: a NaN is close to nothing, an infinity only to an equal one, and a finite
+    pair by its difference or by the window around either side.
+    """
+    if actual != actual or expected != expected:
+        return False
+    try:
+        if actual in (math.inf, -math.inf) or expected in (math.inf, -math.inf):
+            return actual == expected
+        return (
+            actual == expected
+            or abs(actual - expected) <= tolerance
+            or expected - tolerance <= actual <= expected + tolerance
+            or actual - tolerance <= expected <= actual + tolerance
+        )
+    except OverflowError:
+        return None
+
+
 def _within_tolerance(actual, expected, tolerance) -> bool:
     """Whether two values lie within ``tolerance`` of each other, the same answer whichever comes first.
 
@@ -447,7 +476,7 @@ def _non_finite(value) -> str:
         if decimal.Decimal.is_finite(value):
             return ""
         return "nan" if decimal.Decimal.is_nan(value) else "inf"
-    if isinstance(value, int) or not hasattr(type(value), "__float__"):
+    if isinstance(value, int) or not hasattr(type(value), "__float__") or integral_kind(type(value)):
         return ""
     if _is_nan(value):
         return "nan"
 
@@ -21,11 +21,14 @@
 
 from ._introspection import definition_of, is_mapping_like, materialized
 from ._ordering import (
+    _PLAIN,
+    MEMBERSHIP_REFUSALS,
     REFUSALS,
     equals,
     lookup,
     may_broadcast,
     member,
+    member_past,
     mixes_broadcasting,
 )
 from ._require import raised_inside, verdict
@@ -248,13 +251,26 @@ def _absent_from(
                 absent.append(item)
             continue
         try:
-            if not member(item, present, verify):
+            if not _held(item, present, verify):
                 absent.append(item)
         except TypeError as refusal:
             _told_apart((((item,), present),), refusal, marked=marked)
     return absent
 
 
+def _held(item: Any, present: Any, verify: bool) -> bool:
+    """`member`, asking ``in`` itself where no item that may broadcast can come: through it cost 100 items 11%."""
+    if not verify or type(item) in _PLAIN:
+        try:
+            return item in present
+        except MEMBERSHIP_REFUSALS as refusal:
+            found = member_past(item, present, refusal)
+            if found is None:
+                raise
+            return found
+    return member(item, present, verify)
+
+
 def only_faults(value: Any, items: Sequence[Any], *, marked: bool = False) -> tuple[list[Any], list[Any]]:
     """``(extra, missing)`` for "contains only these": what is there but unwanted, and what is absent.
 
 
@@ -72,11 +72,33 @@ def nan_operand(value: Any) -> bool:
     if isinstance(value, decimal.Decimal):
         return decimal.Decimal.is_nan(value)
     kind = type(value)
-    if kind is int or type(kind) is not type or issubclass(kind, numbers.Integral):
+    if kind is int or type(kind) is not type or kind in _INTEGRAL_KINDS or integral_kind(kind):
         return False
     return _exact_real(value) == "nan"
 
 
+def integral_kind(kind: type) -> bool:
+    """Whether a class built by `type` itself is a `numbers.Integral`, kept once found: a class never stops being one.
+
+    Asked of a `numpy` integer at every NaN and infinity question, where the ABC check cost an `int64` tie 11%.  At
+    most 256 are kept, so classes made on the fly cannot grow it without bound, and an ABC registry cleared by hand
+    through its private API is not followed.
+    """
+    if type(kind) is not type:
+        return False
+    if kind in _INTEGRAL_KINDS:
+        return True
+    if issubclass(kind, numbers.Integral):
+        if len(_INTEGRAL_KINDS) < 256:
+            _INTEGRAL_KINDS.add(kind)
+        return True
+    return False
+
+
+_INTEGRAL_KINDS: set[type] = set()
+"""What `integral_kind` has found, only classes built by `type` itself, so hashed as `type` hashes."""
+
+
 def _kind_of(value: Any) -> type | None:
     """The date-and-time kind a value orders within, subclasses included, or ``None`` for anything else.
 
@@ -108,7 +130,7 @@ def equals(actual: Any, expected: Any) -> bool:
         equal = actual == expected
     except (decimal.InvalidOperation, OverflowError, TypeError, ValueError) as refusal:
         return equal_past(actual, expected, refusal)
-    if type(equal) is not bool and broadcasts(actual, expected, answer=equal):
+    if type(equal) is not bool and type(actual) is not type(expected) and broadcasts(actual, expected, answer=equal):
         return False
     return bool(equal)
 
@@ -194,25 +216,40 @@ def member(item: Any, container: Any, verify: bool = True) -> bool:
         return any(element is item or equals(element, item) for element in container)
     try:
         return item in container
-    except (decimal.InvalidOperation, OverflowError) as refusal:
-        if raised_inside(refusal):
+    except MEMBERSHIP_REFUSALS as refusal:
+        found = member_past(item, container, refusal)
+        if found is None:
             raise
-        return any(element is item or equals(element, item) for element in container)
-    except (ValueError, DeprecationWarning) as ambiguous:
+        return found
+
+
+MEMBERSHIP_REFUSALS = (decimal.InvalidOperation, OverflowError, ValueError, DeprecationWarning, TypeError)
+"""What ``in`` raises that `member_past` may answer."""
+
+
+def member_past(item: Any, container: Any, refusal: Exception) -> bool | None:
+    """`member`'s verdict once ``item in container`` raised *refusal*, or ``None`` to hand the refusal on as raised.
+
+    Answered from the refusal already caught, never by asking ``in`` again: an element whose ``==`` answers
+    differently the second time would have turned the refusal into a verdict.
+    """
+    if isinstance(refusal, (decimal.InvalidOperation, OverflowError)):
+        if raised_inside(refusal):
+            return None
+    elif isinstance(refusal, (ValueError, DeprecationWarning)):
         # a hash collision met a `numpy` scalar with a tuple, and `in` took the truth of their array
-        if raised_inside(ambiguous) or not may_broadcast(item) or not _searched_again(container):
-            raise
-        return any(element is item or equals(element, item) for element in container)
-    except TypeError as refusal:
+        if raised_inside(refusal) or not may_broadcast(item) or not _searched_again(container):
+            return None
+    else:
         # a dict's items view hashes the key of a pair alone, and asks about the value only once the key is there
         pair = type(container) is type({}.items()) and isinstance(item, tuple) and len(item) == 2
         key = item[0] if pair else item
         hashed = _searches_by_hash(container)
         if hashed and _unhashable_for_a_nan_alone(key):
             return False
         if raised_inside(refusal) or not (_walks_by_equality(container) or (hashed and _hashes(key))):
-            raise
-        return any(element is item or equals(element, item) for element in container)
+            return None
+    return any(element is item or equals(element, item) for element in container)
 
 
 def _walks_by_equality(container: Any) -> bool:
@@ -598,12 +635,14 @@ def compare(actual: Any, expected: Any) -> int:
     right: Any = expected
     try:
         less = left < right
-        if type(less) is not bool and broadcasts(left, right, ordering=True, answer=less):
+        mixed = actual_type is not type(expected)
+        # a pair of one type is never a scalar against a list: asked for it anyway, an `int64` tie cost 19% more
+        if mixed and type(less) is not bool and broadcasts(left, right, ordering=True, answer=less):
             raise UnorderableError("pair")
         if less:
             return -1
         greater = right < left
-        if type(greater) is not bool and broadcasts(right, left, ordering=True, answer=greater):
+        if mixed and type(greater) is not bool and broadcasts(right, left, ordering=True, answer=greater):
             raise UnorderableError("pair")
         if greater:
             return 1
 
@@ -32,6 +32,7 @@
     _non_finite,
     _resolve_comparator,
     _within_tolerance,
+    plainly_within,
     zero_of,
 )
 from ._engine._equality import (
@@ -727,8 +728,13 @@ def __init__(self, expected: object, tolerance: object):
             and _non_finite(tolerance) != "nan"
             and _measured_under(expected, tolerance, self._duration)
         )
+        self._plain = self._measures and type(expected) in (int, float) and type(tolerance) in (int, float)
 
     def matches(self, value: Any) -> bool:
+        if self._plain and type(value) in (int, float):
+            within = plainly_within(value, self.expected, self.tolerance)
+            if within is not None:
+                return within
         if not self._measures or not _measured_under(value, self.tolerance, self._duration):
             return False
         try:
 
@@ -2183,6 +2183,25 @@ def __iter__(self):
         with pytest.raises(TypeError, match="only the first time"):
             missing_items(Moody(), [1], _is_matcher)
 
+    def test_an_element_whose_equality_changes_its_answer_is_asked_once(self):
+        """The refusal ``in`` raised is answered as caught: asked again, the second answer passed the item."""
+        numpy = pytest.importorskip("numpy")
+
+        class Fickle:
+            def __init__(self):
+                self.asked = 0
+
+            def __eq__(self, other):
+                self.asked += 1
+                return numpy.array([True, False]) if self.asked == 1 else True
+
+            __hash__ = None
+
+        fickle = Fickle()
+        with pytest.raises(ValueError, match="ambiguous"):
+            assert_that([fickle]).contains(5)
+        assert_that(fickle.asked).is_equal_to(1)
+
     def test_a_mapping_of_many_non_string_keys_says_how_many_it_dropped(self):
         wide = {index: index for index in range(101)}
         written = _json_safe(wide)
 
@@ -9,6 +9,7 @@
 import pytest
 
 from assertpy2 import assert_that, match
+from assertpy2._engine import _ordering
 from assertpy2._engine._compare import _difference_within
 
 
@@ -1043,6 +1044,15 @@ def test_a_fraction_past_a_numpy_integers_width_is_ordered_by_exact_value(width,
     assert_that(ask(_TINY, five)).is_equal_to(holds)
 
 
+def test_an_integral_class_is_kept_at_most_so_many_times(monkeypatch):
+    """Found and answered past the bound, and not kept: classes made on the fly cannot grow the cache without end."""
+    kept = set(range(256))
+    monkeypatch.setattr(_ordering, "_INTEGRAL_KINDS", kept)
+    counted = type("Counted", (int,), {})
+    assert_that(_ordering.integral_kind(counted)).is_true()
+    assert_that(kept).is_length(256)
+
+
 class _OrderingOverflowsOfItsOwn(fractions.Fraction):
     """A `Fraction` whose own ordering overflows, which the exact order is not allowed to paper over."""
 
 
@@ -66,6 +66,15 @@
     ),
     ("pytest_plugin.py", "_poll_threshold", "float(written)"): "parses ini text, not a value under test",
     ("behave_matchers.py", "_positive_float", "float(text)"): "parses step text behave matched as digits",
+    **dict.fromkeys(
+        (
+            ("_engine/_compare.py", "plainly_within", "actual != actual"),
+            ("_engine/_compare.py", "plainly_within", "expected != expected"),
+            ("_engine/_compare.py", "plainly_within", "actual in (math.inf, -math.inf)"),
+            ("_engine/_compare.py", "plainly_within", "expected in (math.inf, -math.inf)"),
+        ),
+        "its operands are exact ints and floats, the caller's condition, so the NaN and the infinity are float's",
+    ),
 }
 
 _NUMBER_MODULES = frozenset({"math", "cmath", "numpy"})
 
@@ -34,7 +34,7 @@
 from assertpy2 import assert_conforms, assert_that, match, soft_assertions
 from assertpy2._clustering import _VALUE_LIMIT, Observation, Signature, _shown, clusters, render, stable_repr
 from assertpy2._dangling import findings as dangling_findings
-from assertpy2._engine._compare import _EQ_ATOMIC
+from assertpy2._engine._compare import _EQ_ATOMIC, _within_tolerance, plainly_within
 from assertpy2._engine._contract import contract_drift, shape, shape_diff
 from assertpy2._engine._diff import _build_equality_diff, _ordered_keys, _sub_diff_entries
 from assertpy2._engine._equality import values_differ
@@ -2776,6 +2776,35 @@ def test_closeness_is_one_answer_however_it_is_asked(value, other, tolerance):
     assert_that(set(answers.values())).described_as(str(answers)).is_length(1)
 
 
+_PLAIN_OPERANDS = st.one_of(
+    st.floats(allow_nan=True, allow_infinity=True, allow_subnormal=True),
+    st.integers(),
+    st.integers(-(10**400), 10**400),
+)
+_PLAIN_TOLERANCES = st.one_of(
+    st.floats(min_value=0, allow_infinity=True, allow_subnormal=True), st.integers(0, 10**400)
+)
+
+
+@settings(deadline=None)
+@example(value=-1.1, other=-0.9, tolerance=0.2)
+@example(value=0.1 + 0.2, other=0.3, tolerance=5.551115123125783e-17)
+@example(value=-0.0, other=0.0, tolerance=0)
+@example(value=5e-324, other=0.0, tolerance=5e-324)
+@example(value=10**400, other=1e308, tolerance=float("inf"))
+@example(value=float("inf"), other=float("inf"), tolerance=0)
+@example(value=float("-inf"), other=float("inf"), tolerance=float("inf"))
+@example(value=float("nan"), other=float("nan"), tolerance=float("inf"))
+@given(value=_PLAIN_OPERANDS, other=_PLAIN_OPERANDS, tolerance=_PLAIN_TOLERANCES)
+def test_the_plain_closeness_answers_as_the_general_one(value, other, tolerance):
+    """`match.close_to` answers exact ints and floats inline, and only an int past the float range leaves it."""
+    plain = plainly_within(value, other, tolerance)
+    general = _within_tolerance(value, other, tolerance)
+    assert_that(plain).described_as(f"{value!r}, {other!r}, {tolerance!r}").is_in(None, general)
+    if plain is None:
+        assert_that(any(type(operand) is int for operand in (value, other, tolerance))).is_true()
+
+
 _MOMENT = datetime.datetime(2026, 9, 24, 12, 0, 0)
 _CLOSE_PAIRS = st.one_of(
     st.tuples(