Function makeLambda

src/compute-engine/function-utils.ts:449–638

(
  expr: Expression
)

  // Replace '_' with '_1'
  const body = expr.subs({ _: '_1' });

  const params: Expression[] = [];
  for (let i = 1; i < 10; i++)
    if (body.has(`_${i}`))
      params.push(body.engine.symbol(`_${i}`, { canonical: false }));

  return [body, params];
}

/** Assuming that ops has the following form:
 * - body
 * - ...params
 * return a canonical function literal (["Function", body, ...params]) where
 * body is potentially wrapped in a Block expression and the arguments are
 * declared in the scope of the body.
 */
export function canonicalFunctionLiteralArguments(
  ce: ComputeEngine,
  ops: ReadonlyArray<Expression>
): Expression | undefined {
  if (ops.length === 0) return undefined;

  // ── The E2 pre-pass (generic-literals design §2.3), ordered FIRST ──────────
  //
  // A full-signature marker in the body slot is the literal's contract
  // of record. It has to be read BEFORE the parameter operands are normalized:
  // a hand-authored E2 (and the M2 lowering) may carry `["Typed", x, "'T'"]`
  // parameters, and `T` is not a declared type name — type resolution would
  // fail on it below. Under the erasure ruling (G1) those annotations are
  // redundant anyway: the marker states the parameter types, and quantified
  // positions are erased so the body canonicalizes exactly as an untyped
  // literal's does.
  const erased = eraseGenericParameters(ce, ops);
  let genericMarker = false;
  if (erased !== undefined) {
    // A well-formedness violation is reported in place; otherwise continue with
    // the erased operands.
    if (erased.error !== undefined) return erased.error;
    ops = erased.ops!;
    genericMarker = erased.generic === true;
  }

  // Signature-string sugar (typed-literals design §3.2/§10):
  // `["Function", body, "'(n: integer) -> complex'"]` desugars into the
  // structural form — each named argument becomes a `["Typed", name, type]`
  // parameter and a non-`unknown` result becomes the body's return-type
  // ascription. Applied only when the single parameter operand is a string
  // parsing to a signature type with every argument named and no
  // optional/variadic markers (those need `makeLambda` arity support);
  // anything else falls through to the standard expected-a-symbol error —
  // except a string that IS signature-shaped and fails to parse as a type,
  // which reports the type parser's own diagnostic (see
  // `signatureStringError`) rather than blaming the operand.
  if (ops.length === 2 && isString(ops[1])) {
    // A `where` clause IS accepted here (generic-literals design §2.2, E1):
    // the string parses to a signature carrying `typeParams` and desugars into
    // the E2 form — bare symbols at the quantified positions (erasure, G1) and
    // the full signature as the body's ascription — which then re-enters this