@@ -7,7 +7,7 @@
 
 ![FuncFrog icon](https://github.com/koss-null/funcfrog/blob/master/FuncFrogIco.jpg?raw=true)
 
-*FuncFrog* is a tiny library for doing **fast**, **parallel**, **lazy** `Map`, `Filter`, `Reduce` and [a bunch of other things](#api-reference) over slices and other sequences — all chained into a single pipeline. You feed it a source (a slice, a `func`, a range...), stack a few operations on top, and pull the trigger with `Do()`.
+*FuncFrog* is a powerful library for doing **fast**, **parallel**, **lazy** `Map`, `Filter`, `Reduce` and [a bunch of other things](#api-reference) over slices and other sequences -- all chained into a single pipeline. You feed it a source (a slice, a `func`, a range...), stack a few operations on top, and pull the trigger with `Do()`.
 
 Everything runs in parallel with **minimal copying and locking**, and there's built-in [error handling](#error-handling-yeti--snag) that is honestly a bit weird but very handy once it clicks (hello `Yeet`/`Snag`).
 
@@ -89,12 +89,12 @@ Want to poke at real code? Jump straight to the [Examples](#examples).
 
 The whole library revolves around two interfaces:
 
-- **`Piper[T]`** — a *lazy* sequence whose **length is known** (a slice, a `Range`, a `Repeat`...). It can do everything.
-- **`PiperNoLen[T]`** — a *lazy* sequence whose **length is unknown yet** (a `Func`, a `Cycle`, ...). It can do almost everything, plus it can *become* a `Piper` via [`Take` or `Gen`](#set-the-pipe-length-take--gen).
+- **`Piper[T]`** -- a *lazy* sequence whose **length is known** (a slice, a `Range`, a `Repeat`...). It can do everything.
+- **`PiperNoLen[T]`** -- a *lazy* sequence whose **length is unknown yet** (a `Func`, a `Cycle`, ...). It can do almost everything, plus it can *become* a `Piper` via [`Take` or `Gen`](#set-the-pipe-length-take--gen).
 
 Both are lazy: nothing actually runs until you call a terminal method (`Do`, `Reduce`, `Sum`, `Count`, `First`, `Any`...). Until then you're just describing the pipeline.
 
-Because a pipe is a value, you can copy it around freely — assign it to a variable, reuse it, branch it:
+Because a pipe is a value, you can copy it around freely -- assign it to a variable, reuse it, branch it:
 
 ```go
 base := pipe.Slice(a).Map(square)
@@ -103,93 +103,93 @@ odds  := base.Filter(isOdd) // `base` is untouched
 ```
 
 Operations can change the element type too, but two flavors exist:
-- `Pipe.Map` keeps the **same** type (`func(T) T`) — cheap and easy.
-- `pipe.Map` (prefix) / `ff.Map` change the **type** (`func(SrcT) DstT`) — see [Prefix helpers](#prefix-helpers).
+- `Pipe.Map` keeps the **same** type (`func(T) T`) -- cheap and easy.
+- `pipe.Map` (prefix) / `ff.Map` change the **type** (`func(SrcT) DstT`) -- see [Prefix helpers](#prefix-helpers).
 
 ## API reference
 
-Every bullet below is a real signature — copy/paste safe.
+Every bullet below is a real signature -- copy/paste safe.
 
 ### Constructors
 
-- :frog: `Slice([]T) Piper[T]` — wraps a slice. *Length known.*
-- :frog: `Func(fn func(i int) (T, bool)) PiperNoLen[T]` — builds a lazy sequence from a function of the index `i`. The bool says whether the value exists (`true`) or should be skipped (`false`). *Length unknown.*
-- :frog: `Fn(fn func(i int) T) PiperNoLen[T]` — like `Func`, but nothing is ever skipped. *Length unknown.*
-- :frog: `FuncP(fn func(i int) (*T, bool)) PiperNoLen[T]` — like `Func`, but your function hands back pointers (handy for big structs). *Length unknown.*
-- :frog: `Cycle(a []T) PiperNoLen[T]` — loops over the slice forever. *Length unknown.*
-- :frog: `Range[T Integer|Float](start, finish, step T) Piper[T]` — generates `start, start+step, ...` and stops **before** `finish` (i.e. `[start, finish)`). Works for any integer or float. *Length known.*
-- :frog: `Repeat(x T, n int) Piper[T]` — `x` repeated `n` times. A non-positive `n` gives an empty pipe. *Length known.*
+- :frog: `Slice([]T) Piper[T]` -- wraps a slice. *Length known.*
+- :frog: `Func(fn func(i int) (T, bool)) PiperNoLen[T]` -- builds a lazy sequence from a function of the index `i`. The bool says whether the value exists (`true`) or should be skipped (`false`). *Length unknown.*
+- :frog: `Fn(fn func(i int) T) PiperNoLen[T]` -- like `Func`, but nothing is ever skipped. *Length unknown.*
+- :frog: `FuncP(fn func(i int) (*T, bool)) PiperNoLen[T]` -- like `Func`, but your function hands back pointers (handy for big structs). *Length unknown.*
+- :frog: `Cycle(a []T) PiperNoLen[T]` -- loops over the slice forever. *Length unknown.*
+- :frog: `Range[T Integer|Float](start, finish, step T) Piper[T]` -- generates `start, start+step, ...` and stops **before** `finish` (i.e. `[start, finish)`). Works for any integer or float. *Length known.*
+- :frog: `Repeat(x T, n int) Piper[T]` -- `x` repeated `n` times. A non-positive `n` gives an empty pipe. *Length known.*
 
 ### Set the pipe length: Take & Gen
 
 These two only exist on `PiperNoLen` and are how you turn an unknown-length pipe into a `Piper`. Only the **first** `Take`/`Gen` in a chain counts.
 
-- :frog: `Take(n int) Piper[T]` — "I want `n` values in the end". FuncFrog keeps evaluating until it has collected `n` *surviving* values. *Length becomes known.*
-- :frog: `Gen(n int) Piper[T]` — "evaluate the first `n` positions". Note the difference: it evaluates positions `[0, n)` and your `Filter` can still drop some, so the result may be shorter than `n`. *Length becomes known.*
+- :frog: `Take(n int) Piper[T]` -- "I want `n` values in the end". FuncFrog keeps evaluating until it has collected `n` *surviving* values. *Length becomes known.*
+- :frog: `Gen(n int) Piper[T]` -- "evaluate the first `n` positions". Note the difference: it evaluates positions `[0, n)` and your `Filter` can still drop some, so the result may be shorter than `n`. *Length becomes known.*
 
 ### Go parallel
 
-- :frog: `Parallel(n uint16) Piper[T]` (and `PiperNoLen[T]`) — split the work across `n` goroutines. Default is `1`. Only the **first** `Parallel` in a chain is applied.
+- :frog: `Parallel(n uint16) Piper[T]` (and `PiperNoLen[T]`) -- split the work across `n` goroutines. Default is `1`. Only the **first** `Parallel` in a chain is applied.
 
 ### Transforming data
 
-- :frog: `Map(fn func(T) T) Piper[T]` — apply `fn` to every element (same type in, same type out).
-- :frog: `Filter(fn func(*T) bool) Piper[T]` — keep only the elements for which `fn` returns `true`. (**Tip:** the argument is a `*T`, so remember to dereference — `*x`.)
-- :frog: `MapFilter(fn func(T) (T, bool)) Piper[T]` — map and filter in one pass. If the returned bool is `false`, the value is dropped. Great for "skip this one" cases, [including error handling](#simple-error-handling).
-- :frog: `Sort(less func(*T, *T) bool) Piper[T]` — sort the current values. **Requires a known length**, so `Gen`/`Slice`/`Range`/`Repeat` first.
-- :frog: `Reduce(fn func(*T, *T) T) *T` — fold the whole pipe into a single value, left to right. Returns `nil` for an empty pipe. (*Postfix* reduce: type stays the same.)
-- :frog: `Sum(plus func(*T, *T) T) T` — like `Reduce` but **parallel-friendly**, so it wants an associative function (`+`, `*`, `min`, `max`...).
+- :frog: `Map(fn func(T) T) Piper[T]` -- apply `fn` to every element (same type in, same type out).
+- :frog: `Filter(fn func(*T) bool) Piper[T]` -- keep only the elements for which `fn` returns `true`. (**Tip:** the argument is a `*T`, so remember to dereference -- `*x`.)
+- :frog: `MapFilter(fn func(T) (T, bool)) Piper[T]` -- map and filter in one pass. If the returned bool is `false`, the value is dropped. Great for "skip this one" cases, [including error handling](#simple-error-handling).
+- :frog: `Sort(less func(*T, *T) bool) Piper[T]` -- sort the current values. **Requires a known length**, so `Gen`/`Slice`/`Range`/`Repeat` first.
+- :frog: `Reduce(fn func(*T, *T) T) *T` -- fold the whole pipe into a single value, left to right. Returns `nil` for an empty pipe. (*Postfix* reduce: type stays the same.)
+- :frog: `Sum(plus func(*T, *T) T) T` -- like `Reduce` but **parallel-friendly**, so it wants an associative function (`+`, `*`, `min`, `max`...).
 
 ### Grabbing a single value
 
-- :frog: `First() *T` — the first element, or `nil` if there is nothing (yes, it's a pointer).
-- :frog: `Any() *T` — *some* (effectively random under parallelism) element, or `nil` if empty.
-- :frog: `Count() int` — how many elements the pipe would produce. It still runs the pipeline, but skips building the result slice — so it's the memory-light way to ask "how many?".
+- :frog: `First() *T` -- the first element, or `nil` if there is nothing (yes, it's a pointer).
+- :frog: `Any() *T` -- *some* (effectively random under parallelism) element, or `nil` if empty.
+- :frog: `Count() int` -- how many elements the pipe would produce. It still runs the pipeline, but skips building the result slice -- so it's the memory-light way to ask "how many?".
 
 ### Running the pipe: Do & Promices
 
-- :frog: `Do() []T` — **execute** everything and return the resulting slice. This is the usual "end of pipeline" call.
-- :frog: `Promices() []func() (T, bool)` — instead of running now, get one lazy thunk per position. Each thunk returns `(value, ok)`; `ok == true` means "this value exists, append it". Handy if you want to schedule the work yourself. (The funny spelling is intentional — they're "promices" :)
+- :frog: `Do() []T` -- **execute** everything and return the resulting slice. This is the usual "end of pipeline" call.
+- :frog: `Promices() []func() (T, bool)` -- instead of running now, get one lazy thunk per position. Each thunk returns `(value, ok)`; `ok == true` means "this value exists, append it". Handy if you want to schedule the work yourself. (The funny spelling is intentional -- they're "promices" :)
 
 ### Erase & Collect
 
 Sometimes your pipeline needs to lug around different types at different steps. `Erase` gives up the compile-time type so you can work with `any`, and `Collect` puts a type back on.
 
-- :frog: `Erase() Piper[any]` (or `PiperNoLen[any]`) — every element becomes `any` (backed by a pointer to the original value).
-- :frog: `pipe.Collect[DstT](Piper[any]) Piper[DstT]` — pull a `Piper[any]` back into a concrete `Piper[DstT]`.
-- :frog: `pipe.CollectNL[DstT](PiperNoLen[any]) PiperNoLen[DstT]` — the same for a pipe with no known length.
+- :frog: `Erase() Piper[any]` (or `PiperNoLen[any]`) -- every element becomes `any` (backed by a pointer to the original value).
+- :frog: `pipe.Collect[DstT](Piper[any]) Piper[DstT]` -- pull a `Piper[any]` back into a concrete `Piper[DstT]`.
+- :frog: `pipe.CollectNL[DstT](PiperNoLen[any]) PiperNoLen[DstT]` -- the same for a pipe with no known length.
 
-A gotcha worth knowing: `Collect[DstT]` asserts each stored `any` to `*DstT`. So whatever you put into an erased pipe must be a **pointer** to the type you're collecting back — an `Erase()` of `Piper[int]` hands you `any` holding a `*int`, so you'd `Collect[int]`.
+A gotcha worth knowing: `Collect[DstT]` asserts each stored `any` to `*DstT`. So whatever you put into an erased pipe must be a **pointer** to the type you're collecting back -- an `Erase()` of `Piper[int]` hands you `any` holding a `*int`, so you'd `Collect[int]`.
 
 ### Error handling: Yeti & Snag
 
 This part is a little unusual, so read slowly.
 
-- :frog: `Yeti(y internalpipe.YeetSnag) Piper[T]` — register a *yeti* on the pipe. A yeti is a little error collector you create with `pipe.NewYeti()`.
-- :frog: `NewYeti() internalpipe.YeetSnag` — makes a yeti. It has `y.Yeet(err)` to throw an error into it.
-- :frog: `Snag(h func(error)) Piper[T]` — attach a handler that receives whatever got `Yeet`-ed into the **last** yeti that was set via `Yeti`.
+- :frog: `Yeti(y internalpipe.YeetSnag) Piper[T]` -- register a *yeti* on the pipe. A yeti is a little error collector you create with `pipe.NewYeti()`.
+- :frog: `NewYeti() internalpipe.YeetSnag` -- makes a yeti. It has `y.Yeet(err)` to throw an error into it.
+- :frog: `Snag(h func(error)) Piper[T]` -- attach a handler that receives whatever got `Yeet`-ed into the **last** yeti that was set via `Yeti`.
 
-In practice: create a yeti, register it with `Yeti(y)` **before** you start yeeting at it, yeet errors from inside your functions, and let `Snag` deal with them at the end. See the [examples](#simple-error-handling) — they make it click way faster than this paragraph.
+In practice: create a yeti, register it with `Yeti(y)` **before** you start yeeting at it, yeet errors from inside your functions, and let `Snag` deal with them at the end. See the [examples](#simple-error-handling) -- they make it click way faster than this paragraph.
 
 ### Ready-made helpers: pipies
 
 Package `pipies` has the little functions you'd otherwise rewrite every time:
 
-- :frog: `Sum[T]` — a reducer: `func(a, b *T) T { return *a + *b }`. Works for numbers and `~string`.
-- :frog: `Less[T]` — the everyday comparator for `Sort`.
+- :frog: `Sum[T]` -- a reducer: `func(a, b *T) T { return *a + *b }`. Works for numbers and `~string`.
+- :frog: `Less[T]` -- the everyday comparator for `Sort`.
 - :frog: **Predicates:** `NotNil`, `IsNil`, `NotZero`.
 - :frog: **Predicate builders:** `Eq(x)`, `NotEq(x)`, `LessThan(x)`, `Distinct(getKey)`.
-- :frog: **Negation:** `Not(fn)`, `Nott(fn)`, `Nottt(fn)` — flip a boolean-returning function with 1, 2, or 3 args (hence the extra t's).
+- :frog: **Negation:** `Not(fn)`, `Nott(fn)`, `Nottt(fn)` -- flip a boolean-returning function with 1, 2, or 3 args (hence the extra t's).
 
 ### Prefix helpers
 
 `Erase`/`Collect` work, but all those pointer conversions are annoying. The prefix functions in `pkg/pipe` are the pleasant way to change a pipe's type: pass the pipe first, the function second.
 
-- :frog: `pipe.Map(Piper[SrcT], func(SrcT) DstT) Piper[DstT]` — map + change type, known length.
-- :frog: `pipe.MapNL(PiperNoLen[SrcT], func(SrcT) DstT) PiperNoLen[DstT]` — same, unknown length.
-- :frog: `pipe.MapFilter(Piper[SrcT], func(SrcT) (DstT, bool)) Piper[DstT]` — map + filter + change type, known length.
-- :frog: `pipe.MapFilterNL(PiperNoLen[SrcT], func(SrcT) (DstT, bool)) PiperNoLen[DstT]` — same, unknown length.
-- :frog: `pipe.Reduce(Piper[SrcT], func(*DstT, *SrcT) DstT, initVal ...DstT) DstT` — prefix reduce that can also change type. Mind the argument order: the accumulator (`*DstT`) comes first, then the current element (`*SrcT`). `initVal` is optional and seeds the fold.
+- :frog: `pipe.Map(Piper[SrcT], func(SrcT) DstT) Piper[DstT]` -- map + change type, known length.
+- :frog: `pipe.MapNL(PiperNoLen[SrcT], func(SrcT) DstT) PiperNoLen[DstT]` -- same, unknown length.
+- :frog: `pipe.MapFilter(Piper[SrcT], func(SrcT) (DstT, bool)) Piper[DstT]` -- map + filter + change type, known length.
+- :frog: `pipe.MapFilterNL(PiperNoLen[SrcT], func(SrcT) (DstT, bool)) PiperNoLen[DstT]` -- same, unknown length.
+- :frog: `pipe.Reduce(Piper[SrcT], func(*DstT, *SrcT) DstT, initVal ...DstT) DstT` -- prefix reduce that can also change type. Mind the argument order: the accumulator (`*DstT`) comes first, then the current element (`*SrcT`). `initVal` is optional and seeds the fold.
 
 ### The ff shortcuts
 
@@ -203,12 +203,12 @@ When a whole pipe is overkill and you just want to run one function over a slice
 
 ### Still cooking (TBD)
 
-These aren't in yet — they're on the wishlist:
+These aren't in yet -- they're on the wishlist:
 
-- :seedling: `Until(fn func(*T) bool)` — evaluate one-by-one until `fn` says stop. (Single-threaded only by nature.)
-- :seedling: `IsAny() bool` — does the pipe have *any* element?
-- :seedling: `MoreThan(n int) bool` — does it have *more than* `n`?
-- :seedling: `Reverse() Pipe` — reverse the underlying slice.
+- :seedling: `Until(fn func(*T) bool)` -- evaluate one-by-one until `fn` says stop. (Single-threaded only by nature.)
+- :seedling: `IsAny() bool` -- does the pipe have *any* element?
+- :seedling: `MoreThan(n int) bool` -- does it have *more than* `n`?
+- :seedling: `Reverse() Pipe` -- reverse the underlying slice.
 
 ## Examples
 
@@ -252,7 +252,7 @@ p := pipe.Func(func(i int) (v int, b bool) {
 
 ### Take vs Gen
 
-**`Gen(n)`** evaluates the first `n` positions, then the filters get their say — so you can end up with **fewer than `n`** elements:
+**`Gen(n)`** evaluates the first `n` positions, then the filters get their say -- so you can end up with **fewer than `n`** elements:
 
 ```go
 p := pipe.Func(func(i int) (v int, b bool) {
@@ -264,7 +264,7 @@ p := pipe.Func(func(i int) (v int, b bool) {
 // p will be [0, 2, 4, 6, 8]
 ```
 
-All ten positions `0..9` are evaluated, but only the evens survive — 5 values, not 10.
+All ten positions `0..9` are evaluated, but only the evens survive - 5 values, not 10.
 
 **`Take(n)`** keeps going until `n` values actually make it through the filter:
 
@@ -281,7 +281,7 @@ p := pipe.Func(func(i int) (v int, b bool) {
 And here's the trap: if `Take` asks for more values than your source can ever produce, it will spin all the way up to `math.MaxInt` and then panic.
 
 ```go
-// DO NOT DO THIS — it will grind until math.MaxInt and then panic
+// DO NOT DO THIS - it will grind until math.MaxInt and then panic
 p := pipe.Func(func(i int) (v int, b bool) {
 	return i, i < 10 // only the first 10 values survive
 }).
@@ -364,7 +364,7 @@ Check the `pipies` package for more handy predicates and comparators.
 
 ### An infinite sequence
 
-`Func` can be stateful, so you can describe a sequence that never ends — here's a lazy Fibonacci generator. Each value is stashed in a one-slot channel so the next call can find it. To keep the order sane, let it run on a single goroutine (the default) and cap it with `Take`:
+`Func` can be stateful, so you can describe a sequence that never ends -- here's a lazy Fibonacci generator. Each value is stashed in a one-slot channel so the next call can find it. To keep the order sane, let it run on a single goroutine (the default) and cap it with `Take`:
 
 ```go
 fib := make([]chan int, 60)
@@ -482,14 +482,14 @@ This builds `256/i` for `i` from `-10` to `9`. The `0` would explode, so we `Yee
 
 The flow is:
 
-1. `pipe.NewYeti()` — make an error collector.
-2. `Yeti(y)` — register it on the pipe. **Do this before yeeting**, or nothing will catch your error.
-3. `y.Yeet(err)` — throw an error from inside your function.
-4. `Snag(handler)` — attach the function that deals with whatever was yeeted. You can stack several `Snag`s; they all go to the **last** yeti registered with `Yeti`.
+1. `pipe.NewYeti()` -- make an error collector.
+2. `Yeti(y)` -- register it on the pipe. **Do this before yeeting**, or nothing will catch your error.
+3. `y.Yeet(err)` -- throw an error from inside your function.
+4. `Snag(handler)` -- attach the function that deals with whatever was yeeted. You can stack several `Snag`s; they all go to the **last** yeti registered with `Yeti`.
 
 ### Multiple error handling
 
-Different stages of a pipeline can have their own yetis and handlers — nice for a real user-enrichment flow:
+Different stages of a pipeline can have their own yetis and handlers -- nice for a real user-enrichment flow:
 
 ```go
 y1, y2 := pipe.NewYeti(), pipe.NewYeti()
@@ -531,7 +531,7 @@ It compares FuncFrog against plain `for` loops for `Map`, `Filter`, `Reduce`, `A
 
 ## Is this stable?
 
-Yep — **stable since v1.0.0**. Everything listed above is covered by unit tests. The stuff under [Still cooking](#still-cooking-tbd) will land as described and get tests before it's called stable.
+Yep! **Stable since v1.0.0**. Everything listed above is covered by unit tests. The stuff under [Still cooking](#still-cooking-tbd) will land as described and get tests before it's called stable.
 
 If I ever change a method signature, the **major version goes up**.
 
@@ -541,6 +541,6 @@ PRs are welcome, especially for the [TBD](#still-cooking-tbd) features. Same goe
 
 ## What's next?
 
-A proper roadmap is coming. Until then — fork it, play with it, and enjoy.
+A proper roadmap is coming. Until then -- fork it, play with it, and enjoy.
 
 Happy piping! :frog: