Function zip

src/compute-engine/collection-utils.ts:55–117

(items: ReadonlyArray<Expression>)

 * `Filter(xs, p)` used to answer `[]`, `Any(xs, p)` `False`, `All(xs, p)`
 * `True`, `Find(xs, p)` `Nothing` and `IndexWhere(xs, p)` `0` for such a
 * source — answers a later `xs := [1, 5]` contradicts, and which the rest of
 * the library (`Length`, `Total`, `Sort`, `Map`, `CountIf`, …) has always
 * declined to give by staying inert.
 *
 * An EAGER collection operator (`Characters(s)`, `Divisors(n)`, `Eigenvalues`,
 * … — 73 of them, against 47 with collection handlers) has no collection
 * handlers either until it is evaluated, and is the one case
 * `isEnumerableCollection` reports `undefined` for. The evaluated form is
 * consulted for exactly that case — off the hot path, since a source that is
 * already a collection answers on the first test.
 *
 * **On the discarded evaluation** (measured 2026-08-09, don't re-litigate):
 * the fallback fires only for a source that is not already a collection, and
 * only at the LEAF of a chain — an inner `Filter`/`Map`/`Take` answers `true`
 * on the first test. Measured at nesting depth 6 over `Characters(400)`: 12
 * calls, 2 fallbacks; it does not compound with depth. The evaluated form is
 * also what the subsequent walk materializes, and the lazy-collection evaluate
 * memo keeps that second pass cheap.
 *
 * **Why the dedicated facet, and not the emptiness ones.**
 * `isEmptyCollection`/`count` are HONEST about a valueless leaf (both
 * `undefined`), and so is a wrapper over one (`Take(xs, 2)`, `Reverse(xs)`),
 * where `isCollection` answers `true`. But reading them from here is
 * **exponential**: `Filter.isEmpty` would call this, which reads the source's
 * `isEmptyCollection`, which is the inner `Filter.isEmpty`, which calls this
 * again — measured at exactly 2^(d+1) − 2 calls (6/14/30/62/126/254 at depths
 * 2–7), the double-read shape-query class. `isEnumerableCollection` is the
 * O(1) propagating facet that answers instead: a wrapper reads only its
 * source's enumerability (never its own emptiness), so a depth-d chain costs
 * d calls.
 *
 * **On evaluating an IMPURE source.** The fallback evaluates `xs` and throws
 * the result away, so an eager IMPURE producer (`RandomShuffle`) runs one
 * extra time. That is a pre-existing property of these paths rather than
 * something this predicate introduced: counting handler invocations for a
 * 5-element source, `Map(f, RandomShuffle(xs))` — which never reaches this
 * function — evaluates the shuffle **8** times, `Filter(RandomShuffle(xs), p)`
 * 5 (of which this contributes 1), `Any(…)` 2. The results stay correct (a
 * filtered shuffle is still a filtered shuffle); what is not reproducible is
 * the number of draws consumed. Tracked in `ROADMAP.md` as its own defect —
 * fixing it here alone would not make the path reproducible.
 *
 * **Asymmetry with {@link isBroadcastableCollection}** — deliberate. That
 * predicate has no such fallback because it answers a different question at a
 * different place: it is consulted on operands that have ALREADY been
 * evaluated (the broadcast gates run post-evaluation), and it fails CLOSED —
 * a `false` means "do not broadcast", which leaves the expression symbolic.
 * This one is consulted inside LAZY collection handlers, where the source may
 * still be raw, and a wrong answer produces a definite wrong VALUE. Accuracy
 * is worth an evaluation here and is not needed there.
 */
export function isEnumerableSource(xs: Expression): boolean {
  // The facet answers structurally for everything that can be decided without
  // evaluating: a leaf collection (`true`), a symbolic-bounds `Range` or a
  // valueless symbol (`false`), and a wrapper over either (propagated).
  const enumerable = xs.isEnumerableCollection;
  if (enumerable !== undefined) return enumerable;