Class: What

Dynamic version: cartesian product of twoextends results for a given call.

Applies a function or What instance f to each result produced by this What and flattens the final Each of iterables into an Each.

Attach a fallback to handle missing results or matching errors.

This dynamic version of else extends the primary function with recovery logic:

• If the primary function returns undefined, the fallback f is invoked.
• If the primary function throws an error, the error is tested against the optional matcher.
  • If it matches, the fallback f is invoked instead.
  • If it does not match, the error is re-thrown.
• When the fallback is invoked due to an error, the error object is appended as the last argument to f.

Error matching is delegated to Errors.matches, which supports:

• number: compares against err.statusCode
• string: compares against error class name, or substring match for thrown strings
• RegExp: tested against the error message or thrown string
• Function: custom predicate (err) => boolean

Constants (non-functions) are automatically lifted into functions returning that constant.

Conditional execution: keep only inputs passing a predicate.

Wraps this What so that it executes only if the predicate returns true. If the predicate returns false, returns undefined by default. Optionally, an error can be provided to be thrown.

Zip multiple What instances.

Dynamically adapts this What instance for different use cases depending on the arguments.

The behavior depends on the arguments passed, supporting multiple overload modes:

1. Path-expanding mode (no arguments):

   • self()
   • Converts this What: item -> items to a What: path -> paths by expanding path.last through the original function.

2. Context-mapping / nominal mode (string or string[] as first argument):

   • self(name) → extracts ctx[name] and passes it as input.
   • self(nameIn, nameOut) → maps ctx[nameIn] to input and stores result in ctx[nameOut].
   • self([name1, name2, ...]) → extracts multiple properties from context.
   • self([name1, name2, ...], nameOut) → stores result in ctx[nameOut].

3. Argument-binding mode (two numeric arguments):

   • self(index, value)
   • Injects value into the argument list at position index.

4. Timeout mode (single numeric argument):

   • self(timeoutMs)
   • Promotes this What to an AsyncWhat that rejects if the computation does not complete within timeoutMs milliseconds.

5. Retry mode (numeric first argument with ≥3 args):

   • self(nAttempts, baseDelay, factor, maxDelay)
   • Promotes this What to an AsyncWhat that retries execution up to nAttempts with exponential backoff. The resulting AsyncWhat exposes a .stopped property to cancel the retries.

Map values through a function.

Asynchronous conditional in event-driven mode.

Promotes the current What (this) into an AsyncWhat that wraps the underlying logic and executes conditionally based on the occurrence of a specified event and a predicate.

Behavior:

• start = true: the underlying AsyncWhat is executed only when the predicate evaluates truthy upon the event.
• start = false: the underlying AsyncWhat is immediately invoked (so it can run and be stopped), and will be stopped when the predicate evaluates truthy upon the event.

If no matching event occurs within timeoutMs, the returned AsyncWhat rejects with a TimeoutError.

The returned AsyncWhat proxies the .stopped property of the underlying AsyncWhat, allowing external control over cyclic or self-driven executions.

Example: infinite cyclic execution with start/stop triggers

const cyclic = doSomething.self(Infinity, 100, 1);

const bounded = cyclic .when( isStart, // predicate identifying start condition emitter, // event source event, // event name to listen for undefined, // optional timeout true // start cyclic execution when event occurs ) .when( isStop, // predicate identifying stop condition emitter, event, undefined, false // stop cyclic execution when event occurs );

bounded();

Conditional output filter: keeps only results that satisfy the predicate.

Executes this What and evaluates the predicate on the result. If the predicate returns false, returns undefined by default. Optionally, it can throw a provided error.

Wrap a value, function, or What instance as a What.

Static version: generates a search space of Paths across multiple Functions.

Creates a What instance that returns a fixed value when called with an exact sequence of arguments.

Essentially defines a single mapping:

(arg1, arg2, ..., argN) → value

If the input arguments exactly match the defined sequence (deep equality check via Each.equal), the stored value is returned; otherwise undefined.

Example

const f = What.of(1, 2, "answer");
console.log(f(1, 2));    // "answer"
console.log(f(1));       // undefined
console.log(f(2, 1));    // undefined

Attach the prototype of instance to function f.