Function matchRemaining

src/compute-engine/boxed-expression/match.ts:991–1217

* Match a list of patterns against *remaining* (locally scoped) `ops` and consume this list along * the way, whilst appending to `substitution`. If a complete/successful match, return this new * substitution; else return `null`. * * @note: calls recursively (permutations) for sequence wi

(
    patterns: ReadonlyArray<Expression>,
    substitution: BoxedSubstitution
  )

      }
      for (let i = start; i < n; i++) {
        combo.push(i);
        backtrack(i + 1);
        combo.pop();
      }
    }

    backtrack(0);
    return result;
  }
}

/**
 * Match a list of patterns against operands of expression, appending wildcards (named) to
 * *substitution* (along the way). If a successful match, returns the new substitution (or the same
 * if no named wildcard), or *null* for no match.
 *
 * @param expr
 * @param patterns
 * @param substitution
 * @param options
 * @returns
 */
function matchArguments(
  expr: Expression,
  patterns: ReadonlyArray<Expression>,
  substitution: BoxedSubstitution,
  options: PatternMatchOptions
): BoxedSubstitution | null {
  if (patterns.length === 0) {
    if (isFunction(expr) && expr.ops.length === 0) return substitution;
    return null;
  }

  const ce = patterns[0].engine;

  // We're going to consume the ops array, so make a copy
  if (!isFunction(expr)) return null;
  const ops = [...expr.ops];

  return matchRemaining(patterns, substitution);

  /*
   * Local f().
   */
  /**
   * Match a list of patterns against *remaining* (locally scoped) `ops` and consume this list along
   * the way, whilst appending to `substitution`. If a complete/successful match, return this new
   * substitution; else return `null`.
   *
   * @note: calls recursively (permutations) for sequence wildcards
   *
   * @param patterns
   * @param substitution
   * @returns
   */
  function matchRemaining(
    patterns: ReadonlyArray<Expression>,
    substitution: BoxedSubstitution