Returns the sum of two numbers.

import { add } from 'fkit'
add(1, 2) // 3

Determines whether all elements in a list satisfy a predicate function.

import { all, eq, gt } from 'fkit'

all(gt(1), [1, 2, 3]) // false
all(gt(1), [2, 3]) // true
all(gt(1), [3]) // true

all(eq('o'), 'foo') // false
all(eq('o'), 'oo') // true
all(eq('o'), 'o') // true

Returns a function that always returns the same value, regardless of the arguments.

import { always } from 'fkit'
always(1)() // 1

Returns the logical AND of two values.

import { and } from 'fkit'
and(true, true) // true
and(0, 1) // false
and('', 'foo') // false

Determines whether any elements in a list satisfy a predicate function.

import { any, eq, gt } from 'fkit'

any(gt(1), [1, 2, 3]) // true
any(gt(1), [1, 2]) // true
any(gt(1), [1]) // false

any(eq('o'), 'foo') // true
any(eq('o'), 'fo') // true
any(eq('o'), 'f') // false

Appends a value to a list.

import { append } from 'fkit'
append(3, [1, 2]) // [1, 2, 3]
append('o', 'fo') // 'foo'

Applies a function to a value.

import { apply } from 'fkit'
const sayHi = a => ['Hi', a, '!'].join(' ')
apply(sayHi, 'jane') // Hi Jane!

Applies a function to two values.

import { apply2 } from 'fkit'
const sayHi = (a, b) => ['Hi', a, b, '!'].join(' ')
apply2(sayHi, 'Jane', 'Appleseed') // Hi Jane Appleseed!

Applies a function to three values.

import { apply3 } from 'fkit'
const sayHi = (a, b, c) => ['Hi', a, b, c, '!'].join(' ')
apply3(sayHi, 'Ms', 'Jane', 'Appleseed') // Hi Ms Jane Appleseed!

Applies a method to a value.

import { applyMethod } from 'fkit'
const person = { sayHi: a => ['Hi', a, '!'].join(' ') }
applyMethod('sayHi', 'Jane', person) // Hi Jane!

Applies a method to two values.

import { applyMethod2 } from 'fkit'
const person = { sayHi: (a, b) => ['Hi', a, b, '!'].join(' ') }
applyMethod2('sayHi', 'Jane', 'Appleseed', person) // Hi Jane Appleseed!

Applies a method to three values.

import { applyMethod3 } from 'fkit'
const person = { sayHi: (a, b, c) => ['Hi', a, b, c, '!'].join(' ') }
applyMethod3('sayHi', 'Ms', 'Jane', 'Appleseed', person) // Hi Ms Jane Appleseed!

Applies a function to a value. This is similar to apply, however the order of the arguments is flipped.

import { applyRight } from 'fkit'
function sayHi (a) { return ['Hi', a, '!'].join(' ') }
applyRight('Jane', sayHi) // Hi Jane!

Creates a new array.

import { array } from 'fkit'
array(3) // [undefined, undefined, undefined]

Determines whether a number is between two numbers.

import { between } from 'fkit'
between(1, 3, 2) // true
between(1, 3, 4) // false

Converts a function of any arity to a binary function.

import { binary } from 'fkit'
function f (a, b) { ... }
const g = binary(f)
g(1, 2, 3) // f(1, 2)

Branches execution based on a predicate function.

If p(a) is true then f is applied to a, otherwise g is applied to a.

import { branch, gt } from 'fkit'
const big = a => a + ' is a big number'
const small = a => a + ' is a small number'
const f = branch(gt(10), big, small)
f(10) // small number
f(11) // big number

Calculates the Cartesian product of two lists.

import { cartesian } from 'fkit'
cartesian([1, 2], [3, 4]) // [[1, 3], [1, 4], [2, 3], [2, 4]]
cartesian('ab', 'cd') // [['a', 'c'], ['a', 'd'], ['b', 'c'], ['b', 'd']]

Chunks contiguous values in a list.

This is a special case of the chunkBy function where the values are compared using the strict equality === operator.

import { chunk } from 'fkit'
chunk([1, 2, 2, 3, 3, 3]) // [[1], [2, 2], [3, 3, 3]]
chunk('Mississippi') // ['M', 'i', 'ss', 'i', 'ss', 'i', 'pp', 'i']

Chunks contiguous values in a list using a comparator function.

The comparator function f compares two values, a and b. If the values are both considered to be in the same chunk, then the comparator function should return true. Otherwise it should return false.

import { chunkBy } from 'fkit'
chunkBy((a, b) => a === b, [1, 2, 2, 3, 3, 3]) // [[1], [2, 2], [3, 3, 3]]
chunkBy((a, b) => a === b, 'Mississippi') // ['M', 'i', 'ss', 'i', 'ss', 'i', 'pp', 'i']

Clamps a number between two values.

import { clamp } from 'fkit'
clamp(1, 3, 0) // 1
clamp(1, 3, 2) // 2
clamp(1, 3, 4) // 3

Compares two values using natural ordering.

This function compares two values, a and b. If a is greater than b, then it returns 1. If a is less than b, then it returns -1. If both values are equal, then it returns 0.

import { compare } from 'fkit'
compare(2, 1) // 1
compare(1, 2) // -1
compare(2, 2) // 0

Compares two values using natural ordering. The function f is applied to * the values before they are compared.

This function compares two values, f(a) and f(b). If f(a) is greater than f(b), then it returns 1. If f(a) is less than f(b), then it returns -1. If both values are equal, then it returns 0.

import { compare } from 'fkit'
compare(2, 1) // 1
compare(1, 2) // -1
compare(2, 2) // 0

Composes the given functions from right-to-left.

import { compose } from 'fkit'
compose(f, g, h)(a) // f(g(h(a)))

Concatenates multiple lists into a single list.

import { concat } from 'fkit'
concat([1], [2, 3], [4, 5, 6]) // [1, 2, 3, 4, 5, 6]
concat('f', 'oo', 'bar') // 'foobar'

Maps a function, that returns a list, over a list and concatenates the results.

import { concatMap } from 'fkit'
concatMap(a => [a, 0], [1, 2, 3]) // [1, 0, 2, 0, 3, 0]
concatMap(a => [a, '-'], 'foo') // 'f-o-o-'

Creates a copy of one or more objects.

Properties with the same key will take precedence from right to left. The copy will have the same prototype as the first object in the list.

import { copy } from 'fkit'
const person = { name: 'Jane', age: 20, city: 'Melbourne' }
copy(person, { name: 'Steve' }) // { name: 'Steve', age: 20, city: 'Melbourne' }

Curries the given function f.

Currying turns a function that takes multiple arguments into a function that can be applied to one or more values to give a partially applied function.

import { curry } from 'fkit'
const add = curry((a, b) => a + b)
const add2 = add(2)
add2(1) // 3

Decrements a number.

import { dec } from 'fkit'
dec(1) // 0

Calculates the difference of two lists.

This is a special case of the differenceBy function where the elements are compared using the strict equality === operator.

import { difference } from 'fkit'
difference([1, 2, 3], [2, 3, 4]) // [1]
difference('hello', 'world') // 'he'

Calculates the difference of two lists.

The comparator function f compares two elements, a and b. If the elements are considered to be equal, then the comparator function should return true. Otherwise it should return false.

import { differenceBy } from 'fkit'
differenceBy((a, b) => a === b, [1, 2, 3], [2, 3, 4]) // [1]
differenceBy((a, b) => a === b, 'hello', 'world') // 'he'

Returns the division of two numbers.

import { div } from 'fkit'
div(2, 10) // 5

Drops a number of elements from the start of a list.

import { drop } from 'fkit'
drop(2, [1, 2, 3]) // [3]
drop(2, 'foo') // 'o'

Drops elements from the start of a list using a predicate function.

import { dropWhile, lt, neq } from 'fkit'
dropWhile(lt(3), [1, 2, 3]) // [3]
dropWhile(neq(o), 'foo') // 'oo'

Determines if a value is present in a list.

import { elem } from 'fkit'

elem(0, [1, 2, 3]) // false
elem(1, [1, 2, 3]) // true

elem('a', 'foo') // false
elem('o', 'foo') // true

Gets the index of the first occurance of a value in a list.

import { elemIndex } from 'fkit'

elemIndex(0, [1, 2, 3]) // undefined
elemIndex(1, [1, 2, 3]) // 0

elemIndex('a', 'foo') // undefined
elemIndex('o', 'foo') // 1

Gets the indices of all occurances of a value in a list.

import { elemIndices } from 'fkit'

elemIndices(0, [1, 2, 3]) // []
elemIndices(1, [1, 2, 3]) // [0]

elemIndices('a', 'foo') // []
elemIndices('o', 'foo') // [1, 2]

Determines if a list is empty.

import { empty } from 'fkit'

empty([]) // true
empty([1, 2, 3]) // false

empty('') // true
empty('foo') // false

Determines whether a given list ends with a suffix.

import { endsWith } from 'fkit'
endsWith([3], [1, 2, 3]) // true
endsWith('o', 'foo') // true

Determines whether two values are equal.

import { eq } from 'fkit'
eq(1, 1) // true
eq(1, 2) // false

Determines whether the given values are equal. The function f is applied to the values before they are compared.

import { eqBy } from 'fkit'
eqBy(1, 1) // true
eqBy(1, 2) // false

Determines whether a number is even.

import { even } from 'fkit'
even(2) // true
even(1) // false

Filters a list using a predicate function.

import { eq, filter, gt } from 'fkit'
filter(gt(1), [1, 2, 3]) // [2, 3]
filter(eq('o'), 'foo') // 'oo'

Finds the first value in a list that satisfies a predicate function.

import { eq, find, gt } from 'fkit'

find(gt(1), []) // undefined
find(gt(1), [1, 2, 3]) // 2

find(eq('o'), '') // undefined
find(eq('o'), 'foo') // 'o'

Finds the index of the first occurance of a value in a list that satisfies a predicate function.

import { eq, findIndex, gt } from 'fkit'

findIndex(gt(1), []) // undefined
findIndex(gt(1), [1, 2, 3]) // 1

findIndex(eq('o'), '') // undefined
findIndex(eq('o'), 'foo') // 1

Finds the indices of all the values in a list that satisfy a predicate function.

import { eq, findIndices, gt } from 'fkit'

findIndices(gt(1), []) // []
findIndices(gt(1), [1, 2, 3]) // [1, 2]

findIndices(eq('o'), '') // []
findIndices(eq('o'), 'foo') // [1, 2]

Swaps the order of the arguments to a function.

import { flip } from 'fkit'
function f (a, b) { ... }
const g = flip(f)
g(1, 2) // f(2, 1)

Folds a list from left-to-right with a function.

import { fold } from 'fkit'
fold((a, b) => a.concat(b), [], [1, 2, 3]) // [1, 2, 3]
fold((a, b) => a.concat(b), '', 'foo') // 'foo'

Folds a list from right-to-left with a function.

import { foldRight } from 'fkit'
foldRight((b, a) => a.concat(b), [], [1, 2, 3]) // [3, 2, 1]
foldRight((b, a) => a.concat(b), '', 'foo') // 'oof'

Gets a property of an object using a key path.

import { get } from 'fkit'
const person = { name: 'Jane', age: 20, address: { city: 'Melbourne', country: 'Australia' } }
get('name', person) // 'Jane'
get('address.city', person) // 'Melbourne'

Groups values in a list using a grouping function.

The grouping function f is applied to each item in the list. It should return a value representing the group that each item belongs to.

It is also possible to group a list of objects using a key path, instead of a grouping function. The key path identifies the property to use when grouping the objects in the list.

import { groupBy } from 'fkit'
groupBy(Math.floor, [1.1, 2.2, 3.3]) // { '1': [1], '2': [2], '3': [3] }
groupBy('length', ['one', 'two', 'three']) // { '3': ['one', 'two'], '5': ['three'] }
groupBy('a.b', [{ a: { b: 'foo' } }, { a: { b: 'bar' } }]) // { 'foo': [{ a: { b: 'foo' } }], 'bar': [{ a: { b: 'bar' } }] }

Determines whether one number is greater than another.

import { gt } from 'fkit'
gt(1, 2) // true
gt(2, 1) // false

Determines whether one number is greater than or equal to another.

import { gte } from 'fkit'
gte(1, 2) // true
gte(2, 1) // false
gte(2, 2) // true

Determines whether an object has a property at a key path.

import { has } from 'fkit'
const person = { name: 'Jane', age: 20, address: { city: 'Melbourne', country: 'Australia' } }
has('name', person) // true
has('address.city', person) // true

Gets the first element in a list.

import { head } from 'fkit'
head([1, 2, 3]) // 1
head('foo') // 'f'

The identity function.

import { id } from 'fkit'
id(1) // 1

Increments a number.

import { inc } from 'fkit'
inc(1) // 2

Gets the elements before the last element in a list.

import { init } from 'fkit'
init([1, 2, 3]) // [1, 2]
init('foo') // 'fo'

Gets all initial segments of a list.

import { inits } from 'fkit'
inits([1, 2, 3]) // [[], [1], [1, 2], [1, 2, 3]]
inits('foo') // ['', 'f', 'fo', 'foo']

Calculates the intersection of two lists.

This is a special case of the intersectBy function where the elements are compared using the strict equality === operator.

Duplicates are removed from bs, but if as contains duplicates then so will the result.

import { intersect } from 'fkit'
intersect([1, 2, 3], [2, 3, 4]) // [2, 3]
intersect('hello', 'world') // 'ol'

Calculates the intersection of two lists.

The comparator function f compares two elements, a and b. If the elements are considered to be equal, then the comparator function should return true. Otherwise it should return false.

Duplicates are removed from bs, but if as contains duplicates then so will the result.

import { intersectBy } from 'fkit'
intersectBy((a, b) => a === b, [1, 2, 3], [2, 3, 4]) // [2, 3]
intersectBy((a, b) => a === b, 'hello', 'world') // 'ol'

Intersperses the elements of a list with separator.

import { intersperse } from 'fkit'
intersperse(4, [1, 2, 3]) // [1, 4, 2, 4, 3]
intersperse('-', 'foo') // 'f-o-o'

Determines if a list is contained within another list.

import { isInfixOf } from 'fkit'

isInfixOf([], [1, 2, 3]) // true
isInfixOf([2, 3], [1, 2, 3]) // true
isInfixOf([3, 2], [1, 2, 3]) // false

isInfixOf('', 'foo') // true
isInfixOf('oo', 'foo') // true
isInfixOf('of', 'foo') // false

Determines if a list is a prefix of another list.

import { isPrefixOf } from 'fkit'

isPrefixOf([], [1, 2, 3]) // true
isPrefixOf([1, 2], [1, 2, 3]) // true
isPrefixOf([2, 3], [1, 2, 3]) // false

isPrefixOf('', 'foo') // true
isPrefixOf('fo', 'foo') // true
isPrefixOf('oo', 'foo') // false

Determines if a list is a suffix of another list.

import { isSuffixOf } from 'fkit'

isSuffixOf([], [1, 2, 3]) // true
isSuffixOf([1, 2], [1, 2, 3]) // false
isSuffixOf([2, 3], [1, 2, 3]) // true

isSuffixOf('', 'foo') // true
isSuffixOf('fo', 'foo') // false
isSuffixOf('oo', 'foo') // true

Gets the keys of an object.

import { keys } from 'fkit'
const person = { name: 'Jane', age: 20, city: 'Melbourne' }
keys(person) // ['name', 'age', 'city']

Gets the last element in a list.

import { last } from 'fkit'
last([1, 2, 3]) // 3
last('foo') // 'o'

Gets the length of a list.

import { length } from 'fkit'
length([1, 2, 3]) // 3
length('foo') // 3

Determines whether one number is less than another.

import { lt } from 'fkit'
lt(1, 2) // false
lt(2, 1) // true

Determines whether one number is less than or equal to another.

import { lte } from 'fkit'
lte(1, 2) // false
lte(2, 1) // true
lte(2, 2) // true

Maps a function over a list.

import { inc, map, toUpper } from 'fkit'
map(inc, [1, 2, 3]) // [2, 3, 4]
map(toUpper, 'foo') // ['F', 'O', 'O']

Determines whether a given regular expression matches a string.

import { match } from 'fkit'
match(/^f.*$/, 'foo') // true
match(/^f.*$/, 'bar') // false

Determines the largest of two numbers.

import { max } from 'fkit'
max(1, 2) // 2

Calculates the maximum value of a list.

This a special case of the maximumBy function where the values are compared using natural ordering.

import { maximum } from 'fkit'
maximum([1, 2, 3]) // 3
maximum('abc') // 'c'

Calculates the maximum value of a list using a comparator function.

The comparator function compares two elements, a and b. If a is greater than b, then the comparator function should return 1. If a is less than b, then the comparator function should return -1. If both elements are equal then, the comparator function should return 0.

import { compare, maximumBy } from 'fkit'
maximumBy(compare, [1, 2, 3]) // 3
maximumBy(compare, 'abc') // 'c'

Determines the smallest of two numbers.

import { min } from 'fkit'
min(1, 2) // 1

Calculates the minimum value of a list.

This a special case of the minaximumBy function where the values are compared using natural ordering.

import { minimum } from 'fkit'
minimum([1, 2, 3]) // 1
minimum('abc') // 'a'

Calculates the minimum value of a list using a comparator function.

The comparator function compares two elements, a and b. If a is greater than b, then the comparator function should return 1. If a is less than b, then the comparator function should return -1. If both elements are equal, then the comparator function should return 0.

import { compare, minimumBy } from 'fkit'
minimumBy(compare, [1, 2, 3]) // 1
minimumBy(compare, 'abc') // 'a'

Returns the modulo of two numbers.

import { mod } from 'fkit'
mod(3, 2) // 1

Returns the product of two numbers.

import { mul } from 'fkit'
mul(2, 3) // 6

Returns the negation of a number.

import { negate } from 'fkit'
negate(1) // -1

Determines whether two values are not equal.

import { neq } from 'fkit'
neq(1, 1) // false
neq(1, 2) // true

Returns the logical NOT of a value.

import { not } from 'fkit'
not(true) // false
not(false) // true

Removes duplicate elements from a list.

This is a special case of the nubBy function where the elements are compared using the strict equality === operator.

import { nub } from 'fkit'
nub([1, 2, 2, 3, 3, 3]) // [1, 2, 3]
nub('abbccc') // 'abc'

Removes duplicate elements from a list using a comparator function.

The comparator function compares two elements, a and b. If the elements are both considered to equal, then the comparator function should return true. Otherwise it should return false.

import { nubBy } from 'fkit'
nubBy((a, b) => a === b, [1, 2, 2, 3, 3, 3]) // [1, 2, 3]
nubBy((a, b) => a === b, 'abbccc') // 'abc'

Determines whether a number is odd.

import { odd } from 'fkit'
odd(2) // true
odd(1) // false

Omits properties of an object.

import { omit } from 'fkit'
const person = { name: 'Jane', age: 20, city: 'Melbourne' }
omit(['name', 'age'], person) // { city: 'Melbourne' }

Returns the logical OR of two values.

import { or } from 'fkit'
or(false, true) // true
or(0, 1) // true
or('', 'foo') // true

Creates a new ordered pair.

import { pair } from 'fkit'
pair(1, 2) // [1, 2]
pair('a', 'b') // ['a', 'b']

Gets the key-value pairs of an object.

import { pairs } from 'fkit'
const person = { name: 'Jane', age: 20, city: 'Melbourne' }
pairs(person) // [['name', 'Jane'], ['age', 20], ['city', 'Melbourne']]

Partitions a list using a predicate function.

import { eq, gt, partition } from 'fkit'
partition(gt(1), [1, 2, 3]) // [[2, 3], [1]]
partition(eq('o'), 'foo') // ['oo', 'f']

Calculates the permutations of a list.

import { permutations } from 'fkit'
permutations([1, 2, 3]) // [[1, 2, 3], [2, 1, 3], [3, 2, 1], [2, 3, 1], [3, 1, 2], [1, 3, 2]]
permutations('abc') // ['abc', 'bac', 'cba', 'bca', 'cab', 'acb']

Picks properties of an object.

import { pick } from 'fkit'
const person = { name: 'Jane', age: 20, city: 'Melbourne' }
pick(['name', 'age'], person) // { name: 'Jane', age: 20 }

Composes the given functions from left-to-right.

import { compose } from 'fkit'
pipe(f, g, h)(a) // h(g(f(a)))

Prepends a value to a list.

import { prepend } from 'fkit'
prepend(1, [2, 3]) // [1, 2, 3]
prepend('f', 'oo') // 'foo'

Calculates the product of the elements in a list.

import { product } from 'fkit'
product([1, 2, 3]) // 6

Generates a random float.

import { randomFloat } from 'fkit'
randomFloat(1, 3) // 2.3

Generates a random integer.

import { randomInt } from 'fkit'
randomInt(1, 3) // 2

Creates a new array of numbers.

import { range } from 'fkit'
range(1, 3) // [1, 2, 3]

Removes the first occurance of an element from a list.

This is a special case of the removeBy function where the elements are compared using the strict equality === operator.

import { remove } from 'fkit'
remove(2, [1, 2, 3]) // [1, 3]
remove('f', 'foo') // 'oo'

Removes the first occurance of an element from a list using a comparator function.

The comparator function f compares two elements, a and b. If the elements are both considered to equal, then the comparator function should return true. Otherwise it should return false.

import { removeBy } from 'fkit'
removeBy((a, b) => a === b, 2, [1, 2, 3]) // [1, 3]
removeBy((a, b) => a === b, 'f', 'foo') // 'oo'

Replaces a term in a string.

import { replace } from 'fkit'
replace('r', 'z', 'bar') // baz
replace(/^hello/, 'goodbye', 'hello world!') // goodbye world!

Replicates a value.

import { replicate } from 'fkit'
replicate(3, 1) // [1, 1, 1]
replicate(3, 'a') // 'aaa'

Reverses the elements in a list.

import { reverse } from 'fkit'
reverse([1, 2, 3]) // [3, 2, 1]
reverse('foo') // 'oof'

Samples random elements from a list.

import { sample } from 'fkit'
sample(2, [1, 2, 3]) // [3, 1]
sample(2, 'abc') // 'ca'

Scans a list from left-to-right with a function.

import { scan } from 'fkit'
scan((a, b) => a.concat(b), [],  [1, 2, 3]) // [[], [1], [1, 2], [1, 2, 3]]
scan((a, b) => a.concat(b), '',  'foo') // ['', 'f', 'fo', 'foo']

Scans a list from right-to-left with a function.

import { scanRight } from 'fkit'
scanRight((b, a) => a.concat(b), [],  [1, 2, 3]) // [[3, 2, 1], [3, 2], [3], []]
scanRight((b, a) => a.concat(b), '',  'foo') // ['oof', 'oo', 'o', '']

Sets a property of an object using a key path.

import { set } from 'fkit'
const person = { name: 'Jane', age: 20, address: { city: 'Melbourne', country: 'Australia' } }
set('name', 'Steve', person) // { name: 'Steve', age: 20, address: { city: 'Melbourne', country: 'Australia' } }
set('address.city', 'Sydney', person) // { name: 'Jane', age: 20, address: { city: 'Sydney', country: 'Australia' } }

Shuffles a list using the Fisher-Yates algorithm.

import { shuffle } from 'fkit'
shuffle([1, 2, 3]) // [2, 3, 1]
shuffle('abc') // 'bca'

Sorts a list using natural ordering.

This a special case of the sortBy function where the values are compared using natural ordering.

import { sort } from 'fkit'
sort([2, 3, 1]) // [1, 2, 3]
sort('bca') // 'abc'

Sorts a list using a comparator function.

The comparator function compares two elements, a and b. If a is greater than b, then the comparator function should return 1. If a is less than b, then the comparator function should return -1. If both elements are equal then, the comparator function should return 0.

import { compare, sortBy } from 'fkit'
sortBy(compare, [2, 3, 1]) // [1, 2, 3]
sortBy(compare, 'bca') // 'abc'

Splits a list using a predicate function.

import { lt, neq, span } from 'fkit'
span(lt(3), [1, 2, 3]) // [[1, 2], [3]]
span(neq(o), 'foo') // ['f', 'oo']

Splits a list.

import { splitAt } from 'fkit'
splitAt(1, [1, 2, 3]) // [[1], [2, 3]]
splitAt(1, 'foo') // ['f', 'oo']

Determines whether a given list starts with a prefix.

import { startsWith } from 'fkit'
startsWith([1], [1, 2, 3]) // true
startsWith('f', 'foo') // true

Creates a new string.

import { string } from 'fkit'
string(3) // '   '

Returns the difference of two numbers.

import { sub } from 'fkit'
sub(1, 2) // 1

Calculates the subsequences of a list.

import { subsequences } from 'fkit'
subsequences([1, 2, 3]) // [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]
subsequences('abc') // ['', 'a', 'b', 'ab', 'c', 'ac', 'bc', 'abc']

Calculates the sum of the elements in a list.

import { sum } from 'fkit'
sum([1, 2, 3]) // 6

Surrounds the list of cs with the values a and b.

import { surround } from 'fkit'
surround(0, 4, [1, 2, 3]) // [0, 1, 2, 3, 4]
surround('(', ')', 'foo') // '(foo)'

Get the elements after the first element in a list.

import { tail } from 'fkit'
tail([1, 2, 3]) // [2, 3]
tail('foo') // 'oo'

Gets all final segments of a list.

import { tails } from 'fkit'
tails([1, 2, 3]) // [[1, 2, 3], [2, 3], [3], []]
tails('foo') // ['foo', 'oo', 'o', '']

Takes a number of elements from the start of a list.

import { take } from 'fkit'
take(2, [1, 2, 3]) // [1, 2]
take(2, 'foo') // 'fo'

Gets the prefix of a list using a predicate function.

import { lt, neq, takeWhile } from 'fkit'
takeWhile(lt(3), [1, 2, 3]) // [1, 2]
takeWhile(neq(o), 'foo') // 'f'

Applies the function f to the value a and returns the value a unchanged.

import { tap } from 'fkit'
const f = a => console.log(a)
tap(f)(1) // 1

Converts a string to lowercase.

import { toLower } from 'fkit'
toLower('FOO') // foo

Converts a string to uppercase.

import { toUpper } from 'fkit'
toUpper('foo') // FOO

Creates a new tuple.

import { tuple } from 'fkit'
tuple(1, 2, 3) // [1, 2, 3]
tuple('a', 'b', 'c') // ['a', 'b', 'c']

Converts a function of any arity to a unary function.

import { unary } from 'fkit'
function f (a) { ... }
const g = unary(f)
g(1, 2, 3) // f(1)

Converts a binary function to a function on pairs.

import { uncurry } from 'fkit'
const add = uncurry((a, b) => a + b)
add([1, 2]) // 3

Calculates the union of two lists.

This is a special case of the unionBy function where the elements are compared using the strict equality === operator.

Duplicates are removed from bs, but if as contains duplicates then so will the result.

import { union } from 'fkit'
union([1, 2, 3], [2, 3, 4]) // [1, 2, 3, 4]
union('hello', 'world') // 'hellowrd'

Calculates the union of two lists.

The comparator function f compares two elements, a and b. If the elements are both considered to equal, then the comparator function should return true. Otherwise it should return false.

Duplicates are removed from bs, but if as contains duplicates then so will the result.

import { unionBy } from 'fkit'
unionBy((a, b) => a === b, [1, 2, 3], [2, 3, 4]) // [1, 2, 3, 4]
unionBy((a, b) => a === b, 'hello', 'world') // 'hellowrd'

Unzips a list of pairs into a pair of lists.

import { unzip } from 'fkit'
unzip([[1, 4], [2, 5], [3, 6]]) // [[1, 2, 3], [4, 5, 6]]
unzip([['f', 'b'], ['o', 'a'], ['o', 'r']]) // ['foo', 'bar']

Updates a property of an object with a function.

import { always, inc, update } from 'fkit'
const person = { name: 'Jane', age: 20, address: { city: 'Melbourne', country: 'Australia' } }
update('age', inc, person) // { name: 'Jane', age: 21, address: { city: 'Melbourne', country: 'Australia' } }
update('address.city', always('Sydney'), person) // { name: 'Jane', age: 20, address: { city: 'Sydney', country: 'Australia' } }

Gets the values of an object.

import { values } from 'fkit'
const person = { name: 'Jane', age: 20, city: 'Melbourne' }
values(person) // ['Jane', 20, 'Melbourne']

Converts a function to a variadic function.

The last named parameter will be given an array of arguments.

import { variadic } from 'fkit'
function f (head, tail) { ... }
variadic(f)(1, 2, 3) // f(1, [2, 3])

Determines whether all predicate functions in a list are satisfied they are applied to a value.

import { gt, whereAll } from 'fkit'
const ps = [gt(1), gt(2)]
whereAll(ps, 1) // false
whereAll(ps, 2) // false
whereAll(ps, 3) // true

Determines whether any predicate functions in a list are satisfied when they are applied to a value.

import { gt, whereAny } from 'fkit'
const ps = [gt(1), gt(2)]
whereAny(ps, 1) // false
whereAny(ps, 2) // true
whereAny(ps, 3) // true

Zips two lists into a list of pairs.

This is a special case of the zipWith function where the elements are combined using the pair function.

import { zip } from 'fkit'
zip([1, 2, 3], [4, 5, 6]) // [[1, 4], [2, 5], [3, 6]]
zip('foo', 'bar') // [['f', 'b'], ['o', 'a'], ['o', 'r']]

Zips two lists with a function.

import { zipWith } from 'fkit'
zipWith((a, b) => a + b, [1, 2, 3], [4, 5, 6]) // [5, 7, 9]
zipWith((a, b) => a + b, 'foo', 'bar') // ['fb', 'oa', or']