Function flatten

src/compute-engine/boxed-expression/flatten.ts:17–69

(
  ops: T,
  operator?: string,
  canonicalize = true
)

 * Note: *not* recursive
 */
export function flatten<T extends ReadonlyArray<Expression> | Expression[]>(
  ops: T,
  operator?: string,
  canonicalize = true
): T {
  // Optionally make all the arguments canonical.
  const xs: ReadonlyArray<Expression> =
    !canonicalize || ops.every((x) => x.isCanonical)
      ? ops
      : ops.map((x) => x.canonical);

  if (operator) {
    const shouldFlatten = (x: Expression) =>
      isSymbol(x, 'Nothing') ||
      x.operator === operator ||
      x.operator === 'Sequence';

    // Bypass memory allocation for the common case where there is nothing to flatten
    if (xs.every((x) => !shouldFlatten(x))) return xs as T;

    // Iterate over the list of expressions and flatten them
    const ys: Expression[] = [];
    for (const x of xs) {
      // Skip Nothing
      if (isSymbol(x, 'Nothing')) continue;

      // If the operator matches, flatten the expression
      if (
        isFunction(x) &&
        (x.operator === operator || x.operator === 'Sequence')
      )
        ys.push(...flatten(x.ops, operator, canonicalize));
      else ys.push(x);
    }
    return ys as T;
  }

  if (xs.every((x) => !(isSymbol(x, 'Nothing') || x.operator === 'Sequence')))
    return xs as T;

  // Iterate over the list of expressions and flatten them
  const ys: Expression[] = [];
  for (const x of xs) {
    // Skip Nothing
    if (isSymbol(x, 'Nothing')) continue;

    // If the operator matches, flatten the expression
    if (isFunction(x, 'Sequence'))
      ys.push(...flatten(x.ops, operator, canonicalize));
    else ys.push(x);
  }
  return ys as T;
}

/**
 * Like {@link flatten}, but ellipsis-fold barriers are held back.