Function apply

src/compute-engine/function-utils.ts:275–298

(
  fn: Expression,
  args: ReadonlyArray<Expression>
)

  //      Without this gate the shorthand path below reads it as a lambda
  //      BODY and turns its free symbols into parameters, so
  //      `Map(Comparable.compare, xs)` bound each ELEMENT to `Comparable`
  //      and mapped `Field(element, "compare")` — an absence marker per
  //      element. Same predicate as `apply()`'s symbolic-application gate,
  //      so the two tiers agree — plus its syntactic sibling for a RAW
  //      operand (a lazy operator's held callback), whose type still reads
  //      `unknown` and cannot answer the type-based predicate.
  //
  if (denotesFunction(expr) || isQualifiedProtocolMember(expr)) return expr;

  //
  // 6/ Shorthand function literal,
  // e.g. `["Add", "_", 1]` or `["Add", "x", 1]`
  //
  console.assert(expr.operator !== 'Function');

  const ce = expr.engine;
  let [body, params] = anonymousParameters(expr);

  if (params.length === 0) {
    // There are no wildcards

    // The caller knows the intended parameter list (`Integrate` passes its
    // integration variables): build the literal from the RAW body with those
    // parameters, so body occurrences bind to them through the normal §6.1
    // pre-declare mechanism in `canonicalFunctionLiteralArguments`. Inferring
    // parameters from the body's unknowns and swapping the parameter list
    // afterwards is NOT equivalent: the inferred parameters are declared in