@bitmap/fp

ƒp

Functional programming utilities for JavaScript.

Install

npm install @bitmap/fp

Utilities

• reduce
• reduceRight
• map
• filter
• reject
• concat
• copy
• slice
• append
• prepend
• insert
• insertAll
• reverse
• sort
• first
• last
• drop
• dropRight
• dropFirst
• dropLast
• take
• takeFirst
• any
• all
• find
• findLast
• findIndex
• findLastIndex
• includes
• indexOf
• indexOfLast
• pipe
• compose
• prop
• pluck

reduce

Reduce values in a list according to a reducer function. reduce args are curried.

reduce(reducer, initialValue, list)

Example

import { reduce } from '@bitmap/fp'

const sum = (a, b) => a + b
const items = [1, 2, 3, 4]

reduce(sum, 0, items) // -> 10

reduceRight

Reduce values in a list according to a reducer function in reverse order. reduceRight args are curried.

reduceRight(reducer, initialValue, list)

Example

import { reduceRight } from '@bitmap/fp'

const sum = (a, b) => a + b
const items = [1, 2, 3, 4]

reduceRight(sum, 0, items) // -> 10

map

Apply function to each items in a list, and return a new list. map args are curried.

map(mapFunction, list)

Example

import { map } from '@bitmap/fp'

const double = (n) => n * 2
const doubleAll = map(double)

doubleAll([1, 2, 3]) // -> [2, 4, 6]

filter

Filter items from a list, and return a new list. filter args are curried.

filter(conditionFunction, list)

Example

import { filter } from '@bitmap/fp'

const isOdd = (n) => n % 2 !== 0
const filterOdds = filter(isOdd)

const odds = filterOdds([1, 2, 3, 4]) // -> [1, 3]

reject

Reject items from a list, and return a new list. The opposite of filter. reject args are curried.

reject(conditionFunction, list)

Example

import { reject } from '@bitmap/fp'

const isOdd = (n) => n % 2 !== 0
const rejectOdds = reject(isOdd)

const odds = rejectOdds([1, 2, 3, 4]) // -> [2, 4]

concat

Concat n lists into one list.

concat(...lists)

Example

import { concat } from '@bitmap/fp'

const a = [1, 2, 3]
const b = [4, 5, 6]

concat(a, b) // -> [1, 2, 3, 4, 5, 6]

copy

Returns a new copy of the list

copy(list)

Example

import { copy } from '@bitmap/fp'

const list = [1, 2, 3]

copy(list) // -> [1, 2, 3]

slice

Return a sliced list. slice args are curried.

slice(start, end, list)

Example

import { slice } from '@bitmap/fp'

const list = [1, 2, 3, 4, 5, 6]

slice(2, 5, list) // -> [3, 4, 5]

append

Appends item to the end of a list. Unlike Array.prototype.push, doesn't mutate target. append args are curried.

append(item, list)

Example

import { append } from '@bitmap/fp'

const list = [1, 2]

append(3, list) // -> [1, 2, 3]

prepend

Prepends item to the beginning of a list. Unlike Array.prototype.unshift, doesn't mutate target. prepend args are curried.

prepend(item, list)

Example

import { prepend } from '@bitmap/fp'

const list = [1, 2]

prepend(0, list) // -> [0, 1, 2]

insert

Insert item into a list. Unlike Array.prototype.splice, doesn't mutate target. insert args are curried.

insert(start, item, list)

Example

import { insert } from '@bitmap/fp'

const list = [1, 3]

insert(1, 2, list) // -> [1, 2, 3]

insertAll

Insert itemm into a list. Unlike Array.prototype.splice, doesn't mutate target. insertAll args are curried.

insertAll(start, items, list)

Example

import { insertAll } from '@bitmap/fp'

const list = [1, 4]

insertAll(1, [2, 3], list) // -> [1, 2, 3, 4]

reverse

Reverse items in a list. Unlike Array.prototype.reverse, doesn't mutate target.

reverse(list)

Example

import { reverse } from '@bitmap/fp'

const list = [1, 2, 3, 4]

reverse(list) // -> [4, 3, 2, 1]

sort

Sorts items in a list according to comparator function. Unlike Array.prototype.sort, doesn't mutate target.

sort(compareFunction, list)

Example

import { sort } from '@bitmap/fp'

const sortAscending = (a, b) => a - b
const list = [40, 21, 32, 17]

sort(sortAscending, list) // -> [17, 21, 32, 40]

first

Returns first item in a list.

first(list)

Example

import { first } from '@bitmap/fp'

const list = [1, 2, 3, 4]

first(list) // -> 1

last

Returns last item in a list.

last(list)

Example

import { last } from '@bitmap/fp'

const list = [1, 2, 3, 4]

last(list) // -> 4

drop

Drops n items from left. drop args are curried.

drop(n, list)

Example

import { drop } from '@bitmap/fp'

const list = [1, 2, 3, 4]

drop(2, list) // -> [3, 4]

dropRight

Drops n items from right. dropRight args are curried.

dropRight(n, list)

Example

import { dropRight } from '@bitmap/fp'

const list = [1, 2, 3, 4]

dropRight(2, list) // -> [1, 2]

dropFirst

Drops first item from list.

dropFirst(list)

Example

import { dropFirst } from '@bitmap/fp'

const list = [1, 2, 3, 4]

dropFirst(2, list) // -> [2, 3, 4]

dropLast

Drops last item from list.

dropLast(list)

Example

import { dropLast } from '@bitmap/fp'

const list = [1, 2, 3, 4]

dropLast(2, list) // -> [1, 2, 3]

take

Takes n items from left. take args are curried.

take(n, list)

Example

import { take } from '@bitmap/fp'

const list = [1, 2, 3, 4]

take(2, list) // -> [1, 2]

takeRight

Takes n items from right. takeRight args are curried.

takeRight(n, list)

Example

import { takeRight } from '@bitmap/fp'

const list = [1, 2, 3, 4]

takeRight(2, list) // -> [3, 4]

any

Returns true if any item in list meet the condition. any args are curried.

any(conditionFunction, list)

Example

import { any } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const anyGreaterThanTen = any(greaterThanTen)

anyGreaterThanTen([3, 5, 7, 9]) // -> false
anyGreaterThanTen([5, 20, 100]) // -> true

all

Returns true if all item in list meet the condition. all args are curried.

all(conditionFunction, list)

Example

import { all } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const allGreaterThanTen = all(greaterThanTen)

allGreaterThanTen([3, 5, 7, 9]) // -> false
allGreaterThanTen([5, 20, 100]) // -> false
allGreaterThanTen([50, 15, 99]) // -> true

find

Returns first item from list that meets predicate. find args are curried.

find(conditionFunction, list)

Example

import { find } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const findGreaterThanTen = find(greaterThanTen)

findGreaterThanTen([3, 5, 7, 9]) // -> undefined
findGreaterThanTen([5, 20, 100]) // -> 20

findLast

Returns last item from list that meets predicate. findLast args are curried.

findLast(conditionFunction, list)

Example

import { findLast } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const findLastGreaterThanTen = findLast(greaterThanTen)

findLastGreaterThanTen([3, 5, 7, 9]) // -> undefined
findLastGreaterThanTen([5, 20, 100]) // -> 100

findIndex

Returns index of first item from list that meets predicate. findIndex args are curried.

findIndex(conditionFunction, list)

Example

import { findIndex } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const findIndexGreaterThanTen = findIndex(greaterThanTen)

findIndexGreaterThanTen([3, 5, 7, 9]) // -> -1
findIndexGreaterThanTen([5, 20, 100]) // -> 1

findLastIndex

Returns index of last item from list that meets predicate. findLastIndex args are curried.

findLastIndex(conditionFunction, list)

Example

import { findLastIndex } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const findLastIndexGreaterThanTen = findLastIndex(greaterThanTen)

findLastIndexGreaterThanTen([3, 5, 7, 9]) // -> -1
findLastIndexGreaterThanTen([5, 20, 100]) // -> 2

includes

Returns true if item is in the list. includes args are curried.

includes(value, list)

Example

import { includes } from '@bitmap/fp'

const hasApple = includes('apple')

hasApple(['orange', 'banana', 'pear']) // -> false
hasApple(['kiwi', 'apple', 'coconut']) // -> true

indexOf

Returns first index of item in the list. indexOf args are curried.

indexOf(value, list)

Example

import { indexOf } from '@bitmap/fp'

const firstAppleIndex = indexOf('apple')

firstAppleIndex(['orange', 'banana', 'pear', 'lemon']) // -> -1
firstAppleIndex(['kiwi', 'apple', 'coconut', 'apple']) // -> 1

indexOfLast

Returns last index of item in the list. indexOfLast args are curried.

indexOfLast(value, list)

Example

import { indexOfLast } from '@bitmap/fp'

const lastAppleIndex = indexOfLast('apple')

lastAppleIndex(['orange', 'banana', 'pear', 'lemon']) // -> -1
lastAppleIndex(['kiwi', 'apple', 'coconut', 'apple']) // -> 3

pipe

Compose functions from left to right.

pipe(...functions)(value)

Example

import { pipe } from '@bitmap/fp'

const addOne = (n) => n + 1
const double = (n) => n * 2

const doubleThenAddOne = pipe(double, addOne)

doubleThenAddOne(20) // 41

compose

Compose functions from right to left.

compose(...functions)(value)

Example

import { compose } from '@bitmap/fp'

const addOne = (n) => n + 1
const double = (n) => n * 2

const addOneThenDouble = compose(double, addOne)

addOneThenDouble(20) // 42

curry

Curry a function to allow it to be called partially.

curry(function)

Example

import { curry } from '@bitmap/fp'

const sum = curry((a, b, c) => a + b + c)

sum(1)(2)(3) // -> 6

prop

Returns the value of key in object. prop args are curried.

prop(key, object)

Example

import { prop } from '@bitmap/fp'

const data = {
  name: 'Cabe',
  username: 'bitmap',
  title: 'Developer',
}

prop('user', data) // -> 'bitmap'

pluck

Alias of prop