Docs: imathify'd → imathified for consistency

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Technologicat

CHANGELOG.md

@@ -20,7 +20,7 @@
   - `Sliced` has abstract `__getitem__`.
   - `FupTarget` has abstract `__getitem__` returning `Fuppable`.
   - `Fuppable` has abstract `__lshift__`.
-- `slift1`, `slift2`: lift scalar unary/binary operations to work termwise on iterables, returning `imathify`'d lazy generators. Accept optional extra arguments baked into each call (e.g. `slift1(round, 2)`). These are the mechanism behind all built-in `s`-prefixed operators, now exposed for user-defined functions.
+- `slift1`, `slift2`: lift scalar unary/binary operations to work termwise on iterables, returning imathified lazy generators. Accept optional extra arguments baked into each call (e.g. `slift1(round, 2)`). These are the mechanism behind all built-in `s`-prefixed operators, now exposed for user-defined functions.
 - `ConditionProtocol`: `typing.Protocol` capturing the call signature shared by error-handling protocols (`signal`, `error`, `cerror`, `warn`). Useful for annotating custom protocols.
 
 **Changed**:

doc/features.md

@@ -2556,7 +2556,7 @@ We provide the [Cauchy product](https://en.wikipedia.org/wiki/Cauchy_product), a
 
 We also provide `gmathify`, a decorator to mathify a gfunc, so that it will `imathify()` the generator instances it makes. Combo with `imemoize` for great justice, e.g. `a = gmathify(imemoize(myiterable))`, and then `a()` to instantiate a memoized-and-mathified copy.
 
-To apply a custom function termwise to an iterable, use `slift1` (unary) or `slift2` (binary). These lift a scalar operation into one that works on iterables, returning a lazy `imathify`'d generator. All the built-in `s`-prefixed operators (`sadd`, `sabs`, ...) are defined using this mechanism. Extra arguments are baked into each call: e.g. `slift1(round, 2)` gives termwise `round(x, 2)`.
+To apply a custom function termwise to an iterable, use `slift1` (unary) or `slift2` (binary). These lift a scalar operation into one that works on iterables, returning a lazy imathified generator. All the built-in `s`-prefixed operators (`sadd`, `sabs`, ...) are defined using this mechanism. Extra arguments are baked into each call: e.g. `slift1(round, 2)` gives termwise `round(x, 2)`.
 
 ```python
 from unpythonic import slift1, slift2, s, take

unpythonic/tests/test_mathseq.py

@@ -172,7 +172,7 @@ def runtests():
         test_raises[ValueError, cauchyprod(s(1, 3, 5, ...), s(2, 4, 6, ...), require="invalid_value")]
 
     with testset("imathify, gmathify (infix syntax for arithmetic)"):
-        # Sequences returned by `s` are `imathify`'d implicitly.
+        # Sequences returned by `s` are imathified implicitly.
         test[tuple(take(5, s(1, 3, 5, ...) + s(2, 4, 6, ...))) == (3, 7, 11, 15, 19)]
         test[tuple(take(5, 1 + s(1, 3, ...))) == (2, 4, 6, 8, 10)]
         test[tuple(take(5, 1 - s(1, 3, ...))) == (0, -2, -4, -6, -8)]