Function runLoopLegacy

src/compute-engine/library/control-structures.ts:457–495

(
  body: Expression,
  collection: Expression,
  ce: ComputeEngine
)

        // item 52): at or below `MAX_SIZE_EAGER_COLLECTION` the distribution
        // is materialized into a `List`; past the threshold the held `When` is
        // kept and its `collection` handlers (see `whenCollectionHandlers`)
        // expose the same elements lazily. The type check gates the extra
        // `evaluate` so a scalar `When` keeps its held form unchanged.
        // A `Tuple` is excluded: it is a fixed-arity structure (a point), not a
        // list to broadcast over, so a restricted point must stay a point
        // rather than degrade to a `List`. Mirrors `PointList`'s
        // `isListComponent` predicate in `collections.ts`.
        // A tuple-typed value is excluded before it is evaluated: evaluating
        // it here would force every component of a value the restriction is
        // meant to keep held, changing the lazy guard semantics for a shape
        // that can never enter the distribution path anyway.
        // A STRING is excluded for the same reason a tuple is: it is an
        // indexed collection of characters, but it is atomic under
        // element-wise distribution, so `When("ab", c)` must stay a restricted
        // string rather than become a list of restricted characters.
        // A CONDITION that is collection-typed but carries no value yet is a
        // MASK that cannot be read yet, not the scalar guard this branch
        // distributes: splicing it into every cell freezes a nested result.
        // `When([1,2], B)` for a valueless `B: list<boolean>` gave
        // `[1 {B}, 2 {B}]`, which re-evaluates to `[[1,Undefined],[2,Undefined]]`
        // once `B := [True, False]` — where the same expression evaluated
        // fresh masks to `[1, Undefined]` (Tycho item 221). Stay held; the
        // list-condition branch above zips the mask once it resolves.
        if (
          expr.type.matches('collection<any>') &&
          !isTupleShapedType(expr.type.type) &&
          !expr.type.matches('string') &&
          !isUnresolvedCollectionOperand(c)
        ) {
          const ev = expr.evaluate(options);
          if (isFiniteBroadcastParticipant(ev)) {
            const n = ev.count ?? Infinity;
            if (n <= MAX_SIZE_EAGER_COLLECTION) {
              const result = Array.from(ev.each()).map((elem) =>
                ce._fn('When', [elem, c])
              );
              return ce._fn('List', result);
            }
            // Too large to materialize: hold the (evaluated) collection so the
            // collection handlers can walk it.
            return ce._fn('When', [ev, c]);
          }