# rambda
**Repository Path**: mirrors_davidjbradshaw/rambda
## Basic Information
- **Project Name**: rambda
- **Description**: Faster alternative to Ramda in just 10kB
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-08-08
- **Last Updated**: 2026-04-04
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
[](https://circleci.com/gh/selfrefactor/rambda/tree/master)
[](https://codecov.io/gh/selfrefactor/rambda)
[](https://david-dm.org/selfrefactor/rambda)
# Rambda
Faster alternative to **Ramda** - [Documentation](https://selfrefactor.github.io/rambda/#/)
## Rambda's advantages
- Tree-shaking
Currenly **Rambda** is more tree-shakable than **Ramda** as you can see in this [tree-shaking example](https://github.com/selfrefactor/tree-shaking-example).
- Speed
**Rambda** is generally more performant than `Ramda` as the benchmarks can prove that.
You can clone this repo and run `yarn run benchmark all` to see for yourself.
- dot notation for `R.path`
Standard usage of `R.path` is `R.path(['a', 'b'], {a: {b: 1} })`.
In **Rambda** you have the choice to use dot notation(which is arguably more readable):
```
R.path('a.b', {a: {b: 1} })
```
- comma notation for `R.pick` and `R.omit`
Similar to dot notation, but the separator is comma(`,`) instead of dot(`.`).
```
R.pick('a,b', {a: 1 , b: 2, c: 3} })
// No space allowed between properties
```
- Typescript included
Typescript definitions are included in the library, in comparison to **Ramda**, where you need to additionally install `@types/ramda`.
---
**Rambda** partially shadows **Ramda**'s API, which means that you need to check **Rambda**'s documentation to assure that all the methods you need are available.
## Example use
```javascript
const R = require('rambda')
const result = R.compose(
R.map(x => x * 2),
R.filter(x => x > 2)
)([1, 2, 3, 4])
// => [6, 8]
```
You can test this example in Rambda's REPL
## Install
- Use **yarn add rambda** for `Webpack` and `Node.js` usage
- For UMD usage either use `./dist/rambda.umd.js` or following CDN link:
```
https://cdnjs.cloudflare.com/ajax/libs/rambda/1.0.13/webVersion.js
```
## Differences between Rambda and Ramda
- Rambda's **type** detect async functions and unresolved `Promises`. The returned values are `'Async'` and `'Promise'`.
- Rambda's **path** accepts dot notation(`'x.y' same as ['x','y']`)
- Rambda's **pick** and **omit** accept comma notation(`'x,y' same as ['x','y']`)
- Rambda's **map** and **filter** pass object key as second argument when mapping over objects.
- Rambda's **startsWith/endsWith** work only with strings, instead with array and strings.
- Rambda's **flip** works only for functions expecting two arguments.
- Rambda's **equals** doesn't protect against circular structures as **Ramda.equals** does.
- Rambda's **partialCurry** and **includes** are not part of Ramda API.
> If you need more **Ramda** methods in **Rambda**, you may either submit a `PR` or check the extended version of **Rambda** - [Rambdax](https://github.com/selfrefactor/rambdax)
## API
---
#### add
> add(a: number, b: number): number
```
R.add(2, 3) // => 5
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/add.js)
Try in REPL
---
#### addIndex
> addIndex(fn: Function): Function
```
const mapWithIndex = R.addIndex(R.map)
const result = mapWithIndex(
(val, index) => `${val} - ${index}`,
['A', 'B', 'C']
) // => ['A - 0', 'B - 1', 'C - 2']
```
---
#### adjust
> adjust(replaceFn: Function, i: number, arr: T[]): T[]
It replaces `i` index in `arr` with the result of `replaceFn(arr[i])`.
```
R.adjust(
a => a + 1,
0,
[0, 100]
) // => [1, 100]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/adjust.js)
Try in REPL
---
#### all
> all(fn: Function, arr: T[]): boolean
It returns `true`, if all members of array `arr` returns `true`, when applied as argument to function `fn`.
```
const arr = [ 0, 1, 2, 3, 4 ]
const fn = x => x > -1
const result = R.all(fn, arr)
// => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/all.js)
Try in REPL
---
#### allPass
> allPass(rules: Function[], input: any): boolean
It returns `true`, if all functions of `rules` return `true`, when `input` is their argument.
```
const input = {
a : 1,
b : 2,
}
const rules = [
x => x.a === 1,
x => x.b === 2,
]
const result = R.allPass(rules, input) // => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/allPass.js)
Try in REPL
---
#### always
> always(x: any): Function
It returns function that always returns `x`.
```
const fn = R.always(7)
console.log(fn())// => 7
```
---
#### any
> any(condition: Function, arr: T[]): boolean
It returns `true`, if at least one member of `arr` returns true, when passed to the `condition` function.
```
R.any(a => a * a > 8)([1, 2, 3])
// => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/any.js)
Try in REPL
---
#### anyPass
> anyPass(conditions: Function[]): Function
```
const isBig = a => a > 20
const isOdd = a => a % 2 === 1
const result = R.anyPass(
[isBig, isOdd]
)(11)
// => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/anyPass.js)
Try in REPL
---
#### append
> append(valueToAppend: T, arr: T[]): T[]
```
R.append(
'foo',
['bar', 'baz']
) // => ['bar', 'baz', 'foo']
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/append.js)
Try in REPL
---
#### both
> both(firstCondition: Function, secondCondition: Function, input: any): boolean
It returns `true`, if both function `firstCondition` and function `secondCondition` return `true`, when `input` is their argument.
```
const fn = R.both(
a => a > 10,
a => a < 20
)
console.log(fn(15)) //=> true
console.log(fn(30)) //=> false
```
---
#### compose
> compose(fn1: Function, ... , fnN: Function): any
It performs right-to-left function composition.
```
const result = R.compose(
R.map(x => x * 2),
R.filter(x => x > 2)
)([1, 2, 3, 4])
// => [6, 8]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/compose.js)
Try in REPL
---
#### complement
> complement(fn: Function): Function
It returns `complemented` function that accept `input` as argument.
The return value of `complemented` is the negative boolean value of `fn(input)`.
```
const fn = R.complement(x => !x)
const result = fn(false) // => false
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/complement.js)
Try in REPL
---
#### concat
> concat(x: T[]|string, y: T[]|string): T[]|string
It returns a new string or array, which is the result of merging `x` and `y`.
```
R.concat([1, 2])([3, 4]) // => [1, 2, 3, 4]
R.concat('foo')('bar') // => 'foobar'
```
---
#### contains
> contains(valueToFind: T, arr: T[]): boolean
It returns `true`, if `valueToFind` is part of `arr`.
```
R.contains(2, [1, 2]) // => true
R.contains(3, [1, 2]) // => false
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/contains.js)
Try in REPL
---
#### curry
> curry(fn: Function): Function
It returns curried version of `fn`.
```
const addFourNumbers = (a, b, c, d) => a + b + c + d
const curriedAddFourNumbers = R.curry(addFourNumbers)
const f = curriedAddFourNumbers(1, 2)
const g = f(3)
const result = g(4) // => 10
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/curry.js)
Try in REPL
---
#### dec
> dec(x: number): number
It decrements a number.
```
R.dec(2) // => 1
```
---
#### defaultTo
> defaultTo(defaultValue: T, inputArgument: any): T
It returns `defaultValue`, if `inputArgument` is `undefined`, `null` or `NaN`.
It returns `inputArgument` in any other case.
```
R.defaultTo('foo', undefined) // => 'foo'
R.defaultTo('foo', 'bar') // => 'bar'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/defaultTo.js)
Try in REPL
---
#### dissoc
> dissoc(prop: any, obj: object): object
It returns a new object that does not contain a `prop` property.
```
R.dissoc('b', {a: 1, b: 2, c: 3})
//=> {a: 1, c: 3}
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/dissoc.js)
Try in REPL
---
#### divide
```
R.divide(71, 100) // => 0.71
```
---
#### drop
> drop(howManyToDrop: number, arrOrStr: T[]|string): T[]|String
It returns `arrOrStr` with `howManyToDrop` items dropped from the left.
```
R.drop(1, ['foo', 'bar', 'baz']) // => ['bar', 'baz']
R.drop(1, 'foo') // => 'oo'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/drop.js)
Try in REPL
---
#### dropLast
> dropLast(howManyToDrop: number, arrOrStr: T[]|String): T[]|String
It returns `arrOrStr` with `howManyToDrop` items dropped from the right.
```
R.dropLast(1, ['foo', 'bar', 'baz']) // => ['foo', 'bar']
R.dropLast(1, 'foo') // => 'fo'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/dropLast.js)
Try in REPL
---
#### endsWith
> endsWith(x: string, str: string): boolean
```
R.endsWith(
'bar',
'foo-bar'
) // => true
R.endsWith(
'foo',
'foo-bar'
) // => false
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/endsWith.js)
Try in REPL
---
#### either
> endsWith(firstCondition: Function, secondCondition: Function): Function
```
R.either(
a => a > 10,
a => a % 2 === 0
)(15) //=> true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/either.js)
Try in REPL
---
#### equals
> equals(a: any, b: any): boolean
It returns equality match between `a` and `b`.
It doesn't handle cyclical data structures.
```
R.equals(
[1, {a:2}, [{b:3}]],
[1, {a:2}, [{b:3}]]
) // => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/equals.js)
Try in REPL
---
#### F
`R.F() // => false`
---
#### filter
> filter(filterFn: Function, x: Array|Object): Array|Object
It filters `x` iterable over boolean returning `filterFn`.
```
const filterFn = a => a % 2 === 0
const result = R.filter(filterFn, [1, 2, 3, 4])
// => [2, 4]
```
The method works with objects as well.
Note that unlike Ramda's `filter`, here object keys are passed as second argument to `filterFn`.
```
const result = R.filter((val, prop)=>{
return prop === 'a' || val === 2
}, {a: 1, b: 2, c: 3})
// => {a: 1, b: 2}
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/filter.js)
Try in REPL
---
#### find
> find(findFn: Function, arr: T[]): T|undefined
It returns `undefined` or the first element of `arr` satisfying `findFn`.
```
const findFn = a => R.type(a.foo) === 'Number'
const arr = [{foo: 'bar'}, {foo: 1}]
const result = R.find(findFn, arr)
// => {foo: 1}
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/find.js)
Try in REPL
---
#### findIndex
> findIndex(findFn: Function, arr: T[]): number
It returns `-1` or the index of the first element of `arr` satisfying `findFn`.
```
const findFn = a => R.type(a.foo) === 'Number'
const arr = [{foo: 'bar'}, {foo: 1}]
const result = R.findIndex(findFn, arr)
// => 1
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/findIndex.js)
Try in REPL
---
#### flatten
> flatten(arr: any[]): any[]
```
R.flatten([ 1, [ 2, [ 3 ] ] ])
// => [ 1, 2, 3 ]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/flatten.js)
Try in REPL
---
#### flip
> flip(fn: Function): Function
It returns function which calls `fn` with exchanged first and second argument.
```
const subtractFlip = R.flip(R.subtract)
const result = subtractFlip(1,7)
// => 6
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/flip.js)
Try in REPL
---
#### forEach
> forEach(fn: Function, arr: Array): Array
It applies function `fn` over all members of array `arr` and returns `arr`.
```
const sideEffect = {}
const result = R.forEach(
x => sideEffect[`foo${x}`] = x
)([1, 2])
console.log(sideEffect) //=> {foo1 : 1, foo2 : 2}
console.log(result) //=> [1, 2]
```
Note, that unlike `Ramda`'s **forEach**, Rambda's one doesn't dispatch to `forEach` method of `arr` if `arr` has such method.
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/forEach.js)
Try in REPL
---
#### has
> has(prop: string, obj: Object): boolean
- It returns `true` if `obj` has property `prop`.
```
R.has('a', {a: 1}) // => true
R.has('b', {a: 1}) // => false
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/has.js)
Try in REPL
---
#### head
> head(arrOrStr: T[]|string): T|string
It returns the first element of `arrOrStr`.
```
R.head([1, 2, 3]) // => 1
R.head('foo') // => 'f'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/head.js)
Try in REPL
---
#### identity
> identity(x: T): T
It just passes back the supplied arguments.
```
R.identity(7) // => 7
```
---
#### ifElse
> ifElse(condition: Function|boolean, ifFn: Function, elseFn: Function): Function
It returns function, which expect `input` as argument and returns `finalResult`.
When this function is called, a value `answer` is generated as a result of `condition(input)`.
If `answer` is `true`, then `finalResult` is equal to `ifFn(input)`.
If `answer` is `false`, then `finalResult` is equal to `elseFn(input)`.
```
const fn = R.ifElse(
x => x > 10,
x => x*2,
x => x*10
)
const result = fn(8)
// => 80
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/ifElse.js)
Try in REPL
---
#### inc
> inc(x: number): number
It increments a number.
```
R.inc(1) // => 2
```
---
#### includes
> includes(x: any, arrOrStr: T[]|string): boolean
```
R.includes(1, [1, 2]) // => true
R.includes('oo', 'foo') // => true
R.includes('z', 'foo') // => false
```
!! Note that this method is not part of `Ramda` API.
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/includes.js)
Try in REPL
---
#### indexBy
> indexBy(fn: Function, arr: T[]): Object
It indexes array `arr` as an object with provided selector function `fn`.
```
R.indexBy(
x => x.id,
[ {id: 1}, {id: 2} ]
)
// => { 1: {id: 1}, 2: {id: 2} }
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/indexBy.js)
Try in REPL
---
#### indexOf
> indexOf(valueToFind: any, arr: T[]): number
It returns `-1` or the index of the first element of `arr` equal of `valueToFind`.
```
R.indexOf(1, [1, 2]) // => 0
R.indexOf(0, [1, 2]) // => -1
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/indexOf.js)
Try in REPL
---
#### init
> init(arrOrStr: T[]|string): T[]|string
- It returns all but the last element of `arrOrStr`.
```
R.init([1, 2, 3]) // => [1, 2]
R.init('foo') // => 'fo'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/init.js)
Try in REPL
---
#### join
> join(separator: string, arr: T[]): string
```
R.join('-', [1, 2, 3]) // => '1-2-3'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/join.js)
Try in REPL
---
#### is
> is(xPrototype: any, x: any): boolean
It returns `true` is `x` is instance of `xPrototype`.
```
R.is(String, 'foo') // => true
R.is(Array, 1) // => false
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/is.js)
Try in REPL
---
#### isNil
> isNil(x: any): boolean
It returns `true` is `x` is either `null` or `undefined`.
```
R.isNil(null) // => true
R.isNil(1) // => false
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/isNil.js)
Try in REPL
---
#### last
> last(arrOrStr: T[]|string): T|string
- It returns the last element of `arrOrStr`.
```
R.last(['foo', 'bar', 'baz']) // => 'baz'
R.last('foo') // => 'o'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/last.js)
Try in REPL
---
#### lastIndexOf
> lastIndexOf(x: any, arr: T[]): number
It returns the last index of `x` in array `arr`.
`R.equals` is used to determine equality between `x` and members of `arr`.
Value `-1` is returned if no `x` is found in `arr`.
```
R.lastIndexOf(1, [1, 2, 3, 1, 2]) // => 3
R.lastIndexOf(10, [1, 2, 3, 1, 2]) // => -1
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/lastIndexOf.js)
Try in REPL
---
#### length
> length(arrOrStr: Array|String): Number
```
R.length([1, 2, 3]) // => 3
```
---
#### map
> map(mapFn: Function, x: Array|Object): Array|Object
It returns the result of looping through iterable `x` with `mapFn`.
The method works with objects as well.
Note that unlike Ramda's `map`, here object keys are passed as second argument to `mapFn`.
```
const mapFn = x => x * 2
const resultWithArray = R.map(mapFn, [1, 2, 3])
// => [2, 4, 6]
const result = R.map((val, prop)=>{
return `${val}-${prop}`
}, {a: 1, b: 2})
// => {a: 'a-1', b: 'b-2'}
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/map.js)
Try in REPL
---
#### match
> match(regExpression: Regex, str: string): string[]
```
R.match(/([a-z]a)/g, 'bananas') // => ['ba', 'na', 'na']
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/match.js)
Try in REPL
---
#### merge
> merge(a: Object, b: Object)
It returns result of `Object.assign({}, a, b)`.
```
R.merge({ 'foo': 0, 'bar': 1 }, { 'foo': 7 })
// => { 'foo': 7, 'bar': 1 }
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/merge.js)
Try in REPL
---
#### modulo
> modulo(a: number, b: number):numberNumber
It returns the remainder of operation `a/b`.
```
R.module(14, 3) // => 2
```
---
#### multiply
> multiply(a: number, b: number): number
It returns the result of operation `a*b`.
```
R.multiply(4, 3) // => 12
```
---
#### not
> not(x: any): boolean
It returns inverted boolean version of input `x`.
```
R.not(true) //=> false
R.not(false) //=> true
R.not(0) //=> true
R.not(1) //=> false
```
---
#### omit
> omit(propsToOmit: string[]|string, obj: Object): Object
It returns a partial copy of an `obj` with omitting `propsToOmit`
```
R.omit('a,c,d', {a: 1, b: 2, c: 3}) // => {b: 2}
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/omit.js)
Try in REPL
---
#### path
> path(pathToSearch: string[]|string, obj: Object): any
If `pathToSearch` is `'a.b'` then it will return `1` if `obj` is `{a:{b:1}}`.
It will return `undefined`, if such path is not found.
```
R.path('a.b', {a: {b: 1}}) // => 1
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/path.js)
Try in REPL
---
#### pathOr
> pathOr(defaultValue: any, pathToSearch: string[]|string, obj: Object): any
`pathFound` is the result of calling `R.path(pathToSearch, obj)`.
If `pathFound` is `undefined`, `null` or `NaN`, then `defaultValue` will be returned.
`pathFound` is returned in any other case.
```
R.pathOr(1, 'a.b', {a: {b: 2}}) // => 2
R.pathOr(1, ['a', 'b'], {a: {b: 2}}) // => 2
R.pathOr(1, ['a', 'c'], {a: {b: 2}}) // => 1
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/pathOr.js)
Try in REPL
---
#### partialCurry
> partialCurry(fn: Function|Async, a: Object, b: Object): Function|Promise
When called with function `fn` and first set of input `a`, it will return a function.
This function will wait to be called with second set of input `b` and it will invoke `fn` with the merged object of `a` over `b`.
`fn` can be asynchronous function. In that case a `Promise` holding the result of `fn` is returned.
See the example below:
```
const fn = ({a, b, c}) => {
return (a * b) + c
}
const curried = R.partialCurry(fn, {a: 2})
const result = curried({b: 3, c: 10})
// => 16
```
- Note that `partialCurry` is method specific for **Rambda** and the method is not part of **Ramda**'s API
- You can read my argumentation for creating *partialCurry* [here](https://selfrefactor.gitbooks.io/blog/content/argumenting-rambdas-curry.html)
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/partialCurry.js)
Try in REPL
---
#### pick
> pick(propsToPick: string[], obj: Object): Object
It returns a partial copy of an `obj` containing only `propsToPick` properties.
```
R.pick(['a', 'c'], {a: 1, b: 2}) // => {a: 1}
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/pick.js)
Try in REPL
---
#### pipe
> pipe(fn1: Function, ... , fnN: Function): any
It performs left-to-right function composition.
```
const result = R.pipe(
R.filter(val => val > 2),
R.map(a => a * 2)
)([1, 2, 3, 4])
// => [6, 8]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/pipe.js)
Try in REPL
---
#### pluck
> pluck(property: string, arr: Object[]): any[]
It returns list of the values of `property` taken from the objects in array of objects `arr`.
```
R.pluck('a')([{a: 1}, {a: 2}, {b: 3}]) // => [1, 2]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/pluck.js)
Try in REPL
---
#### prepend
> prepend(x: T, arr: T[]): T[]
It adds `x` to the start of the array `arr`.
```
R.prepend('foo', ['bar', 'baz']) // => ['foo', 'bar', 'baz']
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/prepend.js)
Try in REPL
---
#### prop
> prop(propToFind: string, obj: Object): any
It returns `undefined` or the value of property `propToFind` in `obj`
```
R.prop('x', {x: 100}) // => 100
R.prop('x', {a: 1}) // => undefined
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/prop.js)
Try in REPL
---
#### propEq
> propEq(propToFind: string, valueToMatch: any, obj: Object): boolean
It returns true if `obj` has property `propToFind` and its value is equal to `valueToMatch`.
```
const propToFind = 'foo'
const valueToMatch = 0
const result = R.propEq(propToFind, valueToMatch)({foo: 0})
// => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/propEq.js)
Try in REPL
---
#### range
> range(start: number, end: number): number[]
It returns a array of numbers from `start`(inclusive) to `end`(exclusive).
```
R.range(0, 3) // => [0, 1, 2]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/range.js)
Try in REPL
---
#### reduce
> reduce(iteratorFn: Function, accumulator: any, array: T[]): any
```
const iteratorFn = (acc, val) => acc + val
const result = R.reduce(iteratorFn, 1, [1, 2, 3])
// => 7
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/reduce.js)
Try in REPL
---
#### reject
> reject(fn: Function, arr: T[]): T[]
It has the opposite effect of `R.filter`.
It will return those members of `arr` that return `false` when applied to function `fn`.
```
const fn = x => x % 2 === 1
const result = R.reject(fn, [1, 2, 3, 4])
// => [2, 4]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/reject.js)
Try in REPL
---
#### repeat
> repeat(valueToRepeat: T, num: number): T[]
```
R.repeat('foo', 2) // => ['foo', 'foo']
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/repeat.js)
Try in REPL
---
#### replace
> replace(strOrRegex: string|Regex, replacer: string, str: string): string
It replaces `strOrRegex` found in `str` with `replacer`.
```
R.replace('foo', 'bar', 'foo foo') // => 'bar foo'
R.replace(/foo/, 'bar', 'foo foo') // => 'bar foo'
R.replace(/foo/g, 'bar', 'foo foo') // => 'bar bar'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/replace.js)
Try in REPL
---
#### reverse
reverse(str: T[]): T[]
```
const arr = [1, 2]
const result = R.reverse(arr)
// => [2, 1]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/reverse.js)
Try in REPL
---
#### sort
takeLast(num: number, arrOrStr: T[]|string): T[]|String
It returns copy of `arr` sorted by `sortFn`.
Note that `sortFn` must return a number type.
```
const sortFn = (a, b) => a - b
const result = R.sort(sortFn, [3, 1, 2])
// => [1, 2, 3]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/sort.js)
Try in REPL
---
#### sortBy
> sortBy(sortFn: Function, arr: T[]): T[]
It returns copy of `arr` sorted by `sortFn`.
`sortFn` must return value for comparison
```
const sortFn = obj => obj.foo
const result = R.sortBy(sortFn, [
{foo: 1},
{foo: 0}
])
const expectedResult = [ {foo: 0}, {foo: 1} ]
console.log(result === expectedResult) // => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/sortBy.js)
Try in REPL
---
#### split
> split(separator: string, str: string): string[]
```
R.split('-', 'a-b-c') // => ['a', 'b', 'c']
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/split.js)
Try in REPL
---
#### splitEvery
> splitEvery(sliceLength: number, arrOrString: T[]|string): T[T[]]|string[]
- It splits `arrOrStr` into slices of `sliceLength`.
```
R.splitEvery(2, [1, 2, 3]) // => [[1, 2], [3]]
R.splitEvery(3, 'foobar') // => ['foo', 'bar']
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/splitEvery.js)
Try in REPL
---
#### startsWith
> startsWith(x: string, str: string): boolean
```
R.startsWith(
'foo',
'foo-bar'
) // => true
R.startsWith(
'bar',
'foo-bar'
) // => false
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/startsWith.js)
Try in REPL
---
#### subtract
> subtract(a: number, b: number): number
```
R.subtract(3, 1) // => 2
```
---
#### T
`R.T() // => true`
---
#### tail
> tail(arrOrStr: T[]|string): T[]|string
- It returns all but the first element of `arrOrStr`
```
R.tail([1, 2, 3]) // => [2, 3]
R.tail('foo') // => 'oo'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/tail.js)
Try in REPL
---
#### take
> take(num: number, arrOrStr: T[]|string): T[]|string
- It returns the first `num` elements of `arrOrStr`.
```
R.take(1, ['foo', 'bar']) // => ['foo']
R.take(2, ['foo']) // => 'fo'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/take.js)
Try in REPL
---
#### takeLast
> takeLast(num: number, arrOrStr: T[]|string): T[]|string
- It returns the last `num` elements of `arrOrStr`.
```
R.takeLast(1, ['foo', 'bar']) // => ['bar']
R.takeLast(2, ['foo']) // => 'oo'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/takeLast.js)
Try in REPL
---
#### test
> test(regExpression: Regex, str: string): boolean
- Determines whether `str` matches `regExpression`
```
R.test(/^f/, 'foo')
// => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/test.js)
Try in REPL
---
#### times
> times(fn: Function, n: number): T[]
It returns the result of applying function `fn` over members of range array.
The range array includes numbers between `0` and `n`(exclusive).
```
R.times(R.identity, 5)
//=> [0, 1, 2, 3, 4]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/times.js)
Try in REPL
---
#### toLower
> toLower(str: string): string
```
R.toLower('FOO') // => 'foo'
```
---
#### toString
> toString(x: any): string
```
R.toString([1, 2]) // => '1,2'
```
---
#### toUpper
> toUpper(str: string): string
```
R.toUpper('foo') // => 'FOO'
```
---
#### trim
> trim(str: string): string
```
R.trim(' foo ') // => 'foo'
```
---
#### type
> type(a: any): string
```
R.type(() => {}) // => 'Function'
R.type(async () => {}) // => 'Async'
R.type([]) // => 'Array'
R.type({}) // => 'Object'
R.type('foo') // => 'String'
R.type(1) // => 'Number'
R.type(true) // => 'Boolean'
R.type(null) // => 'Null'
R.type(/[A-z]/) // => 'RegExp'
const delay = ms => new Promise(resolve => {
setTimeout(function () {
resolve()
}, ms)
})
R.type(delay) // => 'Promise'
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/type.js)
Try in REPL
---
#### uniq
> uniq(arr: T[]): T[]
It returns a new array containing only one copy of each element in `arr`.
```
R.uniq([1, 1, 2, 1])
// => [1, 2]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/uniq.js)
Try in REPL
---
#### uniqWith
> uniqWith(fn: Function, arr: T[]): T[]
It returns a new array containing only one copy of each element in `arr` according to boolean returning function `fn`.
```
const arr = [
{id: 0, title:'foo'},
{id: 1, title:'bar'},
{id: 2, title:'baz'},
{id: 3, title:'foo'},
{id: 4, title:'bar'},
]
const expectedResult = [
{id: 0, title:'foo'},
{id: 1, title:'bar'},
{id: 2, title:'baz'},
]
const fn = (x,y) => x.title === y.title
const result = R.uniqWith(fn, arr)
console.log(result === expectedResult) // => true
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/uniqWith.js)
Try in REPL
---
#### update
> update(i: number, replaceValue: T, arr: T[]): T[]
It returns a new copy of the `arr` with the element at `i` index
replaced with `replaceValue`.
```
R.update(0, 'foo', ['bar', 'baz'])
// => ['foo', baz]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/update.js)
Try in REPL
---
#### values
> values(obj: Object): Array
It returns array with of all values in `obj`.
```
R.values({a: 1, b: 2})
// => [1, 2]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/values.js)
Try in REPL
---
#### without
> without(a: T[], b: T[]): T[]
It will return a new array based on `b` array.
This array contains all members of `b` array, that doesn't exist in `a` array.
Method `R.equals` is used to determine the existance of `b` members in `a` array.
```
R.without([1, 2], [1, 2, 3, 4])
// => [3, 4]
```
[Source](https://github.com/selfrefactor/rambda/tree/master/modules/without.js)
Try in REPL
---
#### zip
> zip(a: K[], b: V[]): Array>
It will return a new array containing tuples of equally positions items from both lists. The returned list will be truncated to match the length of the shortest supplied list.
```
R.zip([1, 2], ['A', 'B'])
// => [[1, 'A'], [2, 'B']]
// truncates to shortest list
R.zip([1, 2, 3, 4], ['A', 'B'])
// => [[1, 'A'], [2, 'B']]
```
## Benchmark
## Tree-shaking
## Use with ES5
```
import omit from 'rambda/lib/omit'
```
## Changelog
- 1.1.1 Approve [PR #66](https://github.com/selfrefactor/rambda/pull/66) `R.zip`
- 1.1.0 `R.compose` accepts more than one input argument [issue #65](https://github.com/selfrefactor/rambda/issues/65)
- 1.0.13 Approve [PR #64](https://github.com/selfrefactor/rambda/pull/64) `R.indexOf`
- 1.0.12 Close [issue #61](https://github.com/selfrefactor/rambda/issues/61) make all functions modules
- 1.0.11 Close [issue #60](https://github.com/selfrefactor/rambda/issues/60) problem with babelrc
- 1.0.10 Close [issue #59](https://github.com/selfrefactor/rambda/issues/59) add R.dissoc
- 1.0.9 Close [issue #58](https://github.com/selfrefactor/rambda/issues/58) - Incorrect `R.equals`
- 1.0.8 `R.map` and `R.filter` pass object properties when mapping over objects
- 1.0.7 Add `R.uniqWith`
- 1.0.6 Close [issue #52](https://github.com/selfrefactor/rambda/issues/52) - ES5 compatible code
- 1.0.5 Close [issue #51](https://github.com/selfrefactor/rambda/issues/51)
- 1.0.4 Close [issue #50](https://github.com/selfrefactor/rambda/issues/50) - add `R.pipe` typings
- 1.0.3 `R.ifElse` accept also boolean as condition argument
- 1.0.2 Remove `typedDefaultTo` and `typedPathOr` | Add `R.pickAll` and `R.none`
- 1.0.0 Major change as build is now ES6 not ES5 compatible (Related to [issue #46](https://github.com/selfrefactor/rambda/issues/46))| Making `Rambda` fully tree-shakeable| Edit Typescript definition
- 0.9.8 Revert to ES5 compatible build - [issue #46](https://github.com/selfrefactor/rambda/issues/46)
- 0.9.7 Refactor for `Rollup` tree-shake | Remove `R.padEnd` and `R.padStart`
- 0.9.6 Close [issue #44](https://github.com/selfrefactor/rambda/issues/44) - `R.reverse` mutates the array
- 0.9.5 Close [issue #45](https://github.com/selfrefactor/rambda/issues/45) - invalid Typescript typings
- 0.9.4 Add `R.reject` and `R.without` ([PR#41](https://github.com/selfrefactor/rambda/pull/41) [PR#42](https://github.com/selfrefactor/rambda/pull/42)) | Remove 'browser' field in `package.json` due to Webpack bug [4674](https://github.com/webpack/webpack/issues/4674)
- 0.9.3 Add `R.forEach` and `R.times`
- 0.9.2 Add `Typescript` definitions
- 0.9.1 Close [issue #36](https://github.com/selfrefactor/rambda/issues/36) - move current behaviour of `defaultTo` to a new method `typedDefaultTo`; make `defaultTo` follow Ramda spec; add `pathOr`; add `typedPathOr`.
- 0.9.0 Add `R.pipe` [PR#35](https://github.com/selfrefactor/rambda/pull/35)
- 0.8.9 Add `R.isNil`
- 0.8.8 Migrate to ES modules [PR33](https://github.com/selfrefactor/rambda/pull/33) | Add R.flip to the API | R.map/filter works with objects
- 0.8.7 Change `Webpack` with `Rollup` - [PR29](https://github.com/selfrefactor/rambda/pull/29)
- 0.8.6 Add `R.tap` and `R.identity`
- 0.8.5 Add `R.all`, `R.allPass`, `R.both`, `R.either` and `R.complement`
- 0.8.4 Learning to run `yarn test` before `yarn publish` the hard way
- 0.8.3 Add `R.always`, `R.T` and `R.F`
- 0.8.2 Add `concat`, `padStart`, `padEnd`, `lastIndexOf`, `toString`, `reverse`, `endsWith` and `startsWith` methods
- 0.8.1 Add `R.ifElse`
- 0.8.0 Add `R.not`, `R.includes` | Take string as condition for `R.pick` and `R.omit`
- 0.7.6 Fix incorrect implementation of `R.values`
- 0.7.5 Fix incorrect implementation of `R.omit`
- 0.7.4 [issue #13](https://github.com/selfrefactor/rambda/issues/13) - Fix `R.curry`, which used to return incorrectly `function` when called with more arguments
- 0.7.3 Close [issue #9](https://github.com/selfrefactor/rambda/issues/9) - Compile to `es2015`; Approve [PR #10](https://github.com/selfrefactor/rambda/pull/10) - add `R.addIndex` to the API
- 0.7.2 Add `Promise` support for `R.type`
- 0.7.1 Close [issue #7](https://github.com/selfrefactor/rambda/issues/7) - add `R.reduce` to the API
- 0.7.0 Close [issue #5](https://github.com/selfrefactor/rambda/issues/5) - change name of `curry` to `partialCurry`; add new method `curry`, which works just like Ramda's `curry`
- 0.6.2 Add separate documentation site via `docsify`
## Browse by category
### Function
[addIndex](#addindex)
[always](#always)
[compose](#compose)
[curry](#curry)
[F](#f)
[flip](#flip)
[identity](#identity)
[pipe](#pipe)
[T](#t)
[tap](#tap)
### Math
[add](#add)
[dec](#dec)
[divide](#divide)
[inc](#inc)
[modulo](#modulo)
[multiply](#multiply)
[subtract](#subtract)
### List
[adjust](#adjust)
[all](#all)
[any](#any)
[append](#append)
[concat](#concat)
[contains](#contains)
[drop](#drop)
[dropLast](#droplast)
[endsWith](#endswith)
[filter](#filter)
[find](#find)
[findIndex](#findindex)
[flatten](#flatten)
[forEach](#foreach)
[head](#head)
[indexOf](#indexof)
[init](#init)
[join](#join)
[last](#last)
[lastIndexOf](#lastindexof)
[length](#length)
[map](#map)
[none](#none)
[pluck](#pluck)
[prepend](#prepend)
[range](#range)
[reduce](#reduce)
[reject](#reject)
[repeat](#repeat)
[reverse](#reverse)
[sort](#sort)
[splitEvery](#splitevery)
[startsWith](#startswith)
[tail](#tail)
[take](#take)
[takeLast](#takelast)
[times](#times)
[uniq](#uniq)
[uniqWith](#uniqwith)
[update](#update)
[without](#without)
### Logic
[allPass](#allpass)
[anyPass](#anypass)
[both](#both)
[complement](#complement)
[defaultTo](#defaultto)
[either](#either)
[ifElse](#ifelse)
[not](#not)
### Object
[dissoc](#dissoc)
[has](#has)
[merge](#merge)
[omit](#omit)
[path](#path)
[pathOr](#pathor)
[pick](#pick)
[pickAll](#pickall)
[prop](#prop)
[values](#values)
### Relation
[equals](#equals)
[propEq](#propeq)
[sortBy](#sortby)
### Type
[is](#is)
[isNil](#isnil)
[type](#type)
### String
[match](#match)
[replace](#replace)
[split](#split)
[test](#test)
[toLower](#tolower)
[toString](#tostring)
[toUpper](#toupper)
[trim](#trim)
## Additional info
> Running benchmarks
- To run all benchmarks
`yarn run benchmark all`
- To run single or number of benchmarks
`yarn run benchmark add compose filter`
> Projects using Rambda
- [string-fn](https://github.com/selfrefactor/string-fn)
- [tachyons-for-js](https://github.com/devilcoders/tachyons-for-js)
- [react-append-to-body](https://github.com/jpgorman/react-append-to-body)
- [docker-voting-app-nodejs](https://github.com/subfuzion/docker-voting-app-nodejs)
- [ig-api](https://www.npmjs.com/package/ig-api)
- [ldap-authenticate](https://www.npmjs.com/package/ldap-authenticate)
- [mat-che](https://github.com/ianagbip1oti/mat-che)
> Articles about Rambda
- [Interview with Dejan Totef at SurviveJS blog](https://survivejs.com/blog/rambda-interview/)
- [Argumentation of Rambda's curry method](https://selfrefactor.gitbooks.io/blog/content/argumenting-rambdas-curry.html)