extra-function
Version:
Functions are one of the fundamental building blocks in JavaScript.
1,077 lines • 75.4 kB
JavaScript
//#region TYPES
/**
* unknown function type.
* @params args arguments
* @returns unknown value
*/ //#endregion
//#region CONSTANTS
/**
* Do nothing.
* @param _args arguments (ignored)
* @example
* ```javascript
* xfunction.NOOP(1, 2);
* // → undefined
*
* xfunction.NOOP('a', 'b');
* // → undefined
* ```
*/ export function NOOP(..._args) {}
// - https://lodash.com/docs/4.17.15#noop
/**
* Return false.
* @param _args arguments (ignored)
* @returns false.
* @example
* ```javascript
* xfunction.FALSE();
* // → false
* ```
*/ export function FALSE(..._args) {
return false;
}
// - https://www.npmjs.com/package/boolbase
/**
* Return true.
* @param _args arguments (ignored)
* @returns true.
* @example
* ```javascript
* xfunction.TRUE();
* // → true
* ```
*/ export function TRUE(..._args) {
return true;
}
// - https://www.npmjs.com/package/boolbase
/**
* Return the same (first) value.
* @param v a value
* @returns v
* @example
* ```javascript
* xfunction.IDENTITY(1);
* // → 1
*
* xfunction.IDENTITY('a');
* // → 'a'
* ```
*/ export function IDENTITY(v) {
return v;
}
/**
* Compare two values.
* @param a a value
* @param b another value
* @returns a<b: -1, a=b: 0, a>b: 1
* @example
* ```javascript
* xfunction.COMPARE(1, 2);
* // → -1
*
* xfunction.COMPARE(2, 1);
* // → 1
*
* xfunction.COMPARE(1, 1);
* // → 0
*/ export function COMPARE(a, b) {
return a < b ? -1 : a > b ? 1 : 0;
}
/**
* Return the arguments passed as a array.
* @param args arguments
* @returns [...args]
* @example
* ```javascript
* xfunction.ARGUMENTS(1, 2);
* // → [1, 2]
*
* xfunction.ARGUMENTS('a', 'b');
* // → ['a', 'b']
* ```
*/ export function ARGUMENTS(...args) {
return args;
}
//#endregion
//#region METHODS (BUILTIN)
//#region ABOUT
/**
* Get the name of a function.
* @param x a function
* @returns name
* @example
* ```javascript
* import {delay, debounce} from "jsr:@nodef/extra-function";
*
* xfunction.name(delay);
* // → 'delay'
*
* xfunction.name(debounce);
* // → 'debounce'
* ```
*/ export function name(x) {
return x.name;
}
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
// - https://www.npmjs.com/package/fn-name
/**
* Get the number of parameters of a function.
* @param x a function
* @returns |[p, q, ...]| | x(p, q, ...)
* @example
* ```javascript
* xfunction.length(() => 0);
* // → 0
*
* xfunction.length((x, y) => 0);
* // → 2
* ```
*/ export function length(x) {
return x.length;
}
export { length as arity };
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length
//#endregion
//#region BINDING
/**
* Bind this-object, and optional prefix arguments to a function.
* @param x a function
* @param ths this object to bind
* @param prefix prefix arguments
* @returns (...args) => this.x(...prefix, ...args)
* @example
* ```javascript
* var array = [1];
* var fn = xfunction.bind(Array.prototype.push, array);
* fn(2, 3, 4); // push(2, 3, 4)
* array;
* // → [1, 2, 3, 4]
*
* var array = [1, 2, 3, 4];
* var fn = xfunction.bind(Array.prototype.splice, array, 1);
* fn(2); // splice(1, 2)
* array;
* // → [1, 4]
* ```
*/ export function bind(x, ths, ...prefix) {
return x.bind(ths, ...prefix);
}
// - https://underscorejs.org/#bind
// - https://lodash.com/docs/4.17.15#bind
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind
//#endregion
//#region INVOCATION
/**
* Invoke a function with specified this-object, and arguments provided individually.
* @param x a function
* @param ths this object to invoke with
* @param args arguments
* @returns this.x(...args)
* @example
* ```javascript
* var array = [1];
* xfunction.call(Array.prototype.push, array, 2, 3, 4); // push(2, 3, 4)
* array;
* // → [1, 2, 3, 4]
*
* var array = [1, 2, 3, 4];
* xfunction.call(Array.prototype.splice, array, 1, 2); // splice(1, 2)
* array;
* // → [1, 4]
* ```
*/ export function call(x, ths = null, ...args) {
return x.call(ths, ...args);
}
/**
* Invoke a function with specified this-object, and arguments provided as an array.
* @param x a function
* @param ths this object to invoke with
* @param args arguments array
* @returns this.x(...args)
* @example
* ```javascript
* var array = [1];
* xfunction.apply(Array.prototype.push, array, [2, 3, 4]); // push(2, 3, 4)
* array;
* // → [1, 2, 3, 4]
*
* var array = [1, 2, 3, 4];
* xfunction.apply(Array.prototype.splice, array, [1, 2]); // splice(1, 2)
* array;
* // → [1, 4]
* ```
*/ export function apply(x, ths = null, args) {
return x.apply(ths, args);
}
//#endregion
//#endregion
//#region METHODS (CUSTOM)
//#region ABOUT
/**
* Check if value is a function.
* @param v a value
* @returns is function?
* @example
* ```javascript
* xfunction.is(Object.keys);
* // → true
*
* xfunction.is(() => 0);
* // → true
*
* xfunction.is(async () => 0);
* // → true
*
* xfunction.is(0);
* // → false
* ```
*/ export function is(v) {
return typeof v === "function";
}
// - https://www.npmjs.com/package/is-function
/**
* Check if value is an async function.
* @param v a value
* @returns is async function?
* @example
* ```javascript
* xfunction.isAsync(async () => 0);
* // → true
*
* xfunction.isAsync(() => 0);
* // → false
* ```
*/ export function isAsync(v) {
const AsyncFunction = (async function() {}).constructor;
return v instanceof AsyncFunction;
}
// - https://www.npmjs.com/package/is-async-function
// - https://www.npmjs.com/package/is-callback-function
// - https://davidwalsh.name/javascript-detect-async-function
// - https://stackoverflow.com/questions/38508420/how-to-know-if-a-function-is-async
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction
/**
* Check if value is a generator function.
* @param v a value
* @returns is generator function?
* @example
* ```javascript
* function* naturalNumbers() {
* for (var i=0;; ++i)
* yield i;
* }
*
* xfunction.isGenerator(naturalNumbers);
* // → true
*
* xfunction.isGenerator(() => 0);
* // → false
* ```
*/ export function isGenerator(v) {
const GeneratorFunction = (function*() {}).constructor;
return v instanceof GeneratorFunction;
}
// - https://www.npmjs.com/package/is-generator
// - https://www.npmjs.com/package/is-generator-fn
// - https://www.npmjs.com/package/is-generator-function
// - https://stackoverflow.com/questions/16754956/check-if-function-is-a-generator
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator
// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction
//#endregion
//#region CONTEXT
/**
* Contextify a function by accepting the first parameter as this-object.
* @param x a function
* @returns (...args) => x(this, ...args)
* @example
* ```javascript
* function count(x, value) {
* var a = 0;
* for (var v of x)
* if (v===value) ++a;
* return a;
* }
*
* var fn = xfunction.contextify(count);
*
* fn.call([6, 3, 4, 3], 3);
* // → 2
*
* fn.call([6, 1, 4, 3], 3);
* // → 1
* ```
*/ export function contextify(x) {
return function(...args) {
return x(this, ...args);
};
}
/**
* Decontextify a function by accepting this-object as the first argument.
* @param x a function
* @returns (this, ...args) => this.x(...args)
* @example
* ```javascript
* function count(value) {
* var a = 0;
* for (var v of this)
* if (v===value) ++a;
* return a;
* }
*
* var fn = xfunction.decontextify(count);
*
* fn([6, 3, 4, 3], 3);
* // → 2
*
* fn([6, 1, 4, 3], 3);
* // → 1
* ```
*/ export function decontextify(x) {
return (ths = null, ...args)=>x.call(ths, ...args);
}
//#endregion
//#region RESULT MANIPULATION
/**
* Generate a result-negated version of a function.
* @param x a function
* @returns (...args) => !x(...args)
* @example
* ```javascript
* var fn = xfunction.negate(isFinite);
* fn(Infinity)
* // → true
* fn(1)
* // → false
*
* var fn = xfunction.negate(isNaN);
* fn(1);
* // → true
* fn(NaN);
* // → false
* ```
*/ export function negate(x) {
return (...args)=>!x(...args);
}
/**
* Generate result-cached version of a function.
* @param x a function
* @param fr resolver ((...args) => unique key) [IDENTITY]
* @param cache result cache [Map()]
* @example
* ```javascript
* var calls = 0;
*
* function factorialRec(n: number) {
* if (n<=1) return 1;
* return n * factorialRec(n-1);
* }
*
* function factorial(n: number) {
* ++calls;
* return factorialRec(n);
* }
*
* var fn = xfunction.memoize(factorial);
* fn(3);
* // → 6
* fn(4);
* // → 24
* fn(5);
* // → 120
* fn(3);
* // → 6
* fn(4);
* // → 24
* fn(5);
* // → 120
* calls;
* // → 3
*
*
* var calls = 0;
*
* function hypot(x: number, y: number) {
* ++calls;
* return Math.hypot(x, y);
* }
*
* function resolver(x: number, y: number) {
* return 4093*y + x; // a hash
* }
*
* var fn = xfunction.memoize(hypot, resolver);
* fn(3, 4);
* // → 5
* fn(6, 8);
* // → 10
* fn(5, 12);
* // → 13
* fn(3, 4);
* // → 5
* fn(6, 8);
* // → 10
* fn(5, 12);
* // → 13
* calls;
* // → 3
* ```
*/ export function memoize(x, fr = null, cache = null) {
fr = fr || IDENTITY;
cache = cache || new Map();
return (...args)=>{
const k = fr(...args);
if (cache.has(k)) return cache.get(k);
const v = x(...args);
cache.set(k, v);
return v;
};
}
// - https://www.npmjs.com/package/memoizee
// - https://www.npmjs.com/package/memoizerific
//#endregion
//#region PARAMETER MANIPULATION
/**
* Generate a parameter-reversed version of a function.
* @param x a function
* @returns (p, q, ...) => x(..., q, p)
* @example
* ```javascript
* function divide(x, y) {
* return x/y;
* }
*
* var fn = xfunction.reverse(divide);
* fn(2, 4);
* // → 2
* fn(2, 6);
* // → 3
* fn(2, 8);
* // → 4
*
*
* var array = [1];
*
* function push(...args) {
* array.push(...args);
* }
*
* var fn = xfunction.reverse(push);
* fn(2, 3, 4); // push(2, 3, 4) in reverse order
* array;
* // → [1, 4, 3, 2]
* ```
*/ export function reverse(x) {
return (...args)=>x(...args.reverse());
}
export { reverse as flip };
/**
* Generate a (first) parameter-spreaded version of a function.
* @param x a function
* @returns (p, q, ...) => x([p, q, ...])
* @example
* ```javascript
* function sum(x: number[]) {
* var a = 0;
* for (var v of x)
* a += v;
* return a;
* }
*
* var fn = xfunction.spread(sum);
* fn(1, 2, 3); // sum([1, 2, 3])
* // → 6
*
*
* var array = [1];
*
* function concat(x: number[]) {
* return array.concat(x);
* }
*
* var fn = xfunction.spread(concat);
* fn(2, 3, 4); // concat([2, 3, 4])
* // → [1, 2, 3, 4]
* ```
*/ export function spread(x) {
return (...args)=>x(args);
}
/**
* Generate a (first) parameter-collapsed version of a function.
* @param x a function
* @returns ([p, q, ...]) => x(p, q, ...)
* @example
* ```javascript
* var fn = xfunction.unspread(Math.min);
* fn([7, 4, 9]); // Math.min(7, 4, 9)
* // → 4
*
* var fn = xfunction.unspread((x, i, I) => x.slice(i, I));
* fn([[1, 2, 3, 4], 2]); // [1, 2, 3, 4].slice(2)
* // → [3, 4]
* ```
*/ export function unspread(x) {
return (args)=>x(...args);
}
/**
* Attach prefix arguments to leftmost parameters of a function.
* @param x a function
* @param prefix prefix arguments
* @returns (...args) => x(...prefix, ...args)
* @example
* ```javascript
* var fn = xfunction.attach(Math.min, 100);
* fn(180, 130); // Math.min(100, 180, 130)
* // → 100
*
* var array = [1];
* var fn = xfunction.attach((...vs) => array.push(...vs), 10, 10);
* fn(1, 2, 3); // array.push(10, 10, 1, 2, 3)
* array;
* // → [1, 10, 10, 1, 2, 3]
* ```
*/ export function attach(x, ...prefix) {
return (...args)=>x(...prefix, ...args);
}
export { attach as partial };
/**
* Attach suffix arguments to rightmost parameters of a function.
* @param x a function
* @param suffix suffix arguments
* @returns (...args) => x(...args, ...suffix)
* @example
* ```javascript
* var fn = xfunction.attachRight(Math.min, 100);
* fn(180, 130); // Math.min(180, 130, 100)
* // → 100
*
* var array = [1];
* var fn = xfunction.attachRight((...vs) => array.push(...vs), 10, 10);
* fn(1, 2, 3); // array.push(1, 2, 3, 10, 10)
* array;
* // → [1, 1, 2, 3, 10, 10]
* ```
*/ export function attachRight(x, ...suffix) {
return (...args)=>x(...args, ...suffix);
}
export { attachRight as partialRight };
//#endregion
//#region FUNCTIONAL BEHAVIOUR
/**
* Compose functions together, in applicative order.
* @param xs functions (f, g)
* @returns (f o g), or f(g(x))
* @example
* ```javascript
* var fn = xfunction.compose(Math.sqrt, Math.abs);
* fn(-64); // Math.sqrt(Math.abs(-64))
* // → 8
*
* var fn = xfunction.compose(Math.sqrt, Math.min);
* fn(22, 9); // Math.sqrt(Math.min(22, 9))
* // → 3
* ```
*/ export function compose(...xs) {
return composeRight(...xs.reverse());
}
// - https://en.wikipedia.org/wiki/Function_composition
// - http://learnyouahaskell.com/higher-order-functions
// - https://www.npmjs.com/package/compose-function
/**
* Compose functions together, such that result is piped forward.
* @param xs functions (f, g)
* @returns (f ▷ g), or g(f(x))
* @example
* ```javascript
* var fn = xfunction.composeRight(Math.abs, Math.sqrt);
* fn(-64); // Math.sqrt(Math.abs(-64))
* // → 8
*
* var fn = xfunction.composeRight(Math.min, Math.sqrt);
* fn(22, 9); // Math.sqrt(Math.min(22, 9))
* // → 3
* ```
*/ export function composeRight(...xs) {
return (...args)=>{
if (xs.length === 0) return;
let a = xs[0](...args);
for(let i = 1, I = xs.length; i < I; i++)a = xs[i](a);
return a;
};
}
// - https://stackoverflow.com/questions/1457140/haskell-composition-vs-fs-pipe-forward-operator
// - https://www.npmjs.com/package/chain-function
/**
* Generate curried version of a function.
* @param x a function
* @param n number of parameters [all]
* @returns (p)(q)(...) => x(p, q, ...)
* @example
* ```javascript
* var sub = (x: number, y: number) => x - y;
* var fn = xfunction.curry(sub);
* fn(2)(3); // sub(2, 3)
* // → -1
*
* var fn = xfunction.curry(Math.min, 3);
* fn(5)(8)(3); // Math.min(5, 8, 3)
* // → 3
* ```
*/ export function curry(x, n = x.length) {
return (...args)=>{
if (args.length >= n) return x(...args);
else return curry((...rest)=>x(...args, ...rest), n - args.length);
};
}
// - https://www.npmjs.com/package/@spudly/curry
/**
* Generate right-curried version of a function.
* @param x a function
* @param n number of parameters [all]
* @returns (p)(q)(...) => x(..., q, p)
* @example
* ```javascript
* var sub = (x: number, y: number) => x - y;
* var fn = xfunction.curryRight(sub);
* fn(2)(3); // sub(3, 2)
* // → 1
*
* var array = [1];
* var push2 = (x: number, y: number) => array.push(x, y);
* var fn = xfunction.curryRight(push2, 2);
* fn(2)(3); // push2(3, 2)
* array;
* // → [1, 3, 2]
* ```
*/ export function curryRight(x, n = x.length) {
return curry(reverse(x), n);
}
/**
* Generate deferred version of a function, that executes after the current stack has cleared.
* @param x a function
* @returns (...args) => invocation control
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.defer(() => ++count);
* fn();
* fn();
* // `count` incremented after 0s
* // `count` incremented after 0s
* ```
*/ export function defer(x) {
return (...args)=>{
let h = setTimeout(flush, 0);
function clear() {
clearTimeout(h);
h = 0;
}
function flush() {
x(...args);
clear();
}
return {
clear,
flush
};
};
}
/**
* Generate delayed version of a function.
* @param x a function
* @param t delay time (ms)
* @returns (...args) => invocation control
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.delay(() => ++count, 500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* // `count` incremented after 0.5s
* // `count` incremented after 1.5s
*
*
* var count = 0;
* var fn = xfunction.delay(() => ++count, 500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* setTimeout(fn, 3000);
* // `count` incremented after 0.5s
* // `count` incremented after 1.5s
* // `count` incremented after 2.5s
* // `count` incremented after 3.5s
* ```
*/ export function delay(x, t) {
return (...args)=>{
let h = setTimeout(flush, t);
function clear() {
clearTimeout(h);
h = 0;
}
function flush() {
x(...args);
clear();
}
return {
clear,
flush
};
};
}
//#endregion
//#region RATE CONTROL (COUNT)
/**
* Generate restricted-use version of a function.
* @param x a function
* @param start usable from
* @param end usable till (excluding) [-1 ⇒ end]
* @returns (...args) => x(...args) from [start:end] calls
* @example
* ```javascript
* var sum = 0;
* var add = (x: number) => sum += x;
* var fn = xfunction.restrict(add, 0, 4);
* for (var i=0; i<10; ++i)
* fn(i);
* sum; // 0 + 1 + 2 + 3
* // → 6
*
*
* var sum = 0;
* var add = (x: number) => sum += x;
* var fn = xfunction.restrict(add, 4, 8);
* for (var i=0; i<10; ++i)
* fn(i);
* sum; // 4 + 5 + 6 + 7
* // → 22
* ```
*/ export function restrict(x, start, end = -1) {
let i = -1;
return (...args)=>{
if (++i < start === (i < end || end < 0)) return;
return x(...args);
};
}
// - https://www.npmjs.com/package/one-time
// - https://www.npmjs.com/package/onetime
// - https://www.npmjs.com/package/once
// - https://lodash.com/docs/4.17.15#after
// - https://lodash.com/docs/4.17.15#before
/**
* Restrict a function to be used only once.
* @param x a function
* @returns (...args) => x(...args) from [0:1] calls
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.restrictOnce(x => ++count);
* for (var i=0; i<10; ++i)
* fn(i);
* count;
* // → 1
* ```
*/ export function restrictOnce(x) {
return restrict(x, 0, 1);
}
export { restrictOnce as once };
// - https://www.npmjs.com/package/one-time
// - https://www.npmjs.com/package/onetime
// - https://www.npmjs.com/package/once
/**
* Restrict a function to be used only upto a certain number of calls.
* @param x a function
* @param n number of calls upto which it is usable
* @returns (...args) => x(...args) from [0:n] calls
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.restrictBefore(x => ++count, 3);
* for (var i=0; i<10; ++i)
* fn(i);
* count;
* // → 3
* ```
*/ export function restrictBefore(x, n) {
return restrict(x, 0, n);
}
export { restrictBefore as before };
// - https://lodash.com/docs/4.17.15#before
/**
* Restrict a function to be used only after a certain number of calls.
* @param x a function
* @param n number of calls after which it is usable
* @returns (...args) => x(...args) from [n:end] calls
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.restrictAfter(x => ++count, 3);
* for (var i=0; i<10; ++i)
* fn(i);
* count;
* // → 7
* ```
*/ export function restrictAfter(x, n) {
return restrict(x, n);
}
export { restrictAfter as after };
// - https://lodash.com/docs/4.17.15#after
//#endregion
//#region RATE CONTROL (TIME)
/**
* Generate debounced version of a function.
* @param x a function
* @param t delay time (ms)
* @param T max delay time [-1 ⇒ none]
* @returns (...args) => invocation control
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.debounce(() => ++count, 1500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* setTimeout(fn, 4000);
* setTimeout(fn, 5000);
* // `count` incremented after 3.5s
* // `count` incremented after 6.5s
*
*
* var count = 0;
* var fn = xfunction.debounce(() => ++count, 1500);
* setTimeout(fn, 0);
* setTimeout(fn, 500);
* setTimeout(fn, 1000);
* setTimeout(fn, 1500);
* setTimeout(fn, 2000);
* setTimeout(fn, 4000);
* setTimeout(fn, 4500);
* setTimeout(fn, 5000);
* // `count` incremented after 3.5s
* // `count` incremented after 6.5s
*
*
* var count = 0;
* var fn = xfunction.debounce(() => ++count, 1500, 3500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* setTimeout(fn, 3000);
* setTimeout(fn, 4000);
* setTimeout(fn, 6000);
* // `count` incremented after 3.5s
* // `count` incremented after 5.5s
* // `count` incremented after 7.5s
* ```
*/ export function debounce(x, t, T = -1) {
let savedArgs;
let h = 0, H = 0;
function clear() {
clearTimeout(h);
clearTimeout(H);
h = H = 0;
}
function flush() {
x(...savedArgs);
clear();
}
;
return (...args)=>{
savedArgs = args;
if (T >= 0) H = H || setTimeout(flush, T);
if (T < 0 || t < T) {
clearTimeout(h);
h = setTimeout(flush, t);
}
return {
clear,
flush
};
};
}
// - https://github.com/lodash/lodash/blob/4.8.0-npm/debounce.js
// - https://github.com/jashkenas/underscore/commit/9e3e067f5025dbe5e93ed784f93b233882ca0ffe
// - https://css-tricks.com/debouncing-throttling-explained-examples/
// - https://www.npmjs.com/package/debounce
/**
* Generate leading-edge debounced version of a function.
* @param x a function
* @param t delay time (ms)
* @param T max delay time [-1 ⇒ none]
* @returns (...args) => invocation control
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.debounceEarly(() => ++count, 1500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* setTimeout(fn, 4000);
* setTimeout(fn, 5000);
* // `count` incremented after 0s
* // `count` incremented after 4s
*
*
* var count = 0;
* var fn = xfunction.debounceEarly(() => ++count, 1500);
* setTimeout(fn, 0);
* setTimeout(fn, 500);
* setTimeout(fn, 1000);
* setTimeout(fn, 1500);
* setTimeout(fn, 2000);
* setTimeout(fn, 4000);
* setTimeout(fn, 4500);
* setTimeout(fn, 5000);
* // `count` incremented after 0s
* // `count` incremented after 4s
*
*
* var count = 0;
* var fn = xfunction.debounceEarly(() => ++count, 1500, 3500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* setTimeout(fn, 3000);
* setTimeout(fn, 4000);
* setTimeout(fn, 6000);
* // `count` incremented after 0s
* // `count` incremented after 4s
* // `count` incremented after 6s
* ```
*/ export function debounceEarly(x, t, T = -1) {
let h = 0, H = 0;
function clear() {
h = H = 0;
}
function flush() {
clear();
}
return (...args)=>{
if (!h && !H) x(...args);
if (T >= 0) H = H || setTimeout(flush, T);
if (T < 0 || t < T) {
clearTimeout(h);
h = setTimeout(flush, t);
}
return {
clear,
flush
};
};
}
// - https://github.com/lodash/lodash/blob/4.8.0-npm/debounce.js
// - https://github.com/jashkenas/underscore/commit/9e3e067f5025dbe5e93ed784f93b233882ca0ffe
// - https://css-tricks.com/debouncing-throttling-explained-examples/
// - https://www.npmjs.com/package/debounce
/**
* Generate throttled version of a function.
* @param x a function
* @param t wait time (ms)
* @returns (...args) => invocation control
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.throttle(() => ++count, 2500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* // `count` incremented after 2.5s
*
*
* var count = 0;
* var fn = xfunction.throttle(() => ++count, 2500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* setTimeout(fn, 3000);
* setTimeout(fn, 4000);
* // `count` incremented after 2.5s
* // `count` incremented after 5.5s
* ```
*/ export function throttle(x, t) {
let savedArgs;
let h = 0;
function clear() {
h = 0;
}
function flush() {
x(...savedArgs);
clear();
}
return (...args)=>{
savedArgs = args;
h = h || setTimeout(flush, t);
return {
clear,
flush
};
};
}
// - https://www.npmjs.com/package/throttle-debounce
// - https://www.npmjs.com/package/throttleit
/**
* Generate leading-edge throttled version of a function.
* @param x a function
* @param t wait time (ms)
* @returns (...args) => invocation control
* @example
* ```javascript
* var count = 0;
* var fn = xfunction.throttleEarly(() => ++count, 2500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* // `count` incremented after 0s
*
*
* var count = 0;
* var fn = xfunction.throttleEarly(() => ++count, 2500);
* setTimeout(fn, 0);
* setTimeout(fn, 1000);
* setTimeout(fn, 2000);
* setTimeout(fn, 3000);
* setTimeout(fn, 4000);
* // `count` incremented after 0s
* // `count` incremented after 3s
* ```
*/ export function throttleEarly(x, t) {
let h = 0;
function clear() {
h = 0;
}
function flush() {
clear();
}
return (...args)=>{
if (!h) x(...args);
h = h || setTimeout(flush, t);
return {
clear,
flush
};
};
} // - https://www.npmjs.com/package/throttle-debounce
// - https://www.npmjs.com/package/throttleit
// TODO: Is a generator function better for this?
// function backoffRetryRec(x: Function, args: unknown[], err: unknown, n: number, N: number, t: number, T: number, tf: number): void {
// if (N>=0 && n>=N) throw err;
// if (T>=0 && t>=T) throw err;
// try { return x(...args, err); }
// catch(e) { setTimeout(() => backoffRetryRec(x, args, e, n+1, N, t*tf, T, tf), t); }
// }
//
// TODO: Generate exponential-backoff-retried version of a function.
// @param x a function
// @param N maximum retries (-1 ⇒ unlimited)
// @param t initial retry time (1 ms)
// @param T maximum retry time [-1 ⇒ none]
// @param tf retry time factor [2]
//
// function backoffRetry(x: Function, N: number, t: number, T: number=-1, tf: number=2): Function {
// return (...args: unknown[]) => backoffRetryRec(x, args, null, 0, N, t, T, tf);
// }
// - TODO
//#endregion
//#endregion
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/extra-function/extra-function/index.ts"],"sourcesContent":["//#region TYPES\n/**\n * unknown function type.\n * @params args arguments\n * @returns unknown value\n */\nexport type Function = (...args: unknown[]) => unknown;\n//#endregion\n\n\n\n\n//#region CONSTANTS\n/**\n * Do nothing.\n * @param _args arguments (ignored)\n * @example\n * ```javascript\n * xfunction.NOOP(1, 2);\n * // → undefined\n *\n * xfunction.NOOP('a', 'b');\n * // → undefined\n * ```\n */\nexport function NOOP(..._args: unknown[]): void {}\n// - https://lodash.com/docs/4.17.15#noop\n\n\n/**\n * Return false.\n * @param _args arguments (ignored)\n * @returns false.\n * @example\n * ```javascript\n * xfunction.FALSE();\n * // → false\n * ```\n */\nexport function FALSE(..._args: unknown[]): false {\n  return false;\n}\n// - https://www.npmjs.com/package/boolbase\n\n\n/**\n * Return true.\n * @param _args arguments (ignored)\n * @returns true.\n * @example\n * ```javascript\n * xfunction.TRUE();\n * // → true\n * ```\n */\nexport function TRUE(..._args: unknown[]): true {\n  return true;\n}\n// - https://www.npmjs.com/package/boolbase\n\n\n/**\n * Return the same (first) value.\n * @param v a value\n * @returns v\n * @example\n * ```javascript\n * xfunction.IDENTITY(1);\n * // → 1\n *\n * xfunction.IDENTITY('a');\n * // → 'a'\n * ```\n */\nexport function IDENTITY<T>(v: T): T {\n  return v;\n}\n\n\n/**\n * Compare two values.\n * @param a a value\n * @param b another value\n * @returns a<b: -1, a=b: 0, a>b: 1\n * @example\n * ```javascript\n * xfunction.COMPARE(1, 2);\n * // → -1\n *\n * xfunction.COMPARE(2, 1);\n * // → 1\n *\n * xfunction.COMPARE(1, 1);\n * // → 0\n */\nexport function COMPARE<T>(a: T, b: T): number {\n  return a<b? -1 : (a>b? 1 : 0);\n}\n\n\n/**\n * Return the arguments passed as a array.\n * @param args arguments\n * @returns [...args]\n * @example\n * ```javascript\n * xfunction.ARGUMENTS(1, 2);\n * // → [1, 2]\n *\n * xfunction.ARGUMENTS('a', 'b');\n * // → ['a', 'b']\n * ```\n */\nexport function ARGUMENTS(...args: unknown[]): unknown[] {\n  return args;\n}\n//#endregion\n\n\n\n\n//#region METHODS (BUILTIN)\n//#region ABOUT\n/**\n * Get the name of a function.\n * @param x a function\n * @returns name\n * @example\n * ```javascript\n * import {delay, debounce} from \"jsr:@nodef/extra-function\";\n *\n * xfunction.name(delay);\n * // → 'delay'\n *\n * xfunction.name(debounce);\n * // → 'debounce'\n * ```\n */\nexport function name(x: Function): string {\n  return x.name;\n}\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name\n// - https://www.npmjs.com/package/fn-name\n\n\n/**\n * Get the number of parameters of a function.\n * @param x a function\n * @returns |[p, q, ...]| | x(p, q, ...)\n * @example\n * ```javascript\n * xfunction.length(() => 0);\n * // → 0\n *\n * xfunction.length((x, y) => 0);\n * // → 2\n * ```\n */\nexport function length(x: Function): number {\n  return x.length;\n}\nexport {length as arity};\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length\n//#endregion\n\n\n\n\n//#region BINDING\n/**\n * Bind this-object, and optional prefix arguments to a function.\n * @param x a function\n * @param ths this object to bind\n * @param prefix prefix arguments\n * @returns (...args) => this.x(...prefix, ...args)\n * @example\n * ```javascript\n * var array  = [1];\n * var fn = xfunction.bind(Array.prototype.push, array);\n * fn(2, 3, 4);  // push(2, 3, 4)\n * array;\n * // → [1, 2, 3, 4]\n *\n * var array  = [1, 2, 3, 4];\n * var fn = xfunction.bind(Array.prototype.splice, array, 1);\n * fn(2);  // splice(1, 2)\n * array;\n * // → [1, 4]\n * ```\n */\nexport function bind(x: Function, ths: unknown, ...prefix: unknown[]): Function {\n  return x.bind(ths, ...prefix);\n}\n// - https://underscorejs.org/#bind\n// - https://lodash.com/docs/4.17.15#bind\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind\n//#endregion\n\n\n\n\n//#region INVOCATION\n/**\n * Invoke a function with specified this-object, and arguments provided individually.\n * @param x a function\n * @param ths this object to invoke with\n * @param args arguments\n * @returns this.x(...args)\n * @example\n * ```javascript\n * var array = [1];\n * xfunction.call(Array.prototype.push, array, 2, 3, 4);  // push(2, 3, 4)\n * array;\n * // → [1, 2, 3, 4]\n *\n * var array = [1, 2, 3, 4];\n * xfunction.call(Array.prototype.splice, array, 1, 2);  // splice(1, 2)\n * array;\n * // → [1, 4]\n * ```\n */\nexport function call(x: Function, ths: unknown=null, ...args: unknown[]): unknown {\n  return x.call(ths, ...args);\n}\n\n\n/**\n * Invoke a function with specified this-object, and arguments provided as an array.\n * @param x a function\n * @param ths this object to invoke with\n * @param args arguments array\n * @returns this.x(...args)\n * @example\n * ```javascript\n * var array = [1];\n * xfunction.apply(Array.prototype.push, array, [2, 3, 4]);  // push(2, 3, 4)\n * array;\n * // → [1, 2, 3, 4]\n *\n * var array = [1, 2, 3, 4];\n * xfunction.apply(Array.prototype.splice, array, [1, 2]);  // splice(1, 2)\n * array;\n * // → [1, 4]\n * ```\n */\nexport function apply(x: Function, ths: unknown=null, args: unknown[]): unknown {\n  return x.apply(ths, args);\n}\n//#endregion\n//#endregion\n\n\n\n\n//#region METHODS (CUSTOM)\n//#region ABOUT\n/**\n * Check if value is a function.\n * @param v a value\n * @returns is function?\n * @example\n * ```javascript\n * xfunction.is(Object.keys);\n * // → true\n *\n * xfunction.is(() => 0);\n * // → true\n *\n * xfunction.is(async () => 0);\n * // → true\n *\n * xfunction.is(0);\n * // → false\n * ```\n */\nexport function is(v: unknown): v is Function {\n  return typeof v===\"function\";\n}\n// - https://www.npmjs.com/package/is-function\n\n\n/**\n * Check if value is an async function.\n * @param v a value\n * @returns is async function?\n * @example\n * ```javascript\n * xfunction.isAsync(async () => 0);\n * // → true\n *\n * xfunction.isAsync(() => 0);\n * // → false\n * ```\n */\nexport function isAsync(v: unknown): boolean {\n  const AsyncFunction = (async function () {}).constructor;\n  return v instanceof AsyncFunction;\n}\n// - https://www.npmjs.com/package/is-async-function\n// - https://www.npmjs.com/package/is-callback-function\n// - https://davidwalsh.name/javascript-detect-async-function\n// - https://stackoverflow.com/questions/38508420/how-to-know-if-a-function-is-async\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction\n\n\n/**\n * Check if value is a generator function.\n * @param v a value\n * @returns is generator function?\n * @example\n * ```javascript\n * function* naturalNumbers() {\n *   for (var i=0;; ++i)\n *     yield i;\n * }\n *\n * xfunction.isGenerator(naturalNumbers);\n * // → true\n *\n * xfunction.isGenerator(() => 0);\n * // → false\n * ```\n */\nexport function isGenerator(v: unknown): v is GeneratorFunction {\n  const GeneratorFunction = (function* () {}).constructor;\n  return v instanceof GeneratorFunction;\n}\n// - https://www.npmjs.com/package/is-generator\n// - https://www.npmjs.com/package/is-generator-fn\n// - https://www.npmjs.com/package/is-generator-function\n// - https://stackoverflow.com/questions/16754956/check-if-function-is-a-generator\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction\n//#endregion\n\n\n\n\n//#region CONTEXT\n/**\n * Contextify a function by accepting the first parameter as this-object.\n * @param x a function\n * @returns (...args) => x(this, ...args)\n * @example\n * ```javascript\n * function count(x, value) {\n *   var a = 0;\n *   for (var v of x)\n *     if (v===value) ++a;\n *   return a;\n * }\n *\n * var fn = xfunction.contextify(count);\n *\n * fn.call([6, 3, 4, 3], 3);\n * // → 2\n *\n * fn.call([6, 1, 4, 3], 3);\n * // → 1\n * ```\n */\nexport function contextify(x: Function): Function {\n  return function(this: unknown, ...args: unknown[]) { return x(this, ...args); };\n}\n\n\n/**\n * Decontextify a function by accepting this-object as the first argument.\n * @param x a function\n * @returns (this, ...args) => this.x(...args)\n * @example\n * ```javascript\n * function count(value) {\n *   var a = 0;\n *   for (var v of this)\n *     if (v===value) ++a;\n *   return a;\n * }\n *\n * var fn = xfunction.decontextify(count);\n *\n * fn([6, 3, 4, 3], 3);\n * // → 2\n *\n * fn([6, 1, 4, 3], 3);\n * // → 1\n * ```\n */\nexport function decontextify(x: Function): Function {\n  return (ths: unknown=null, ...args: unknown[]) => x.call(ths, ...args);\n}\n//#endregion\n\n\n\n\n//#region RESULT MANIPULATION\n/**\n * Generate a result-negated version of a function.\n * @param x a function\n * @returns (...args) => !x(...args)\n * @example\n * ```javascript\n * var fn = xfunction.negate(isFinite);\n * fn(Infinity)\n * // → true\n * fn(1)\n * // → false\n *\n * var fn = xfunction.negate(isNaN);\n * fn(1);\n * // → true\n * fn(NaN);\n * // → false\n * ```\n */\nexport function negate(x: Function): Function {\n  return (...args: unknown[]) => !x(...args);\n}\n//#endregion\n\n\n\n\n//#region RESULT CACHING\n/**\n * Resolve arguments into a unique key.\n * @param args arguments\n * @returns unique key\n */\nexport type Resolver = (...args: unknown[]) => unknown;\n\n\n/**\n * Generate result-cached version of a function.\n * @param x a function\n * @param fr resolver ((...args) => unique key) [IDENTITY]\n * @param cache result cache [Map()]\n * @example\n * ```javascript\n * var calls = 0;\n *\n * function factorialRec(n: number) {\n *   if (n<=1) return 1;\n *   return n * factorialRec(n-1);\n * }\n *\n * function factorial(n: number) {\n *   ++calls;\n *   return factorialRec(n);\n * }\n *\n * var fn = xfunction.memoize(factorial);\n * fn(3);\n * // → 6\n * fn(4);\n * // → 24\n * fn(5);\n * // → 120\n * fn(3);\n * // → 6\n * fn(4);\n * // → 24\n * fn(5);\n * // → 120\n * calls;\n * // → 3\n *\n *\n * var calls = 0;\n *\n * function hypot(x: number, y: number) {\n *   ++calls;\n *   return Math.hypot(x, y);\n * }\n *\n * function resolver(x: number, y: number) {\n *   return 4093*y + x;  // a hash\n * }\n *\n * var fn = xfunction.memoize(hypot, resolver);\n * fn(3,  4);\n * // → 5\n * fn(6,  8);\n * // → 10\n * fn(5, 12);\n * // → 13\n * fn(3,  4);\n * // → 5\n * fn(6,  8);\n * // → 10\n * fn(5, 12);\n * // → 13\n * calls;\n * // → 3\n * ```\n */\nexport function memoize(x: Function, fr: Resolver | null=null, cache: Map<unknown, unknown> | null=null): Function {\n  fr    = fr || IDENTITY;\n  cache = cache || new Map();\n  return (...args: unknown[]) => {\n    const k = fr(...args);\n    if (cache.has(k)) return cache.get(k);\n    const v = x(...args);\n    cache.set(k, v);\n    return v;\n  };\n}\n// - https://www.npmjs.com/package/memoizee\n// - https://www.npmjs.com/package/memoizerific\n//#endregion\n\n\n\n\n//#region PARAMETER MANIPULATION\n/**\n * Generate a parameter-reversed version of a function.\n * @param x a function\n * @returns (p, q, ...) => x(..., q, p)\n * @example\n * ```javascript\n * function divide(x, y) {\n *   return x/y;\n * }\n *\n * var fn = xfunction.reverse(divide);\n * fn(2, 4);\n * // → 2\n * fn(2, 6);\n * // → 3\n * fn(2, 8);\n * // → 4\n *\n *\n * var array = [1];\n *\n * function push(...args) {\n *   array.push(...args);\n * }\n *\n * var fn = xfunction.reverse(push);\n * fn(2, 3, 4);  // push(2, 3, 4) in reverse order\n * array;\n * // → [1, 4, 3, 2]\n * ```\n */\nexport function reverse(x: Function): Function {\n  return (...args: unknown[]) => x(...args.reverse());\n}\nexport {reverse as flip};\n\n\n/**\n * Generate a (first) parameter-spreaded version of a function.\n * @param x a function\n * @returns (p, q, ...) => x([p, q, ...])\n * @example\n * ```javascript\n * function sum(x: number[]) {\n *   var a = 0;\n *   for (var v of x)\n *     a += v;\n *   return a;\n * }\n *\n * var fn = xfunction.spread(sum);\n * fn(1, 2, 3);  // sum([1, 2, 3])\n * // → 6\n *\n *\n * var array = [1];\n *\n * function concat(x: number[]) {\n *   return array.concat(x);\n * }\n *\n * var fn = xfunction.spread(concat);\n * fn(2, 3, 4);  // concat([2, 3, 4])\n * // → [1, 2, 3, 4]\n * ```\n */\nexport function spread(x: Function): Function {\n  return (...args: unknown[]) => x(args);\n}\n\n\n/**\n * Generate a (first) parameter-collapsed version of a function.\n * @param x a function\n * @returns ([p, q, ...]) => x(p, q, ...)\n * @example\n * ```javascript\n * var fn = xfunction.unspread(Math.min);\n * fn([7, 4, 9]);  // Math.min(7, 4, 9)\n * // → 4\n *\n * var fn = xfunction.unspread((x, i, I) => x.slice(i, I));\n * fn([[1, 2, 3, 4], 2]);  // [1, 2, 3, 4].slice(2)\n * // → [3, 4]\n * ```\n */\nexport function unspread(x: Function): Function {\n  return (args: unknown) => x(...(args as unknown[]));\n}\n\n\n/**\n * Attach prefix arguments to leftmost parameters of a function.\n * @param x a function\n * @param prefix prefix arguments\n * @returns (...args) => x(...prefix, ...args)\n * @example\n * ```javascript\n * var fn = xfunction.attach(Math.min, 100);\n * fn(180, 130);  // Math.min(100, 180, 130)\n * // → 100\n *\n * var array = [1];\n * var fn = xfunction.attach((...vs) => array.push(...vs), 10, 10);\n * fn(1, 2, 3);  // array.push(10, 10, 1, 2, 3)\n * array;\n * // → [1, 10, 10, 1, 2, 3]\n * ```\n */\nexport function attach(x: Function, ...prefix: unknown[]): Function {\n  return (...args: unknown[]) => x(...prefix, ...args);\n}\nexport {attach as partial};\n\n\n/**\n * Attach suffix arguments to rightmost parameters of a function.\n * @param x a function\n * @param suffix suffix arguments\n * @returns (...args) => x(...args, ...suffix)\n * @example\n * ```javascript\n * var fn = xfunction.attachRight(Math.min, 100);\n * fn(180, 130);  // Math.min(180, 130, 100)\n * // → 100\n *\n * var array = [1];\n * var fn = xfunction.attachRight((...vs) => array.push(...vs), 10, 10);\n * fn(1, 2, 3);  // array.push(1, 2, 3, 10, 10)\n * array;\n * // → [1, 1, 2, 3, 10, 10]\n * ```\n */\nexport function attachRight(x: Function, ...suffix: unknown[]): Function {\n  return (...args: unknown[]) => x(...args, ...suffix);\n}\nexport {attachRight as partialRight};\n//#endregion\n\n\n\n\n//#region FUNCTIONAL BEHAVIOUR\n/**\n * Compose functions together, in applicative order.\n * @param xs functions (f, g)\n * @returns (f o g), or f(g(x))\n * @example\n * ```javascript\n * var fn = xfunction.compose(Math.sqrt, Math.abs);\n * fn(-64);  // Math.sqrt(Math.abs(-64))\n * // → 8\n *\n * var fn = xfunction.compose(Math.sqrt, Math.min);\n * fn(22, 9);  // Math.sqrt(Math.min(22, 9))\n * // → 3\n * ```\n */\nexport function compose(...xs: Function[]): Function {\n  return composeRight(...xs.reverse());\n}\n// - https://en.wikipedia.org/wiki/Function_composition\n// - http://learnyouahaskell.com/higher-order-functions\n// - https://www.npmjs.com/package/compose-function\n\n\n/**\n * Compose functions together, such that result is piped forward.\n * @param xs functions (f, g)\n * @returns (f ▷ g), or g(f(x))\n * @example\n * ```javascript\n * var fn = xfunction.composeRight(Math.abs, Math.sqrt);\n * fn(-64);  // Math.sqrt(Math.abs(-64))\n * // → 8\n *\n * var fn = xfunction.composeRight(Math.min, Math.sqrt);\n * fn(22, 9);  // Math.sqrt(Math.min(22, 9))\n * // → 3\n * ```\n */\nexport function composeRight(...xs: Function[]): Function {\n  return (...args: unknown[]) => {\n    if (xs.length===0) return;\n    let a = xs[0](...args);\n    for (let i=1, I=xs.length; i<I; i++)\n      a = xs[i](a);\n    return a;\n  };\n}\n// - https://stackoverflow.com/questions/1457140/haskell-composition-vs-fs-pipe-forward-operator\n// - https://www.npmjs.com/package/chain-function\n\n\n/**\n * Generate curried version of a function.\n * @param x a function\n * @param n number of parameters [all]\n * @returns (p)(q)(...) => x(p, q, ...)\n * @example\n * ```javascript\n * var sub = (x: number, y: number) => x - y;\n * var fn  = xfunction.curry(sub);\n * fn(2)(3);  // sub(2, 3)\n * // → -1\n *\n * var fn  = xfunction.curry(Math.min, 3);\n * fn(5)(8)(3);  // Math.min(5, 8, 3)\n * // → 3\n * ```\n */\nexport function curry(x: Function, n: number=x.length): Function {\n  return (...args: unknown[]) => {\n    if (args.length>=n) return x(...args);\n    else return curry((...rest: unknown[]) => x(...args, ...rest), n-args.length);\n  };\n}\n// - https://www.npmjs.com/package/@spudly/curry\n\n\n/**\n * Generate right-curried version of a function.\n * @param x a function\n * @param n number of parameters [all]\n * @returns (p)(q)(...) => x(..., q, p)\n * @example\n * ```javascript\n * var sub = (x: number, y: number) => x - y;\n * var fn  = xfunction.curryRight(sub);\n * fn(2)(3);  // sub(3, 2)\n * // → 1\n *\n * var array = [1];\n * var push2 = (x: number, y: number) => array.push(x, y);\n * var fn  = xfunction.curryRight(push2, 2);\n * fn(2)(3);  // push2(3, 2)\n * array;\n * // → [1, 3, 2]\n * ```\n */\nexport function curryRight(x: Function, n: number=x.length): Function {\n  return curry(reverse(x), n);\n}\n// - https://www.npmjs.com/package/lodash.curryright\n//#endregion\n\n\n\n\n//#region TIME CONTROL\n/** Invocation control for time/rate-controlled functions. */\nexport interface InvocationControl {\n  /** Disable invoking of target function. */\n  clear: () => void;\n  /** Immediately invoke target function. */\n  flush: () => void;\n}\n\n\n/**\n * Generate deferred version of a function, that executes after the current stack has cleared.\n * @param x a function\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.defer(() => ++count);\n * fn();\n * fn();\n * // `count` incremented after 0s\n * // `count` incremented after 0s\n * ```\n */\nexport function defer(x: Function): Function {\n  return (...args: unknown[]): InvocationControl => {\n    let h: NodeJS.Timeout | number = setTimeout(flush, 0);\n    function clear() { clearTimeout(h as number); h = 0; }\n    function flush() { x(...args); clear(); }\n    return {clear, flush};\n  };\n}\n\n\n/**\n * Generate delayed version of a function.\n * @param x a function\n * @param t delay time (ms)\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.delay(() => ++count, 500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * // `count` incremented after 0.5s\n * // `count` incremented after 1.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.delay(() => ++count, 500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * // `count` incremented after 0.5s\n * // `count` incremented after 1.5s\n * // `count` incremented after 2.5s\n * // `count` incremented after 3.5s\n * ```\n */\nexport function delay(x: Function, t: number): Function {\n  return (...args: unknown[]): InvocationControl => {\n    let h: NodeJS.Timeout | number = setTimeout(flush, t);\n    function clear() { clearTimeout(h as number); h = 0; }\n    function flush() { x(...args); clear(); }\n    return {clear, flush};\n  }\n}\n//#endregion\n\n\n\n\n//#region RATE CONTROL (COUNT)\n/**\n * Generate restricted-use version of a function.\n * @param x a function\n * @param start usable from\n * @param end usable till (excluding) [-1 ⇒ end]\n * @returns (...args) => x(...args) from [start:end] calls\n * @example\n * ```javascript\n * var sum = 0;\n * var add = (x: number) => sum += x;\n * var fn  = xfunction.restrict(add, 0, 4);\n * for (var i=0; i<10; ++i)\n *   fn(i);\n * sum;  // 0 + 1 + 2 + 3\n * // → 6\n *\n *\n * var sum = 0;\n * var add = (x: number) => sum += x;\n * var fn  = xfunction.restrict(add, 4, 8);\n * for (var i=0; i<10; ++i)\n *   fn(i);\n * sum;  // 4 + 5 + 6 + 7\n * // → 22\n * ```\n */\nexport function restrict(x: Function, start: number, end: number=-1): Function {\n  let i = -1;\n  return (...args: unknown[]) => {\n    if ((++i<start)===(i<end || end<0)) return;\n    return x(...args);\n  };\n}\n// - https://www.npmjs.com/package/one-time\n// - https://www.npmjs.com/package/onetime\n// - https://www.npmjs.com/package/once\n// - https://lodash.com/docs/4.17.15#after\n// - https://lodash.com/docs/4.17.15#before\n\n\n/**\n * Restrict a function to be used only once.\n * @param x a function\n * @returns (...args) => x(...args) from [0:1] calls\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.restrictOnce(x => ++count);\n * for (var i=0; i<10; ++i)\n *   fn(i);\n * count;\n * // → 1\n * ```\n */\nexport function restrictOnce(x: Function): Function {\n  return restrict(x, 0, 1);\n}\nexport {restrictOnce as once};\n// - https://www.npmjs.com/package/one-time\n// - https://www.npmjs.com/package/onetime\n// - https://www.npmjs.com/package/once\n\n\n/**\n * Restrict a function to be used only upto a certain number of calls.\n * @param x a function\n * @param n number of calls upto which it is usable\n * @returns (...args) => x(...args) from [0:n] calls\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.restrictBefore(x => ++count, 3);\n * for (var i=0; i<10; ++i)\n *   fn(i);\n * count;\n * // → 3\n * ```\n */\nexport function restrictBefore(x: Function, n: number): Function {\n  return restrict(x, 0, n);\n}\nexport {restrictBefore as before};\n// - https://lodash.com/docs/4.17.15#before\n\n\n/**\n * Restrict a function to be used only after a certain number of calls.\n * @param x a function\n * @param n number of calls after which it is usable\n * @returns (...args) => x(...args) from [n:end] calls\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.restrictAfter(x => ++count, 3);\n * for (var i=0; i<10; ++i)\n *   fn(i);\n * count;\n * // → 7\n * ```\n */\nexport function restrictAfter(x: Function, n: number): Function {\n  return restrict(x, n);\n}\nexport {restrictAfter as after};\n// - https://lodash.com/docs/4.17.15#after\n//#endregion\n\n\n\n\n//#region RATE CONTROL (TIME)\n/**\n * Generate debounced version of a function.\n * @param x a function\n * @param t delay time (ms)\n * @param T max delay time [-1 ⇒ none]\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.debounce(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 5000);\n * // `count` incremented after 3.5s\n * // `count` incremented after 6.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounce(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 500);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 1500);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 4500);\n * setTimeout(fn, 5000);\n * // `count` incremented after 3.5s\n * // `count` incremented after 6.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounce(() => ++count, 1500, 3500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 6000);\n * // `count` incremented after 3.5s\n * // `count` incremented after 5.5s\n * // `count` incremented after 7.5s\n * ```\n */\nexport function debounce(x: Function, t: number, T: number=-1): Function {\n  let savedArgs: unknown[];\n  let h = 0 as NodeJS.Timeout | number, H = 0 as NodeJS.Timeout | number;\n  function clear() {\n    clearTimeout(h as number);\n    clearTimeout(H as number);\n    h = H = 0;\n  }\n  function flush() { x(...savedArgs); clear(); };\n  return (...args: unknown[]): InvocationControl => {\n    savedArgs = args;\n    if (T>=0)  H = H || setTimeout(flush, T);\n    if (T<0 || t<T) { clearTimeout(h as number); h = setTimeout(flush, t); }\n    return {clear, flush};\n  };\n}\n// - https://github.com/lodash/lodash/blob/4.8.0-npm/debounce.js\n// - https://github.com/jashkenas/underscore/commit/9e3e067f5025dbe5e93ed784f93b233882ca0ffe\n// - https://css-tricks.com/debouncing-throttling-explained-examples/\n// - https://www.npmjs.com/package/debounce\n\n\n/**\n * Generate leading-edge debounced version of a function.\n * @param x a function\n * @param t delay time (ms)\n * @param T max delay time [-1 ⇒ none]\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.debounceEarly(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 5000);\n * // `count` incremented after 0s\n * // `count` incremented after 4s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounceEarly(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 500);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 1500);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 4500);\n * setTimeout(fn, 5000);\n * // `count` incremented after 0s\n * // `count` incremented after 4s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounceEarly(() => ++count, 1500, 3500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 6000);\n * // `count` incremented after 0s\n * // `count` incremented after 4s\n * // `count` incremented after 6s\n * ```\n */\nexport function debounceEarly(x: Function, t: number, T: number=-1): Function {\n  let h = 0 as NodeJS.Timeout | number, H = 0 as NodeJS.Timeout | number;\n  function clear() { h = H = 0; }\n  function flush() { clear(); }\n  return (...args: unknown[]): InvocationControl => {\n    if (!h && !H) x(...args);\n    if (T>=0)  H = H || setTimeout(flush, T);\n    if (T<0 || t<T) { clearTimeout(h as number); h = setTimeout(flush, t); }\n    return {clear, flush};\n  };\n}\n// - https://github.com/lodash/lodash/blob/4.8.0-npm/debounce.js\n// - https://github.com/jashkenas/underscore/commit/9e3e067f5025dbe5e93ed784f93b233882ca0ffe\n// - https://css-tricks.com/debouncing-throttling-explained-examples/\n// - https://www.npmjs.com/package/debounce\n\n\n/**\n * Generate throttled version of a function.\n * @param x a function\n * @param t wait time (ms)\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.throttle(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * // `count` incremented after 2.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.throttle(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * // `count` incremented after 2.5s\n * // `count` incremented after 5.5s\n * ```\n */\nexport function throttle(x: Function, t: number): Function {\n  let savedArgs: unknown[];\n  let h = 0 as NodeJS.Timeout | number;\n  function clear() { h = 0; }\n  function flush() { x(...savedArgs); clear(); }\n  return (...args: unknown[]): InvocationControl => {\n    savedArgs = args;\n    h = h || setTimeout(flush, t);\n    return {clear, flush};\n  };\n}\n// - https://www.npmjs.com/package/throttle-debounce\n// - https://www.npmjs.com/package/throttleit\n\n\n/**\n * Generate leading-edge throttled version of a function.\n * @param x a function\n * @param t wait time (ms)\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.throttleEarly(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * // `count` incremented after 0s\n *\n *\n * var count = 0;\n * var fn = xfunction.throttleEarly(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * // `count` incremented after 0s\n * // `count` incremented after 3s\n * ```\n */\nexport function throttleEarly(x: Function, t: number): Function {\n  let h = 0 as NodeJS.Timeout | number;\n  function clear() { h = 0; }\n  function flush() { clear(); }\n  return (...args: unknown[]): InvocationControl => {\n    if (!h) x(...args);\n    h = h || setTimeout(flush, t);\n    return {clear, flush};\n  };\n}\n// - https://www.npmjs.com/package/throttle-debounce\n// - https://www.npmjs.com/package/throttleit\n\n\n// TODO: Is a generator function better for this?\n// function backoffRetryRec(x: Function, args: unknown[], err: unknown, n: number, N: number, t: number, T: number, tf: number): void {\n//   if (N>=0 && n>=N) throw err;\n//   if (T>=0 && t>=T) throw err;\n//   try { return x(...args, err); }\n//   catch(e) { setTimeout(() => backoffRetryRec(x, args, e, n+1, N, t*tf, T, tf), t); }\n// }\n\n//\n// TODO: Generate exponential-backoff-retried version of a function.\n// @param x a function\n// @param N maximum retries (-1 ⇒ unlimited)\n// @param t initial retry time (1 ms)\n// @param T maximum retry time [-1 ⇒ none]\n// @param tf retry time factor [2]\n//\n// function backoffRetry(x: Function, N: number, t: number, T: number=-1, tf: number=2): Function {\n//   return (...args: unknown[]) => backoffRetryRec(x, args, null, 0, N, t, T, tf);\n// }\n// - TODO\n//#endregion\n//#endregion\n"],"names":[],"mappings":"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"}