Return a result determined only by inputs without observable side effects.

Represent a change by producing a new value rather than modifying an existing one.

Accept functions as inputs or return functions as results.

Create a transformation by feeding each function’s result to the next.

Pass a value through a readable ordered sequence of transformations.

Transform a multi-argument function into a series of one-argument functions.

Create a new function by fixing some arguments of an existing function.

Combine a function with values captured from its lexical environment.

Cache function results by input so repeated calls reuse prior work.

Apply a function to each contained value while preserving structure.

Retain elements that satisfy a predicate.

Collapse a structure into a result using a combining function and accumulator.

Preserve previous versions while sharing unchanged structure with new versions.

Compose a focused getter with an immutable updater for nested data.

Model data using explicit product and alternative cases.

Select and bind behavior by the structural form of data.

Represent either a present value or explicit absence.

Represent either a success value or a structured failure value.

Apply an ordinary function to values inside a context while preserving that context.

Combine independent computations that each occur inside a context.

Sequence contextual computations where each next step depends on the prior result.

Solve a problem by defining base cases and combining smaller instances.

Place the recursive call in final position so an implementation may reuse the stack frame.

Represent recursive continuation steps as values and execute them in a loop.

Delay a computation until its value is demanded and optionally retain the result.