@bitmap/fp

ƒp

Functional programming utilities for JavaScript.

Install

npm install @bitmap/fp

Utilities

• reduce
• reduceRight
• map
• flat
• flatMap
• filter
• filterMap
• reject
• rejectMap
• concat
• copy
• slice
• append
• prepend
• insert
• insertAll
• reverse
• sort
• first
• last
• drop
• dropRight
• dropFirst
• dropLast
• take
• takeRight
• any
• all
• find
• findLast
• findIndexOf
• findIndexOfLast
• includes
• indexOf
• indexOfLast
• pipe
• compose
• curry
• prop
• pluck
• pick
• omit
• split
• join

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]

flat

Return a flattened list.

flat(list, depth)

Example

import { flat } from '@bitmap/fp'

flat([0, [1, 2], [3, 4], [5]]) // -> [0, 1, 2, 3, 4, 5]
flat([0, [1, 2, [3, 4, [5]]]], 3) // -> [0, 1, 2, 3, 4, 5]

flatMap

Apply function to each items in a list, and return a flattened list. flatMap args are curried.

flatMap(flatMapFunction, list)

Example

import { flatMap } from '@bitmap/fp'

const users = ['@cabe', '@bitmap']
const indexUsers = flatMap((user, index) => [index, user])

indexUsers(users) // -> [0, '@cabe', 1, '@bitmap']

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)

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

filterMap

Apply filter and map to a list, and return a new list. filterMap args are curried.

filterMap(conditionFunction, mapFunction, list)

Example

import { filterMap } from '@bitmap/fp'

const isOdd = (n) => n % 2 !== 0
const double = (n) => n * 2
const doubleOdds = filterMap(isOdd, double)

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

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)

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

rejectMap

Apply reject and map to a list, and return a new list. rejectMap args are curried.

rejectMap(conditionFunction, mapFunction, list)

Example

import { rejectMap } from '@bitmap/fp'

const isOdd = (n) => n % 2 !== 0
const double = (n) => n * 2
const doubleEvens = rejectMap(isOdd, double)

doubleEvens([1, 2, 3, 4]) // -> [4, 8]

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 a string or 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]

const string = 'functional'

reverse(string) // -> 'lanoitcnuf'

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

findIndexOf

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

findIndexOf(conditionFunction, list)

Example

import { findIndexOf } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const findIndexOfGreaterThanTen = findIndexOf(greaterThanTen)

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

findIndexOfLast

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

findIndexOfLast(conditionFunction, list)

Example

import { findIndexOfLast } from '@bitmap/fp'

const greaterThanTen = x => x > 10
const findIndexOfLastGreaterThanTen = findIndexOfLast(greaterThanTen)

findIndexOfLastGreaterThanTen([3, 5, 7, 9]) // -> -1
findIndexOfLastGreaterThanTen([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('username', data) // -> 'bitmap'

pluck

Returns map of key values from a list of objects. pluck args are curried.

pluck(key, list)

Example

import { pluck } from '@bitmap/fp'

const data = [
  {
    city: 'New York',
    state: 'NY',
  },
  {
    city: 'San Francisco',
    state: 'CA',
  },
   {
    city: 'Portland',
    state: 'OR',
  }
]

pluck('state', data) // -> ['NY', 'CA', 'OR']

pick

Returns copy of object with supplied keys and all other properties omitted. pick args are curried.

pick(keys, object)

Example

import { pick } from '@bitmap/fp'

const data = {
  name: 'Cabe',
  age: 32,
  position: 'Developer',
  state: 'NY',
  city: 'New York',
}

pick(['name', 'position'], data) // -> { name: 'Cabe', position: 'Developer' }

omit

Returns copy of object with supplied keys omitted. opposite of pick. omit args are curried.

omit(keys, object)

Example

import { omit } from '@bitmap/fp'

const data = {
  name: 'Cabe',
  age: 32,
  position: 'Developer',
  state: 'NY',
  city: 'New York',
}

omit(['age', 'state', 'city'], data) // -> { name: 'Cabe', position: 'Developer' }

split

Splits a string by delimiter into a list. split args are curried.

split(delimiter, string)

Example

import { split } from '@bitmap/fp'

split(':', 'name:Cabe') // -> ['name', 'Cabe']

join

Joins a list into a string, seperating each item by specified delimiter. join args are curried.

join(delimiter, list)

Example

import { join } from '@bitmap/fp'

join('|', [1, 2, 3, 4]) // -> '1|2|3|4'