Logical xor operator
True when exactly one of two values is truthy.
function xor([a, b]) { return Boolean(a) !== Boolean(b); }functionCollection · 17 utilities
Function utilities
Higher-order helpers: compose, curry, memoize, run once. They take functions as input, so each page shows executed usage instead of a JSON example.
Identity function
Return the argument unchanged.
function identity(value) { return value; }functionBox handler
Chain transformations on a value, then unwrap the result.
function boxHandler(value) { return { next: f => boxHandler(f(value)), done: f => f(value) }; }…functionCheck if a value is a function
True for anything callable: functions, arrows, async and generator functions, classes.
function isFunction(value) { return typeof value === 'function'; }functionCheck if a value is a generator function
Read the internal tag of function* and async function* declarations.
function isGeneratorFunction(value) { return ['[object GeneratorFunction]', '[object AsyncGener…functionCheck if a value is an async function
Read the internal tag of async function declarations and arrows.
function isAsyncFunction(value) { return Object.prototype.toString.call(value) === '[object Asy…functionCompose functions from left to right
Build one function that passes a value through each function in order.
function pipe(...fns) { return input => fns.reduce((value, fn) => fn(value), input); }functionCompose functions
Build one function that applies functions from right to left, as in f(g(x)).
function compose(...fns) { return input => fns.reduceRight((value, fn) => fn(value), input); }functionCreate a function that accepts a single argument
Wrap a function so it ignores every argument after the first.
function unary(fn) { return value => fn(value); }functionCreate an empty function
A function that does nothing and returns undefined.
function noop() {}functionCurry a function
Collect arguments across calls until the function has as many as it declares.
function curry(fn, ...args) { return fn.length <= args.length ? fn(...args) : (...more) => curr…functionDelay the evaluation of a function
Turn a call into a thunk: a function that runs the call only when invoked.
function thunkify(fn) { return (...args) => () => fn(...args); }functionExecute a function once
Run a function on the first call and return that result afterwards.
function once(fn) { let done = false, result; return (...args) => { if (!done) { result = fn(..…functionFlip the arguments of a function
Call a function with its arguments in reverse order.
function flip(fn) { return (...args) => fn(...args.reverse()); }functionMemoize a function
Cache results by argument so each input is computed once.
function memoize(fn) { const cache = new Map(); return arg => { if (!cache.has(arg)) cache.set(…functionPartially apply a function
Fix the first arguments now and pass the rest later.
function partial(fn, ...preset) { return (...rest) => fn(...preset, ...rest); }functionUncurry a function
Call a curried function with several arguments at once.
function uncurry(fn, depth = 1) { return (...args) => args.slice(0, depth).reduce((next, arg) =…functionTry a function in the local code lab, then read its limits before using it in an application.