)
]
// => [1, 'DEFAULT_VALUE']
```
Try this R.propOr example in Rambda REPL
R.propOr source
```javascript
import { curry } from './curry.js'
import { defaultTo } from './defaultTo.js'
function propOrFn(
defaultValue, property, obj
){
if (!obj) return defaultValue
return defaultTo(defaultValue, obj[ property ])
}
export const propOr = curry(propOrFn)
```
Tests
```javascript
import { propOr } from './propOr.js'
test('propOr (result)', () => {
const obj = { a : 1 }
expect(propOr(
'default', 'a', obj
)).toBe(1)
expect(propOr(
'default', 'notExist', obj
)).toBe('default')
expect(propOr(
'default', 'notExist', null
)).toBe('default')
})
test('propOr (currying)', () => {
const obj = { a : 1 }
expect(propOr('default')('a', obj)).toBe(1)
expect(propOr('default', 'a')(obj)).toBe(1)
expect(propOr('default')('notExist', obj)).toBe('default')
expect(propOr('default', 'notExist')(obj)).toBe('default')
})
```
[](#propOr)
### props
```typescript
props(propsToPick: P[], obj: Record): T[]
```
It takes list with properties `propsToPick` and returns a list with property values in `obj`.
```javascript
const result = R.props(
['a', 'b'],
{a:1, c:3}
)
// => [1, undefined]
```
Try this R.props example in Rambda REPL
R.props source
```javascript
import { isArray } from './_internals/isArray.js'
import { mapArray } from './map.js'
export function props(propsToPick, obj){
if (arguments.length === 1){
return _obj => props(propsToPick, _obj)
}
if (!isArray(propsToPick)){
throw new Error('propsToPick is not a list')
}
return mapArray(prop => obj[ prop ], propsToPick)
}
```
Tests
```javascript
import { props } from './props.js'
const obj = {
a : 1,
b : 2,
}
const propsToPick = [ 'a', 'c' ]
test('happy', () => {
const result = props(propsToPick, obj)
expect(result).toEqual([ 1, undefined ])
})
test('curried', () => {
const result = props(propsToPick)(obj)
expect(result).toEqual([ 1, undefined ])
})
test('wrong input', () => {
expect(() => props(null)(obj)).toThrowErrorMatchingInlineSnapshot('"propsToPick is not a list"')
})
```
[](#props)
### propSatisfies
```typescript
propSatisfies(predicate: Predicate, property: string, obj: Record): boolean
```
It returns `true` if the object property satisfies a given predicate.
```javascript
const obj = {a: {b:1}}
const property = 'a'
const predicate = x => x?.b === 1
const result = R.propSatisfies(predicate, property, Record)
// => true
```
Try this R.propSatisfies example in Rambda REPL
R.propSatisfies source
```javascript
import { curry } from './curry.js'
import { prop } from './prop.js'
function propSatisfiesFn(
predicate, property, obj
){
return predicate(prop(property, obj))
}
export const propSatisfies = curry(propSatisfiesFn)
```
Tests
```javascript
import { propSatisfies } from './propSatisfies.js'
const obj = { a : 1 }
test('when true', () => {
expect(propSatisfies(
x => x > 0, 'a', obj
)).toBeTrue()
})
test('when false', () => {
expect(propSatisfies(x => x < 0, 'a')(obj)).toBeFalse()
})
```
[](#propSatisfies)
### random
```typescript
random(minInclusive: number, maxInclusive: number): number
```
It returns a random number between `min` inclusive and `max` inclusive.
R.random source
```javascript
export function random(min, max){
return Math.floor(Math.random() * (max - min + 1)) + min
}
```
Tests
```javascript
import { random } from './random.js'
import { range } from './range.js'
test('when returns true', () => {
range(0, 100).map(() => {
const randomResult = random(1, 10)
expect(randomResult).toBeLessThanOrEqual(10)
expect(randomResult).toBeGreaterThanOrEqual(1)
})
})
```
[](#random)
### range
```typescript
range(startInclusive: number, endExclusive: number): number[]
```
It returns list of numbers between `startInclusive` to `endExclusive` markers.
```javascript
R.range(0, 5)
// => [0, 1, 2, 3, 4]
```
Try this R.range example in Rambda REPL
R.range source
```javascript
export function range(start, end){
if (arguments.length === 1) return _end => range(start, _end)
if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){
throw new TypeError('Both arguments to range must be numbers')
}
if (end < start) return []
const len = end - start
const willReturn = Array(len)
for (let i = 0; i < len; i++){
willReturn[ i ] = start + i
}
return willReturn
}
```
Tests
```javascript
import { range } from './range.js'
test('happy', () => {
expect(range(0, 10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ])
})
test('end range is bigger than start range', () => {
expect(range(7, 3)).toEqual([])
expect(range(5, 5)).toEqual([])
})
test('with bad input', () => {
const throwMessage = 'Both arguments to range must be numbers'
expect(() => range('a', 6)).toThrowWithMessage(Error, throwMessage)
expect(() => range(6, 'z')).toThrowWithMessage(Error, throwMessage)
})
test('curry', () => {
expect(range(0)(10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ])
})
```
[](#range)
### reduce
> :boom: It passes index of the list as third argument to `reducer` function.
Try this R.reduce example in Rambda REPL
[](#reduce)
### reduceBy
Try this R.reduceBy example in Rambda REPL
[](#reduceBy)
### reject
```typescript
reject(predicate: Predicate, list: T[]): T[]
```
It has the opposite effect of `R.filter`.
```javascript
const list = [1, 2, 3, 4]
const obj = {a: 1, b: 2}
const predicate = x => x > 1
const result = [
R.reject(predicate, list),
R.reject(predicate, Record)
]
// => [[1], {a: 1}]
```
Try this R.reject example in Rambda REPL
R.reject source
```javascript
import { filter } from './filter.js'
export function reject(predicate, list){
if (arguments.length === 1) return _list => reject(predicate, _list)
return filter(x => !predicate(x), list)
}
```
Tests
```javascript
import { reject } from './reject.js'
const isOdd = n => n % 2 === 1
test('with array', () => {
expect(reject(isOdd)([ 1, 2, 3, 4 ])).toEqual([ 2, 4 ])
})
test('with object', () => {
const obj = {
a : 1,
b : 2,
c : 3,
d : 4,
}
expect(reject(isOdd, obj)).toEqual({
b : 2,
d : 4,
})
})
```
[](#reject)
### rejectIndexed
Same as `R.reject`, but it passes index/property as second argument to the predicate, when looping over arrays/objects.
Try this R.rejectIndexed example in Rambda REPL
[](#rejectIndexed)
### remove
It will remove all `toRemove` entries from `text` sequentially.
`toRemove` argument can be either a list of strings/regular expressions or a single string/regular expression.
> :boom: This is the only case where Rambdax exports clashes with Ramda API, as Ramda has `remove` method. If `Rambda.remove` is introduced, then this method will be renamed.
Try this R.remove example in Rambda REPL
[](#remove)
### removeIndex
```typescript
removeIndex(index: number, list: T[]): T[]
```
It returns a copy of `list` input with removed `index`.
```javascript
const list = [1, 2, 3, 4]
const result = R.removeIndex(1, list)
// => [1, 3, 4]
```
Try this R.removeIndex example in Rambda REPL
R.removeIndex source
```javascript
export function removeIndex(index, list){
if (arguments.length === 1) return _list => removeIndex(index, _list)
if (index <= 0) return list.slice(1)
if (index >= list.length - 1) return list.slice(0, list.length - 1)
return [ ...list.slice(0, index), ...list.slice(index + 1) ]
}
```
Tests
```javascript
import { removeIndex } from './removeIndex.js'
const list = [ 1, 2, 3, 4 ]
test('first or before first index', () => {
expect(removeIndex(-2, list)).toEqual([ 2, 3, 4 ])
expect(removeIndex(-2)(list)).toEqual([ 2, 3, 4 ])
})
test('last or after last index', () => {
expect(removeIndex(4, list)).toEqual([ 1, 2, 3 ])
expect(removeIndex(10, list)).toEqual([ 1, 2, 3 ])
})
test('middle index', () => {
expect(removeIndex(1, list)).toEqual([ 1, 3, 4 ])
expect(removeIndex(2, list)).toEqual([ 1, 2, 4 ])
})
```
[](#removeIndex)
### renameProps
```typescript
renameProps(rules: object, input: object): object
```
If property `prop` of `rules` is also a property in `input`, then rename `input` property to `rules[prop]`.
R.renameProps source
```javascript
import { mergeRight } from './mergeRight.js'
import { omit } from './omit.js'
export function renameProps(conditions, inputObject){
if (arguments.length === 1){
return inputObjectHolder => renameProps(conditions, inputObjectHolder)
}
const renamed = {}
Object.keys(conditions).forEach(condition => {
if (Object.keys(inputObject).includes(condition)){
renamed[ conditions[ condition ] ] = inputObject[ condition ]
}
})
return mergeRight(renamed, omit(Object.keys(conditions), inputObject))
}
```
Tests
```javascript
import { renameProps } from './renameProps.js'
test('renameProps', () => {
const rules = {
f : 'foo',
b : 'bar',
q : 'x',
}
const input = {
f : 1,
b : 2,
a : 3,
}
const result = renameProps(rules, input)
const expectedResult = {
foo : 1,
bar : 2,
a : 3,
}
expect(result).toEqual(expectedResult)
})
test('curry', () => {
const rules = {
f : 'foo',
b : 'bar',
}
const input = {
f : 1,
b : 2,
}
const result = renameProps(rules)(input)
const expectedResult = {
foo : 1,
bar : 2,
}
expect(result).toEqual(expectedResult)
})
```
[](#renameProps)
### repeat
```typescript
repeat(x: T): (timesToRepeat: number) => T[]
```
```javascript
R.repeat('foo', 3)
// => ['foo', 'foo', 'foo']
```
Try this R.repeat example in Rambda REPL
R.repeat source
```javascript
export function repeat(x, timesToRepeat){
if (arguments.length === 1){
return _timesToRepeat => repeat(x, _timesToRepeat)
}
return Array(timesToRepeat).fill(x)
}
```
Tests
```javascript
import { repeat } from './repeat.js'
test('repeat', () => {
expect(repeat('')(3)).toEqual([ '', '', '' ])
expect(repeat('foo', 3)).toEqual([ 'foo', 'foo', 'foo' ])
const obj = {}
const arr = repeat(obj, 3)
expect(arr).toEqual([ {}, {}, {} ])
expect(arr[ 0 ] === arr[ 1 ]).toBeTrue()
})
```
[](#repeat)
### replace
```typescript
replace(strOrRegex: RegExp | string, replacer: RegExpReplacer, str: string): string
```
It replaces `strOrRegex` found in `str` with `replacer`.
```javascript
const strOrRegex = /o/g
const result = R.replace(strOrRegex, '|0|', 'foo')
// => 'f|0||0|'
```
Try this R.replace example in Rambda REPL
R.replace source
```javascript
import { curry } from './curry.js'
function replaceFn(
pattern, replacer, str
){
return str.replace(pattern, replacer)
}
export const replace = curry(replaceFn)
```
Tests
```javascript
import { replace } from './replace.js'
test('happy', () => {
expect(replace(
/\s/g, '|', 'foo bar baz'
)).toBe('foo|bar|baz')
})
test('with function as replacer input', () => {
expect(replace(
/\s/g,
(
match, offset, str
) => {
expect(match).toBe(' ')
expect([ 3, 7 ].includes(offset)).toBeTrue()
expect(str).toBe('foo bar baz')
return '|'
},
'foo bar baz'
)).toBe('foo|bar|baz')
})
```
[](#replace)
### replaceAll
```typescript
replaceAll(patterns: (RegExp | string)[], replacer: string, input: string): string
```
Same as `R.replace` but it accepts array of string and regular expressions instead of a single value.
```javascript
const replacer = '|'
const patterns = [ /foo/g, 'bar' ]
const input = 'foo bar baz foo bar'
const result = R.replaceAll(patterns, replacer, input)
// => '| | baz | bar'
```
Try this R.replaceAll example in Rambda REPL
R.replaceAll source
```javascript
import { curry } from './curry.js'
import { ok } from './ok.js'
function replaceAllFn(
patterns, replacer, input
){
ok(
patterns, replacer, input
)(
Array, String, String
)
let text = input
patterns.forEach(singlePattern => {
text = text.replace(singlePattern, replacer)
})
return text
}
export const replaceAll = curry(replaceAllFn)
```
Tests
```javascript
import {replaceAll} from './replaceAll.js'
const replacer = '|'
const patterns = [/foo/g, 'bar']
const input = 'foo bar baz foo bar'
test('happy', () => {
const result = replaceAll(patterns, replacer, input)
const expected = '| | baz | bar'
expect(result).toEqual(expected)
})
test('throws when wrong patterns', () => {
expect(() => replaceAll({}, replacer, input))
.toThrowErrorMatchingInlineSnapshot(`
"Failed R.ok -
reason: {"input":{},"schema":"array"}
all inputs: [{},"|","foo bar baz foo bar"]
all schemas: ["array","string","string"]"
`)
})
test('throws when wrong input', () => {
expect(() => replaceAll(patterns, replacer, []))
.toThrowErrorMatchingInlineSnapshot(`
"Failed R.ok -
reason: {"input":[],"schema":"string"}
all inputs: [[{},"bar"],"|",[]]
all schemas: ["array","string","string"]"
`)
})
test('throws when wrong replacer', () => {
expect(() => replaceAll(patterns, null, input))
.toThrowErrorMatchingInlineSnapshot(`
"Failed R.ok -
reason: {"input":null,"schema":"string"}
all inputs: [[{},"bar"],null,"foo bar baz foo bar"]
all schemas: ["array","string","string"]"
`)
})
```
[](#replaceAll)
### reset
```typescript
reset(): void
```
> :boom: `R.getter` method contains explanations, tests and source information of `R.reset`, `R.setter` and `R.getter` methods.
[](#reset)
### reverse
```typescript
reverse(input: T[]): T[]
```
It returns a reversed copy of list or string `input`.
```javascript
const result = [
R.reverse('foo'),
R.reverse([1, 2, 3])
]
// => ['oof', [3, 2, 1]
```
Try this R.reverse example in Rambda REPL
R.reverse source
```javascript
export function reverse(listOrString) {
if (typeof listOrString === 'string') {
return listOrString.split('').reverse().join('')
}
const clone = listOrString.slice()
return clone.reverse()
}
```
Tests
```javascript
import {reverse} from './reverse.js'
test('happy', () => {
expect(reverse([1, 2, 3])).toEqual([3, 2, 1])
})
test('with string', () => {
expect(reverse('baz')).toBe('zab')
})
test("it doesn't mutate", () => {
const arr = [1, 2, 3]
expect(reverse(arr)).toEqual([3, 2, 1])
expect(arr).toEqual([1, 2, 3])
})
```
[](#reverse)
### set
```typescript
set(lens: Lens): {
(a: A): (obj: S) => S
(a: A, obj: S): S
}
```
It returns a copied **Object** or **Array** with modified `lens` focus set to `replacer` value.
```javascript
const input = {x: 1, y: 2}
const xLens = R.lensProp('x')
const result = [
R.set(xLens, 4, input),
R.set(xLens, 8, input)
]
// => [{x: 4, y: 2}, {x: 8, y: 2}]
```
Try this R.set example in Rambda REPL
R.set source
```javascript
import {always} from './always.js'
import {curry} from './curry.js'
import {over} from './over.js'
function setFn(lens, replacer, x) {
return over(lens, always(replacer), x)
}
export const set = curry(setFn)
```
Tests
```javascript
import {assoc} from './assoc.js'
import {lens} from './lens.js'
import {lensIndex} from './lensIndex.js'
import {lensPath} from './lensPath.js'
import {prop} from './prop.js'
import {set} from './set.js'
const testObject = {
foo: 'bar',
baz: {
a: 'x',
b: 'y',
},
}
test('assoc lens', () => {
const assocLens = lens(prop('foo'), assoc('foo'))
const result = set(assocLens, 'FOO', testObject)
const expected = {
...testObject,
foo: 'FOO',
}
expect(result).toEqual(expected)
})
test('path lens', () => {
const pathLens = lensPath('baz.a')
const result = set(pathLens, 'z', testObject)
const expected = {
...testObject,
baz: {
a: 'z',
b: 'y',
},
}
expect(result).toEqual(expected)
})
test('index lens', () => {
const indexLens = lensIndex(0)
const result = set(indexLens, 3, [1, 2])
expect(result).toEqual([3, 2])
})
```
[](#set)
### setter
```typescript
setter(keyOrObject: string | object, value?: any): void
```
> :boom: `R.getter` method contains explanations, tests and source information of `R.reset`, `R.setter` and `R.getter` methods.
[](#setter)
### shuffle
```typescript
shuffle(list: T[]): T[]
```
It returns a randomized copy of array.
R.shuffle source
```javascript
export function shuffle(arrayRaw){
const array = arrayRaw.concat()
let counter = array.length
while (counter > 0){
const index = Math.floor(Math.random() * counter)
counter--
const temp = array[ counter ]
array[ counter ] = array[ index ]
array[ index ] = temp
}
return array
}
```
Tests
```javascript
import { range } from './range.js'
import { shuffle } from './shuffle.js'
import { uniq } from './uniq.js'
test('happy', () => {
const list = range(0, 7)
const result = range(0, 300).map(() => shuffle(list))
const allUniq = uniq(result)
expect(allUniq.length > 150).toBeTrue()
})
```
[](#shuffle)
### slice
```typescript
slice(from: number, to: number, input: string): string
```
```javascript
const list = [0, 1, 2, 3, 4, 5]
const str = 'FOO_BAR'
const from = 1
const to = 4
const result = [
R.slice(from, to, str),
R.slice(from, to, list)
]
// => ['OO_', [1, 2, 3]]
```
Try this R.slice example in Rambda REPL
R.slice source
```javascript
import { curry } from './curry.js'
function sliceFn(
from, to, list
){
return list.slice(from, to)
}
export const slice = curry(sliceFn)
```
Tests
```javascript
import { slice } from './slice.js'
test('slice', () => {
expect(slice(
1, 3, [ 'a', 'b', 'c', 'd' ]
)).toEqual([ 'b', 'c' ])
expect(slice(
1, Infinity, [ 'a', 'b', 'c', 'd' ]
)).toEqual([ 'b', 'c', 'd' ])
expect(slice(
0, -1, [ 'a', 'b', 'c', 'd' ]
)).toEqual([ 'a', 'b', 'c' ])
expect(slice(
-3, -1, [ 'a', 'b', 'c', 'd' ]
)).toEqual([ 'b', 'c' ])
expect(slice(
0, 3, 'ramda'
)).toBe('ram')
})
```
[](#slice)
### sort
```typescript
sort(sortFn: (a: T, b: T) => number, list: T[]): T[]
```
It returns copy of `list` sorted by `sortFn` function, where `sortFn` needs to return only `-1`, `0` or `1`.
```javascript
const list = [
{a: 2},
{a: 3},
{a: 1}
]
const sortFn = (x, y) => {
return x.a > y.a ? 1 : -1
}
const result = R.sort(sortFn, list)
const expected = [
{a: 1},
{a: 2},
{a: 3}
]
// => `result` is equal to `expected`
```
Try this R.sort example in Rambda REPL
R.sort source
```javascript
import { cloneList } from './_internals/cloneList.js'
export function sort(sortFn, list){
if (arguments.length === 1) return _list => sort(sortFn, _list)
return cloneList(list).sort(sortFn)
}
```
Tests
```javascript
import { sort } from './sort.js'
const fn = (a, b) => a > b ? 1 : -1
test('sort', () => {
expect(sort((a, b) => a - b)([ 2, 3, 1 ])).toEqual([ 1, 2, 3 ])
})
test('it doesn\'t mutate', () => {
const list = [ 'foo', 'bar', 'baz' ]
expect(sort(fn, list)).toEqual([ 'bar', 'baz', 'foo' ])
expect(list[ 0 ]).toBe('foo')
expect(list[ 1 ]).toBe('bar')
expect(list[ 2 ]).toBe('baz')
})
```
[](#sort)
### sortBy
```typescript
sortBy(sortFn: (a: T) => Ord, list: T[]): T[]
```
It returns copy of `list` sorted by `sortFn` function, where `sortFn` function returns a value to compare, i.e. it doesn't need to return only `-1`, `0` or `1`.
```javascript
const list = [
{a: 2},
{a: 3},
{a: 1}
]
const sortFn = x => x.a
const result = R.sortBy(sortFn, list)
const expected = [
{a: 1},
{a: 2},
{a: 3}
]
// => `result` is equal to `expected`
```
Try this R.sortBy example in Rambda REPL
R.sortBy source
```javascript
import { cloneList } from './_internals/cloneList.js'
export function sortBy(sortFn, list){
if (arguments.length === 1) return _list => sortBy(sortFn, _list)
const clone = cloneList(list)
return clone.sort((a, b) => {
const aSortResult = sortFn(a)
const bSortResult = sortFn(b)
if (aSortResult === bSortResult) return 0
return aSortResult < bSortResult ? -1 : 1
})
}
```
Tests
```javascript
import { compose } from './compose.js'
import { prop } from './prop.js'
import { sortBy } from './sortBy.js'
import { toLower } from './toLower.js'
test('happy', () => {
const input = [ { a : 2 }, { a : 1 }, { a : 1 }, { a : 3 } ]
const expected = [ { a : 1 }, { a : 1 }, { a : 2 }, { a : 3 } ]
const result = sortBy(x => x.a)(input)
expect(result).toEqual(expected)
})
test('with compose', () => {
const alice = {
name : 'ALICE',
age : 101,
}
const bob = {
name : 'Bob',
age : -10,
}
const clara = {
name : 'clara',
age : 314.159,
}
const people = [ clara, bob, alice ]
const sortByNameCaseInsensitive = sortBy(compose(toLower, prop('name')))
expect(sortByNameCaseInsensitive(people)).toEqual([ alice, bob, clara ])
})
```
[](#sortBy)
### sortByPath
```typescript
sortByPath(sortPath: Path, list: T[]): T[]
```
It returns copy of `list` sorted by `sortPath` value.
As `sortPath` is passed to `R.path`, it can be either a string or an array of strings.
```javascript
const list = [
{a: {b: 2}},
{a: {b: 1}},
{a: {b: 3}}
]
const result = R.sortByPath('a.b', list)
const expected = [
{a: {b: 1}},
{a: {b: 2}},
{a: {b: 3}}
]
// => `result` is equal to `expected`
```
Try this R.sortByPath example in Rambda REPL
R.sortByPath source
```javascript
import { path } from './path.js'
import { sortBy } from './sortBy.js'
export function sortByPath(sortPath, list){
if (arguments.length === 1) return _list => sortByPath(sortPath, _list)
return sortBy(path(sortPath), list)
}
```
Tests
```javascript
import { sortByPath } from './sortByPath.js'
const list = [ { a : { b : 3 } }, { a : { b : 1 } }, { a : { b : 2 } } ]
const sorted = [ { a : { b : 1 } }, { a : { b : 2 } }, { a : { b : 3 } } ]
test('with string as path', () => {
expect(sortByPath('a.b', list)).toEqual(sorted)
})
test('with list of strings as path', () => {
expect(sortByPath([ 'a', 'b' ], list)).toEqual(sorted)
})
test('with string as path - curried', () => {
expect(sortByPath('a.b')(list)).toEqual(sorted)
})
test('with list of strings as path - curried', () => {
expect(sortByPath([ 'a', 'b' ])(list)).toEqual(sorted)
})
```
[](#sortByPath)
### sortByProps
```typescript
sortByProps(sortPaths: string[], list: T[]): T[]
```
It returns sorted copy of `list` of objects.
Sorting is done using a list of strings, each representing a path. Two members `a` and `b` from `list` can be sorted if both return a value for a given path. If the value is equal, then the next member of `sortPaths`(if there is such) will be used in order to find difference between `a` and `b`.
```javascript
const list = [
{a: {b: 2}},
{a: {b: 1}},
{a: {b: 3}}
]
const result = R.sortByProps(['a.b'], list)
const expected = [
{a: {b: 1}},
{a: {b: 2}},
{a: {b: 3}}
]
// => `result` is equal to `expected`
```
Try this R.sortByProps example in Rambda REPL
R.sortByProps source
```javascript
import { path } from './path.js'
function singleSort(
a, b, sortPaths
){
let toReturn = 0
sortPaths.forEach(singlePath => {
if (toReturn !== 0) return
const aResult = path(singlePath, a)
const bResult = path(singlePath, b)
if ([ aResult, bResult ].includes(undefined)) return
if (aResult === bResult) return
toReturn = aResult > bResult ? 1 : -1
})
return toReturn
}
export function sortByProps(sortPaths, list){
if (arguments.length === 1) return _list => sortByProps(sortPaths, _list)
const clone = list.slice()
clone.sort((a, b) => singleSort(
a, b, sortPaths
))
return clone
}
```
Tests
```javascript
import { sortByProps } from './sortByProps.js'
const list = [ { a : { b : 3 } }, { a : { b : 2 } }, { a : { b : 1 } } ]
const sorted = [ { a : { b : 1 } }, { a : { b : 2 } }, { a : { b : 3 } } ]
test('wrong paths are ignored', () => {
expect(sortByProps([ 'foo.bar', 'a.c', 'a.b', 'a.d' ], list)).toEqual(sorted)
})
test('skip sort when path results are equal', () => {
const input = [
{
a : {
b : 0,
c : 2,
},
},
{
a : {
b : 0,
c : 1,
},
},
]
expect(sortByProps([ 'a.b', 'a.d' ], input)).toEqual(input)
})
test('when list is already sorted', () => {
const input = [
{
a : {
b : 0,
c : 1,
},
},
{
a : {
b : 0,
c : 2,
},
},
]
expect(sortByProps([ 'a.b', 'a.c' ])(input)).toEqual(input)
})
```
[](#sortByProps)
### sortObject
```typescript
sortObject(predicate: SortObjectPredicate, input: { [key: string]: T }): { [keyOutput: string]: T }
```
It returns a sorted version of `input` object.
```javascript
const predicate = (propA, propB, valueA, valueB) => valueA > valueB ? -1 : 1
const result = R.sortObject(predicate, {a:1, b: 4, c: 2})
// => {b: 4, c: 2, a: 1}
```
Try this R.sortObject example in Rambda REPL
R.sortObject source
```javascript
import { sort } from './sort.js'
export function sortObject(predicate, obj){
if (arguments.length === 1){
return _obj => sortObject(predicate, _obj)
}
const keys = Object.keys(obj)
const sortedKeys = sort((a, b) => predicate(
a, b, obj[ a ], obj[ b ]
), keys)
const toReturn = {}
sortedKeys.forEach(singleKey => {
toReturn[ singleKey ] = obj[ singleKey ]
})
return toReturn
}
```
Tests
```javascript
import { runTests } from 'helpers-fn'
import { allTrue } from './allTrue.js'
import { equals } from './equals.js'
import { sortObject } from './sortObject.js'
const obj = {
c : 1,
a : 2,
b : 3,
}
const predicateA = (
propA, propB, valueA, valueB
) => propA > propB ? -1 : 1
const expectationA = [ 'c', 'b', 'a' ]
const predicateB = (
propA, propB, valueA, valueB
) => propA < propB ? -1 : 1
const expectationB = [ 'a', 'b', 'c' ]
const predicateC = (
propA, propB, valueA, valueB
) =>
valueA > valueB ? -1 : 1
const expectationC = [ 'b', 'a', 'c' ]
const fn = ([ predicate, expectation ]) => {
const result = sortObject(predicate, obj)
const curriedResult = sortObject(predicate)(obj)
const sortedKeys = Object.keys(result)
const sortedKeysCurried = Object.keys(curriedResult)
const isSameObject = equals(obj, result)
const isSameObjectCurried = equals(obj, curriedResult)
return allTrue(
isSameObject,
isSameObjectCurried,
equals(sortedKeys, expectation),
equals(sortedKeysCurried, expectation)
)
}
const testData = {
label : 'foo',
data : [
{ ok : [ predicateA, expectationA ] },
{ ok : [ predicateB, expectationB ] },
{ ok : [ predicateC, expectationC ] },
],
fn,
}
runTests(testData)
```
[](#sortObject)
### sortWith
Try this R.sortWith example in Rambda REPL
[](#sortWith)
### split
```typescript
split(separator: string | RegExp): (str: string) => string[]
```
Curried version of `String.prototype.split`
```javascript
const str = 'foo|bar|baz'
const separator = '|'
const result = R.split(separator, str)
// => [ 'foo', 'bar', 'baz' ]
```
Try this R.split example in Rambda REPL
R.split source
```javascript
export function split(separator, str){
if (arguments.length === 1) return _str => split(separator, _str)
return str.split(separator)
}
```
Tests
```javascript
import { split } from './split.js'
const str = 'foo|bar|baz'
const splitChar = '|'
const expected = [ 'foo', 'bar', 'baz' ]
test('happy', () => {
expect(split(splitChar, str)).toEqual(expected)
})
test('curried', () => {
expect(split(splitChar)(str)).toEqual(expected)
})
```
[](#split)
### splitAt
```typescript
splitAt(index: number, input: T[]): [T[], T[]]
```
It splits string or array at a given index.
```javascript
const list = [ 1, 2, 3 ]
const result = R.splitAt(2, list)
// => [[ 1, 2 ], [ 3 ]]
```
Try this R.splitAt example in Rambda REPL
R.splitAt source
```javascript
import { isArray } from './_internals/isArray.js'
import { drop } from './drop.js'
import { maybe } from './maybe.js'
import { take } from './take.js'
export function splitAt(index, input){
if (arguments.length === 1){
return _list => splitAt(index, _list)
}
if (!input) throw new TypeError(`Cannot read property 'slice' of ${ input }`)
if (!isArray(input) && typeof input !== 'string') return [ [], [] ]
const correctIndex = maybe(
index < 0,
input.length + index < 0 ? 0 : input.length + index,
index
)
return [ take(correctIndex, input), drop(correctIndex, input) ]
}
```
Tests
```javascript
import { splitAt as splitAtRamda } from 'ramda'
import { splitAt } from './splitAt.js'
const list = [ 1, 2, 3 ]
const str = 'foo bar'
test('with array', () => {
const result = splitAt(2, list)
expect(result).toEqual([ [ 1, 2 ], [ 3 ] ])
})
test('with array - index is negative number', () => {
const result = splitAt(-6, list)
expect(result).toEqual([ [], list ])
})
test('with array - index is out of scope', () => {
const result = splitAt(4, list)
expect(result).toEqual([ [ 1, 2, 3 ], [] ])
})
test('with string', () => {
const result = splitAt(4, str)
expect(result).toEqual([ 'foo ', 'bar' ])
})
test('with string - index is negative number', () => {
const result = splitAt(-2, str)
expect(result).toEqual([ 'foo b', 'ar' ])
})
test('with string - index is out of scope', () => {
const result = splitAt(10, str)
expect(result).toEqual([ str, '' ])
})
test('with array - index is out of scope', () => {
const result = splitAt(4)(list)
expect(result).toEqual([ [ 1, 2, 3 ], [] ])
})
const badInputs = [ 1, true, /foo/g, {} ]
const throwingBadInputs = [ null, undefined ]
test('with bad inputs', () => {
throwingBadInputs.forEach(badInput => {
expect(() => splitAt(1, badInput)).toThrowWithMessage(TypeError,
`Cannot read property 'slice' of ${ badInput }`)
expect(() => splitAtRamda(1, badInput)).toThrowWithMessage(TypeError,
`Cannot read properties of ${ badInput } (reading 'slice')`)
})
badInputs.forEach(badInput => {
const result = splitAt(1, badInput)
const ramdaResult = splitAtRamda(1, badInput)
expect(result).toEqual(ramdaResult)
})
})
```
[](#splitAt)
### splitEvery
```typescript
splitEvery(sliceLength: number, input: T[]): (T[])[]
```
It splits `input` into slices of `sliceLength`.
```javascript
const result = [
R.splitEvery(2, [1, 2, 3]),
R.splitEvery(3, 'foobar')
]
const expected = [
[[1, 2], [3]],
['foo', 'bar']
]
// => `result` is equal to `expected`
```
Try this R.splitEvery example in Rambda REPL
R.splitEvery source
```javascript
export function splitEvery(sliceLength, listOrString){
if (arguments.length === 1){
return _listOrString => splitEvery(sliceLength, _listOrString)
}
if (sliceLength < 1){
throw new Error('First argument to splitEvery must be a positive integer')
}
const willReturn = []
let counter = 0
while (counter < listOrString.length){
willReturn.push(listOrString.slice(counter, counter += sliceLength))
}
return willReturn
}
```
Tests
```javascript
import { splitEvery } from './splitEvery.js'
test('happy', () => {
expect(splitEvery(3, [ 1, 2, 3, 4, 5, 6, 7 ])).toEqual([
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7 ],
])
expect(splitEvery(3)('foobarbaz')).toEqual([ 'foo', 'bar', 'baz' ])
})
test('with bad input', () => {
expect(() =>
expect(splitEvery(0)('foo')).toEqual([ 'f', 'o', 'o' ])).toThrowErrorMatchingInlineSnapshot('"First argument to splitEvery must be a positive integer"')
})
```
[](#splitEvery)
### splitWhen
```typescript
splitWhen(predicate: Predicate, list: U[]): (U[])[]
```
It splits `list` to two arrays according to a `predicate` function.
The first array contains all members of `list` before `predicate` returns `true`.
```javascript
const list = [1, 2, 1, 2]
const result = R.splitWhen(R.equals(2), list)
// => [[1], [2, 1, 2]]
```
Try this R.splitWhen example in Rambda REPL
R.splitWhen source
```javascript
export function splitWhen(predicate, input){
if (arguments.length === 1){
return _input => splitWhen(predicate, _input)
}
if (!input)
throw new TypeError(`Cannot read property 'length' of ${ input }`)
const preFound = []
const postFound = []
let found = false
let counter = -1
while (counter++ < input.length - 1){
if (found){
postFound.push(input[ counter ])
} else if (predicate(input[ counter ])){
postFound.push(input[ counter ])
found = true
} else {
preFound.push(input[ counter ])
}
}
return [ preFound, postFound ]
}
```
Tests
```javascript
import { splitWhen as splitWhenRamda } from 'ramda'
import { equals } from './equals.js'
import { splitWhen } from './splitWhen.js'
const list = [ 1, 2, 1, 2 ]
test('happy', () => {
const result = splitWhen(equals(2), list)
expect(result).toEqual([ [ 1 ], [ 2, 1, 2 ] ])
})
test('when predicate returns false', () => {
const result = splitWhen(equals(3))(list)
expect(result).toEqual([ list, [] ])
})
const badInputs = [ 1, true, /foo/g, {} ]
const throwingBadInputs = [ null, undefined ]
test('with bad inputs', () => {
throwingBadInputs.forEach(badInput => {
expect(() => splitWhen(equals(2), badInput)).toThrowWithMessage(TypeError,
`Cannot read property 'length' of ${ badInput }`)
expect(() => splitWhenRamda(equals(2), badInput)).toThrowWithMessage(TypeError,
`Cannot read properties of ${ badInput } (reading 'length')`)
})
badInputs.forEach(badInput => {
const result = splitWhen(equals(2), badInput)
const ramdaResult = splitWhenRamda(equals(2), badInput)
expect(result).toEqual(ramdaResult)
})
})
```
[](#splitWhen)
### startsWith
```typescript
startsWith(question: T, input: string): boolean
```
When iterable is a string, then it behaves as `String.prototype.startsWith`.
When iterable is a list, then it uses R.equals to determine if the target list starts in the same way as the given target.
> :boom: It doesn't work with arrays unlike its corresponding **Ramda** method.
```javascript
const str = 'foo-bar'
const list = [{a:1}, {a:2}, {a:3}]
const result = [
R.startsWith('foo', str),
R.startsWith([{a:1}, {a:2}], list)
]
// => [true, true]
```
Try this R.startsWith example in Rambda REPL
R.startsWith source
```javascript
import { isArray } from './_internals/isArray.js'
import { equals } from './equals.js'
export function startsWith(question, iterable){
if (arguments.length === 1)
return _iterable => startsWith(question, _iterable)
if (typeof iterable === 'string'){
return iterable.startsWith(question)
}
if (!isArray(question)) return false
let correct = true
const filtered = question.filter((x, index) => {
if (!correct) return false
const result = equals(x, iterable[ index ])
if (!result) correct = false
return result
})
return filtered.length === question.length
}
```
Tests
```javascript
import { startsWith as startsWithRamda } from 'ramda'
import { compareCombinations } from './_internals/testUtils.js'
import { possibleIterables, possibleTargets } from './endsWith.spec.js'
import { startsWith } from './startsWith.js'
test('with string', () => {
expect(startsWith('foo', 'foo-bar')).toBeTrue()
expect(startsWith('baz')('foo-bar')).toBeFalse()
})
test('use R.equals with array', () => {
const list = [ { a : 1 }, { a : 2 }, { a : 3 } ]
expect(startsWith({ a : 1 }, list)).toBeFalse()
expect(startsWith([ { a : 1 } ], list)).toBeTrue()
expect(startsWith([ { a : 1 }, { a : 2 } ], list)).toBeTrue()
expect(startsWith(list, list)).toBeTrue()
expect(startsWith([ { a : 2 } ], list)).toBeFalse()
})
describe('brute force', () => {
compareCombinations({
fn : startsWith,
fnRamda : startsWithRamda,
firstInput : possibleTargets,
secondInput : possibleIterables,
callback : errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
{
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 0,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 0,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 32,
}
`)
},
})
})
```
[](#startsWith)
### subtract
Curried version of `x - y`
Try this R.subtract example in Rambda REPL
[](#subtract)
### sum
```typescript
sum(list: number[]): number
```
```javascript
R.sum([1, 2, 3, 4, 5])
// => 15
```
Try this R.sum example in Rambda REPL
R.sum source
```javascript
export function sum(list){
return list.reduce((prev, current) => prev + current, 0)
}
```
Tests
```javascript
import { sum } from './sum.js'
test('happy', () => {
expect(sum([ 1, 2, 3, 4, 5 ])).toBe(15)
})
```
[](#sum)
### swap
Try this R.swap example in Rambda REPL
[](#swap)
### switcher
```typescript
switcher(valueToMatch: any): Switchem
```
Edited fork of [Switchem](https://github.com/planttheidea/switchem) library.
The method return a value if the matched option is a value.
If the matched option is a function, then `R.switcher` returns a function which expects input. Tests of the method explain it better than this short description.
`R.equals` is used to determine equality.
```javascript
const valueToMatch = {foo: 1}
const result = R.switcher(valueToMatch)
.is('baz', 'is baz')
.is(x => typeof x === 'boolean', 'is boolean')
.is({foo: 1}, 'Property foo is 1')
.default('is bar')
// => 'Property foo is 1'
```
Try this R.switcher example in Rambda REPL
R.switcher source
```javascript
import { equals } from './equals.js'
const NO_MATCH_FOUND = Symbol ? Symbol('NO_MATCH_FOUND') : undefined
const getMatchingKeyValuePair = (
cases, testValue, defaultValue
) => {
let iterationValue
for (let index = 0; index < cases.length; index++){
iterationValue = cases[ index ].test(testValue)
if (iterationValue !== NO_MATCH_FOUND){
return iterationValue
}
}
return defaultValue
}
const isEqual = (testValue, matchValue) => {
const willReturn =
typeof testValue === 'function' ?
testValue(matchValue) :
equals(testValue, matchValue)
return willReturn
}
const is = (testValue, matchResult = true) => ({
key : testValue,
test : matchValue =>
isEqual(testValue, matchValue) ? matchResult : NO_MATCH_FOUND,
})
class Switchem{
constructor(
defaultValue, cases, willMatch
){
if (cases === undefined && willMatch === undefined){
this.cases = []
this.defaultValue = undefined
this.willMatch = defaultValue
} else {
this.cases = cases
this.defaultValue = defaultValue
this.willMatch = willMatch
}
return this
}
default(defaultValue){
const holder = new Switchem(
defaultValue, this.cases, this.willMatch
)
return holder.match(this.willMatch)
}
is(testValue, matchResult){
return new Switchem(
this.defaultValue,
[ ...this.cases, is(testValue, matchResult) ],
this.willMatch
)
}
match(matchValue){
return getMatchingKeyValuePair(
this.cases, matchValue, this.defaultValue
)
}
}
export function switcher(input){
return new Switchem(input)
}
```
Tests
```javascript
import { add } from './add.js'
import { switcher } from './switcher.js'
import { tap } from './tap.js'
import { trim } from './trim.js'
test('with undefined', () => {
const result = switcher(undefined)
.is(x => x === 0, '0')
.is(x => x === undefined, 'UNDEFINED')
.default('3')
expect(result).toBe('UNDEFINED')
})
test('happy', () => {
const a = true
const b = false
const result = switcher([ a, b ])
.is([ false, false ], '0')
.is([ false, true ], '1')
.is([ true, true ], '2')
.default('3')
expect(result).toBe('3')
})
test('can compare objects', () => {
const result = switcher({ a : 1 })
.is({ a : 1 }, 'it is object')
.is('baz', 'it is baz')
.default('it is default')
expect(result).toBe('it is object')
})
test('options are mixture of functions and values - input match function', () => {
const fn = switcher('foo').is('bar', 1)
.is('foo', add(1))
.default(1000)
expect(fn(2)).toBe(3)
})
test('options are mixture of functions and values - input match value', () => {
const result = switcher('bar').is('bar', 1)
.is('foo', add(1))
.default(1000)
expect(result).toBe(1)
})
test('return function if all options are functions', () => {
const fn = switcher('foo').is('bar', tap)
.is('foo', add(1))
.default(trim)
expect(fn(2)).toBe(3)
})
const switchFn = input =>
switcher(input)
.is(x => x.length && x.length === 7, 'has length of 7')
.is('baz', 'it is baz')
.default('it is default')
test('works with function as condition', () => {
expect(switchFn([ 0, 1, 2, 3, 4, 5, 6 ])).toBe('has length of 7')
})
test('works with string as condition', () => {
expect(switchFn('baz')).toBe('it is baz')
})
test('fallback to default input when no matches', () => {
expect(switchFn(1)).toBe('it is default')
})
```
[](#switcher)
### symmetricDifference
```typescript
symmetricDifference(x: T[], y: T[]): T[]
```
It returns a merged list of `x` and `y` with all equal elements removed.
`R.equals` is used to determine equality.
```javascript
const x = [ 1, 2, 3, 4 ]
const y = [ 3, 4, 5, 6 ]
const result = R.symmetricDifference(x, y)
// => [ 1, 2, 5, 6 ]
```
Try this R.symmetricDifference example in Rambda REPL
R.symmetricDifference source
```javascript
import { concat } from './concat.js'
import { filter } from './filter.js'
import { includes } from './includes.js'
export function symmetricDifference(x, y){
if (arguments.length === 1){
return _y => symmetricDifference(x, _y)
}
return concat(filter(value => !includes(value, y), x),
filter(value => !includes(value, x), y))
}
```
Tests
```javascript
import { symmetricDifference } from './symmetricDifference.js'
test('symmetricDifference', () => {
const list1 = [ 1, 2, 3, 4 ]
const list2 = [ 3, 4, 5, 6 ]
expect(symmetricDifference(list1)(list2)).toEqual([ 1, 2, 5, 6 ])
expect(symmetricDifference([], [])).toEqual([])
})
test('symmetricDifference with objects', () => {
const list1 = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
const list2 = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
expect(symmetricDifference(list1)(list2)).toEqual([
{ id : 1 },
{ id : 2 },
{ id : 5 },
{ id : 6 },
])
})
```
[](#symmetricDifference)
### T
```typescript
T(): boolean
```
```javascript
R.T()
// => true
```
Try this R.T example in Rambda REPL
R.T source
```javascript
export function T(){
return true
}
```
[](#T)
### tail
```typescript
tail(input: T): T extends [any, ...infer U] ? U : [...T]
```
It returns all but the first element of `input`.
```javascript
const result = [
R.tail([1, 2, 3]),
R.tail('foo')
]
// => [[2, 3], 'oo']
```
Try this R.tail example in Rambda REPL
R.tail source
```javascript
import { drop } from './drop.js'
export function tail(listOrString){
return drop(1, listOrString)
}
```
Tests
```javascript
import { tail } from './tail.js'
test('tail', () => {
expect(tail([ 1, 2, 3 ])).toEqual([ 2, 3 ])
expect(tail([ 1, 2 ])).toEqual([ 2 ])
expect(tail([ 1 ])).toEqual([])
expect(tail([])).toEqual([])
expect(tail('abc')).toBe('bc')
expect(tail('ab')).toBe('b')
expect(tail('a')).toBe('')
expect(tail('')).toBe('')
})
```
[](#tail)
### take
```typescript
take(howMany: number, input: T): T extends string ? string : T
```
It returns the first `howMany` elements of `input`.
```javascript
const howMany = 2
const result = [
R.take(howMany, [1, 2, 3]),
R.take(howMany, 'foobar'),
]
// => [[1, 2], 'fo']
```
Try this R.take example in Rambda REPL
R.take source
```javascript
import baseSlice from './_internals/baseSlice.js'
export function take(howMany, listOrString){
if (arguments.length === 1)
return _listOrString => take(howMany, _listOrString)
if (howMany < 0) return listOrString.slice()
if (typeof listOrString === 'string') return listOrString.slice(0, howMany)
return baseSlice(
listOrString, 0, howMany
)
}
```
Tests
```javascript
import { take } from './take.js'
test('happy', () => {
const arr = [ 'foo', 'bar', 'baz' ]
expect(take(1, arr)).toEqual([ 'foo' ])
expect(arr).toEqual([ 'foo', 'bar', 'baz' ])
expect(take(2)([ 'foo', 'bar', 'baz' ])).toEqual([ 'foo', 'bar' ])
expect(take(3, [ 'foo', 'bar', 'baz' ])).toEqual([ 'foo', 'bar', 'baz' ])
expect(take(4, [ 'foo', 'bar', 'baz' ])).toEqual([ 'foo', 'bar', 'baz' ])
expect(take(3)('rambda')).toBe('ram')
})
test('with negative index', () => {
expect(take(-1, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
expect(take(-Infinity, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
})
test('with zero index', () => {
expect(take(0, [ 1, 2, 3 ])).toEqual([])
})
```
[](#take)
### takeLast
```typescript
takeLast(howMany: number, input: T): T extends string ? string : T
```
It returns the last `howMany` elements of `input`.
```javascript
const howMany = 2
const result = [
R.takeLast(howMany, [1, 2, 3]),
R.takeLast(howMany, 'foobar'),
]
// => [[2, 3], 'ar']
```
Try this R.takeLast example in Rambda REPL
R.takeLast source
```javascript
import baseSlice from './_internals/baseSlice.js'
export function takeLast(howMany, listOrString){
if (arguments.length === 1)
return _listOrString => takeLast(howMany, _listOrString)
const len = listOrString.length
if (howMany < 0) return listOrString.slice()
let numValue = howMany > len ? len : howMany
if (typeof listOrString === 'string')
return listOrString.slice(len - numValue)
numValue = len - numValue
return baseSlice(
listOrString, numValue, len
)
}
```
Tests
```javascript
import { takeLast } from './takeLast.js'
test('with arrays', () => {
expect(takeLast(1, [ 'foo', 'bar', 'baz' ])).toEqual([ 'baz' ])
expect(takeLast(2)([ 'foo', 'bar', 'baz' ])).toEqual([ 'bar', 'baz' ])
expect(takeLast(3, [ 'foo', 'bar', 'baz' ])).toEqual([ 'foo', 'bar', 'baz' ])
expect(takeLast(4, [ 'foo', 'bar', 'baz' ])).toEqual([ 'foo', 'bar', 'baz' ])
expect(takeLast(10, [ 'foo', 'bar', 'baz' ])).toEqual([ 'foo', 'bar', 'baz' ])
})
test('with strings', () => {
expect(takeLast(3, 'rambda')).toBe('bda')
expect(takeLast(7, 'rambda')).toBe('rambda')
})
test('with negative index', () => {
expect(takeLast(-1, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
expect(takeLast(-Infinity, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
})
```
[](#takeLast)
### takeLastWhile
```typescript
takeLastWhile(predicate: (x: string) => boolean, input: string): string
```
```javascript
const result = R.takeLastWhile(
x => x > 2,
[1, 2, 3, 4]
)
// => [3, 4]
```
Try this R.takeLastWhile example in Rambda REPL
R.takeLastWhile source
```javascript
import { isArray } from './_internals/isArray.js'
export function takeLastWhile(predicate, input){
if (arguments.length === 1){
return _input => takeLastWhile(predicate, _input)
}
if (input.length === 0) return input
const toReturn = []
let counter = input.length
while (counter){
const item = input[ --counter ]
if (!predicate(item)){
break
}
toReturn.push(item)
}
return isArray(input) ? toReturn.reverse() : toReturn.reverse().join('')
}
```
Tests
```javascript
import { takeLastWhile } from './takeLastWhile.js'
const assert = require('assert')
const list = [ 1, 2, 3, 4 ]
test('happy', () => {
const predicate = x => x > 2
const result = takeLastWhile(predicate, list)
expect(result).toEqual([ 3, 4 ])
})
test('predicate is always true', () => {
const predicate = () => true
const result = takeLastWhile(predicate)(list)
expect(result).toEqual(list)
})
test('predicate is always false', () => {
const predicate = () => false
const result = takeLastWhile(predicate, list)
expect(result).toEqual([])
})
test('with string', () => {
const result = takeLastWhile(x => x !== 'F', 'FOOBAR')
expect(result).toBe('OOBAR')
})
```
[](#takeLastWhile)
### takeUntil
```typescript
takeUntil(predicate: (x: T) => boolean, list: T[]): T[]
```
```javascript
const list = [1, 2, 3, 4, 5]
const predicate = x => x > 3
const result = R.takeUntil(predicate, list)
// => [1, 2, 3]
```
Try this R.takeUntil example in Rambda REPL
R.takeUntil source
```javascript
export function takeUntil(predicate, list){
const toReturn = []
let stopFlag = false
let counter = -1
while (stopFlag === false && counter++ < list.length - 1){
if (predicate(list[ counter ])){
stopFlag = true
} else {
toReturn.push(list[ counter ])
}
}
return toReturn
}
```
Tests
```javascript
import { takeUntil } from './takeUntil.js'
const list = [ 1, 2, 3, 4, 5, 6 ]
test('happy', () => {
const result = takeUntil(x => x > 3, list)
expect(result).toEqual([ 1, 2, 3 ])
})
test('predicate always returns true', () => {
const result = takeUntil(x => x < 10, list)
expect(result).toEqual([])
})
test('predicate always returns false', () => {
const result = takeUntil(x => x > 10, list)
expect(result).toEqual(list)
})
```
[](#takeUntil)
### takeWhile
Try this R.takeWhile example in Rambda REPL
[](#takeWhile)
### tap
```typescript
tap(fn: (x: T) => void, input: T): T
```
It applies function `fn` to input `x` and returns `x`.
One use case is debugging in the middle of `R.compose`.
```javascript
const list = [1, 2, 3]
R.compose(
R.map(x => x * 2)
R.tap(console.log),
R.filter(x => x > 1)
)(list)
// => `2` and `3` will be logged
```
Try this R.tap example in Rambda REPL
R.tap source
```javascript
export function tap(fn, x){
if (arguments.length === 1) return _x => tap(fn, _x)
fn(x)
return x
}
```
Tests
```javascript
import { tap } from './tap.js'
test('tap', () => {
let a = 1
const sayX = x => a = x
expect(tap(sayX, 100)).toBe(100)
expect(tap(sayX)(100)).toBe(100)
expect(a).toBe(100)
})
```
[](#tap)
### tapAsync
```typescript
tapAsync(fn: Func | Promise, input: T): T
```
Asynchronous version of `R.tap`.
R.tapAsync source
```javascript
async function tapAsyncFn(fn, input){
await fn(input)
return input
}
export function tapAsync(fn, input){
if (arguments.length === 1){
return async _input => tapAsyncFn(fn, _input)
}
return new Promise((resolve, reject) => {
tapAsyncFn(fn, input).then(resolve)
.catch(reject)
})
}
```
Tests
```javascript
import { delay } from './delay.js'
import { pipedAsync } from './pipedAsync.js'
import { tapAsync } from './tapAsync.js'
test('happy', async () => {
const result = await tapAsync(delay, 1)
expect(result).toBe(1)
})
test('complex', async () => {
let marker = false
const fn = () => marker = true
const result = await pipedAsync(
1,
async x => {
await delay(100)
return x + 1
},
tapAsync(fn),
x => x + 1
)
expect(marker).toBeTrue()
expect(result).toBe(3)
})
```
[](#tapAsync)
### test
```typescript
test(regExpression: RegExp): (str: string) => boolean
```
It determines whether `str` matches `regExpression`.
```javascript
R.test(/^f/, 'foo')
// => true
```
Try this R.test example in Rambda REPL
R.test source
```javascript
export function test(pattern, str){
if (arguments.length === 1) return _str => test(pattern, _str)
if (typeof pattern === 'string'){
throw new TypeError(`R.test requires a value of type RegExp as its first argument; received "${ pattern }"`)
}
return str.search(pattern) !== -1
}
```
Tests
```javascript
import { test as testMethod } from './test.js'
test('happy', () => {
expect(testMethod(/^x/, 'xyz')).toBeTrue()
expect(testMethod(/^y/)('xyz')).toBeFalse()
})
test('throws if first argument is not regex', () => {
expect(() => testMethod('foo', 'bar')).toThrowErrorMatchingInlineSnapshot('"R.test requires a value of type RegExp as its first argument; received "foo""')
})
```
[](#test)
### throttle
```typescript
throttle(fn: () => T, ms: number): () => T
```
```javascript
let counter = 0
const inc = () => {
counter++
}
const throttledInc = R.throttle(inc, 800)
const result = async () => {
throttledInc()
await R.delay(500)
throttledInc()
return counter
}
// `result` resolves to `1`
```
Try this R.throttle example in Rambda REPL
R.throttle source
```javascript
export function throttle(fn, ms){
let wait = false
let result
return function (...input){
if (!wait){
result = fn.apply(null, input)
wait = true
setTimeout(() => {
wait = false
}, ms)
}
return result
}
}
```
Tests
```javascript
import { delay } from './delay.js'
import { inc } from './inc.js'
import { throttle } from './throttle.js'
test('with side effect', async () => {
let counter = 0
const incFn = a => {
counter += a
return counter
}
const incWrapped = throttle(incFn, 1000)
incWrapped(1)
incWrapped(1)
await delay(1500)
incWrapped(1)
expect(counter).toBe(2)
})
test('return result', async () => {
const incWrapped = throttle(inc, 1000)
const results = []
results.push(incWrapped(1))
results.push(incWrapped(1))
await delay(1500)
results.push(incWrapped(1))
await delay(500)
results.push(incWrapped(1))
expect(results).toEqual([ 2, 2, 2, 2 ])
})
```
[](#throttle)
### times
```typescript
times(fn: (i: number) => T, howMany: number): T[]
```
It returns the result of applying function `fn` over members of range array.
The range array includes numbers between `0` and `howMany`(exclusive).
```javascript
const fn = x => x * 2
const howMany = 5
R.times(fn, howMany)
// => [0, 2, 4, 6, 8]
```
Try this R.times example in Rambda REPL
R.times source
```javascript
import { isInteger } from './_internals/isInteger.js'
import { map } from './map.js'
import { range } from './range.js'
export function times(fn, howMany){
if (arguments.length === 1) return _howMany => times(fn, _howMany)
if (!isInteger(howMany) || howMany < 0){
throw new RangeError('n must be an integer')
}
return map(fn, range(0, howMany))
}
```
Tests
```javascript
import assert from 'assert'
import { identity } from './identity.js'
import { times } from './times.js'
test('happy', () => {
const result = times(identity, 5)
expect(result).toEqual([ 0, 1, 2, 3, 4 ])
})
test('with bad input', () => {
assert.throws(() => {
times(3)('cheers!')
}, RangeError)
assert.throws(() => {
times(identity, -1)
}, RangeError)
})
test('curry', () => {
const result = times(identity)(5)
expect(result).toEqual([ 0, 1, 2, 3, 4 ])
})
```
[](#times)
### toDecimal
```typescript
toDecimal(num: number, charsAfterDecimalPoint?: number): number
```
```javascript
R.toDecimal(2.45464,2) // => 2.45
```
Try this R.toDecimal example in Rambda REPL
R.toDecimal source
```javascript
export function toDecimal(number, charsAfterDecimalPoint = 2){
return Number(parseFloat(String(number)).toFixed(charsAfterDecimalPoint))
}
```
Tests
```javascript
import { toDecimal } from './toDecimal.js'
test('happy', () => {
expect(toDecimal(2.2789, 1)).toBe(2.3)
expect(toDecimal(2.2789, 3)).toBe(2.279)
expect(toDecimal(2, 3)).toBe(2)
expect(toDecimal(2.2789)).toBe(2.28)
expect(toDecimal(2.45464)).toBe(2.45)
})
```
[](#toDecimal)
### toLower
```typescript
toLower(str: S): Lowercase
```
```javascript
R.toLower('FOO')
// => 'foo'
```
Try this R.toLower example in Rambda REPL
R.toLower source
```javascript
export function toLower(str){
return str.toLowerCase()
}
```
Tests
```javascript
import { toLower } from './toLower.js'
test('toLower', () => {
expect(toLower('FOO|BAR|BAZ')).toBe('foo|bar|baz')
})
```
[](#toLower)
### toPairs
```typescript
toPairs>(obj: O): Array<{ [key in K]: [`${key}`, O[key]] }[K]>
```
It transforms an object to a list.
```javascript
const list = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
const expected = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ] ]
const result = R.toPairs(list)
// => `result` is equal to `expected`
```
Try this R.toPairs example in Rambda REPL
R.toPairs source
```javascript
export function toPairs(obj){
return Object.entries(obj)
}
```
Tests
```javascript
import { toPairs } from './toPairs.js'
const obj = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
const expected = [
[ 'a', 1 ],
[ 'b', 2 ],
[ 'c', [ 3, 4 ] ],
]
test('happy', () => {
expect(toPairs(obj)).toEqual(expected)
})
```
[](#toPairs)
### toString
```typescript
toString(x: unknown): string
```
```javascript
R.toString([1, 2])
// => '1,2'
```
Try this R.toString example in Rambda REPL
R.toString source
```javascript
export function toString(x){
return x.toString()
}
```
Tests
```javascript
import { toString } from './toString.js'
test('happy', () => {
expect(toString([ 1, 2, 3 ])).toBe('1,2,3')
})
```
[](#toString)
### toUpper
```typescript
toUpper(str: S): Uppercase
```
```javascript
R.toUpper('foo')
// => 'FOO'
```
Try this R.toUpper example in Rambda REPL
R.toUpper source
```javascript
export function toUpper(str){
return str.toUpperCase()
}
```
Tests
```javascript
import { toUpper } from './toUpper.js'
test('toUpper', () => {
expect(toUpper('foo|bar|baz')).toBe('FOO|BAR|BAZ')
})
```
[](#toUpper)
### transpose
```typescript
transpose(list: (T[])[]): (T[])[]
```
```javascript
const list = [[10, 11], [20], [], [30, 31, 32]]
const expected = [[10, 20, 30], [11, 31], [32]]
const result = R.transpose(list)
// => `result` is equal to `expected`
```
Try this R.transpose example in Rambda REPL
R.transpose source
```javascript
import { isArray } from './_internals/isArray.js'
export function transpose(array){
return array.reduce((acc, el) => {
el.forEach((nestedEl, i) =>
isArray(acc[ i ]) ? acc[ i ].push(nestedEl) : acc.push([ nestedEl ]))
return acc
}, [])
}
```
Tests
```javascript
import { transpose } from './transpose.js'
test('happy', () => {
const input = [
[ 'a', 1 ],
[ 'b', 2 ],
[ 'c', 3 ],
]
expect(transpose(input)).toEqual([
[ 'a', 'b', 'c' ],
[ 1, 2, 3 ],
])
})
test('when rows are shorter', () => {
const actual = transpose([ [ 10, 11 ], [ 20 ], [], [ 30, 31, 32 ] ])
const expected = [ [ 10, 20, 30 ], [ 11, 31 ], [ 32 ] ]
expect(actual).toEqual(expected)
})
test('with empty array', () => {
expect(transpose([])).toEqual([])
})
test('array with falsy values', () => {
const actual = transpose([
[ true, false, undefined, null ],
[ null, undefined, false, true ],
])
const expected = [
[ true, null ],
[ false, undefined ],
[ undefined, false ],
[ null, true ],
]
expect(actual).toEqual(expected)
})
```
[](#transpose)
### trim
```typescript
trim(str: string): string
```
```javascript
R.trim(' foo ')
// => 'foo'
```
Try this R.trim example in Rambda REPL
R.trim source
```javascript
export function trim(str){
return str.trim()
}
```
Tests
```javascript
import { trim } from './trim.js'
test('trim', () => {
expect(trim(' foo ')).toBe('foo')
})
```
[](#trim)
### tryCatch
It returns function that runs `fn` in `try/catch` block. If there was an error, then `fallback` is used to return the result. Note that `fn` can be value or asynchronous/synchronous function(unlike `Ramda` where fallback can only be a synchronous function).
> :boom: Please check the tests of `R.tryCatch` to fully understand how this method works.
Try this R.tryCatch example in Rambda REPL
[](#tryCatch)
### tryCatchAsync
It returns function that runs `fn` in `try/catch` block. If there was an error, then `fallback` is used to return the result.
Try this R.tryCatchAsync example in Rambda REPL
[](#tryCatchAsync)
### type
It accepts any input and it returns its type.
> :boom: `NaN`, `Promise` and `Async` are types specific for **Rambda**.
Try this R.type example in Rambda REPL
[](#type)
### unapply
```typescript
unapply(fn: (args: any[]) => T): (...args: any[]) => T
```
It calls a function `fn` with the list of values of the returned function.
`R.unapply` is the opposite of `R.apply` method.
```javascript
R.unapply(JSON.stringify)(1, 2, 3)
//=> '[1,2,3]'
```
Try this R.unapply example in Rambda REPL
R.unapply source
```javascript
export function unapply(fn){
return function (...args){
return fn.call(this, args)
}
}
```
Tests
```javascript
import { apply } from './apply.js'
import { converge } from './converge.js'
import { identity } from './identity.js'
import { prop } from './prop.js'
import { sum } from './sum.js'
import { unapply } from './unapply.js'
test('happy', () => {
const fn = unapply(identity)
expect(fn(
1, 2, 3
)).toEqual([ 1, 2, 3 ])
expect(fn()).toEqual([])
})
test('returns a function which is always passed one argument', () => {
const fn = unapply(function (){
return arguments.length
})
expect(fn('x')).toBe(1)
expect(fn('x', 'y')).toBe(1)
expect(fn(
'x', 'y', 'z'
)).toBe(1)
})
test('forwards arguments to decorated function as an array', () => {
const fn = unapply(xs => '[' + xs + ']')
expect(fn(2)).toBe('[2]')
expect(fn(2, 4)).toBe('[2,4]')
expect(fn(
2, 4, 6
)).toBe('[2,4,6]')
})
test('returns a function with length 0', () => {
const fn = unapply(identity)
expect(fn).toHaveLength(0)
})
test('is the inverse of R.apply', () => {
let a, b, c, d, e, f, g, n
const rand = function (){
return Math.floor(200 * Math.random()) - 100
}
f = Math.max
g = unapply(apply(f))
n = 1
while (n <= 100){
a = rand()
b = rand()
c = rand()
d = rand()
e = rand()
expect(f(
a, b, c, d, e
)).toEqual(g(
a, b, c, d, e
))
n += 1
}
f = function (xs){
return '[' + xs + ']'
}
g = apply(unapply(f))
n = 1
while (n <= 100){
a = rand()
b = rand()
c = rand()
d = rand()
e = rand()
expect(f([ a, b, c, d, e ])).toEqual(g([ a, b, c, d, e ]))
n += 1
}
})
test('it works with converge', () => {
const fn = unapply(sum)
const convergeFn = converge(fn, [ prop('a'), prop('b'), prop('c') ])
const obj = {
a : 1337,
b : 42,
c : 1,
}
const expected = 1337 + 42 + 1
expect(convergeFn(obj)).toEqual(expected)
})
```
[](#unapply)
### union
```typescript
union(x: T[], y: T[]): T[]
```
It takes two lists and return a new list containing a merger of both list with removed duplicates.
`R.equals` is used to compare for duplication.
```javascript
const result = R.union([1,2,3], [3,4,5]);
// => [1, 2, 3, 4, 5]
```
Try this R.union example in Rambda REPL
R.union source
```javascript
import { cloneList } from './_internals/cloneList.js'
import { includes } from './includes.js'
export function union(x, y){
if (arguments.length === 1) return _y => union(x, _y)
const toReturn = cloneList(x)
y.forEach(yInstance => {
if (!includes(yInstance, x)) toReturn.push(yInstance)
})
return toReturn
}
```
Tests
```javascript
import { union } from './union.js'
test('happy', () => {
expect(union([ 1, 2 ], [ 2, 3 ])).toEqual([ 1, 2, 3 ])
})
test('with list of objects', () => {
const list1 = [ { a : 1 }, { a : 2 } ]
const list2 = [ { a : 2 }, { a : 3 } ]
const result = union(list1)(list2)
})
```
[](#union)
### uniq
```typescript
uniq(list: T[]): T[]
```
It returns a new array containing only one copy of each element of `list`.
`R.equals` is used to determine equality.
```javascript
const list = [1, 1, {a: 1}, {a: 2}, {a:1}]
R.uniq(list)
// => [1, {a: 1}, {a: 2}]
```
Try this R.uniq example in Rambda REPL
R.uniq source
```javascript
import { _Set } from './_internals/set.js'
export function uniq(list){
const set = new _Set()
const willReturn = []
list.forEach(item => {
if (set.checkUniqueness(item)){
willReturn.push(item)
}
})
return willReturn
}
```
Tests
```javascript
import { uniq } from './uniq.js'
test('happy', () => {
const list = [ 1, 2, 3, 3, 3, 1, 2, 0 ]
expect(uniq(list)).toEqual([ 1, 2, 3, 0 ])
})
test('with object', () => {
const list = [ { a : 1 }, { a : 2 }, { a : 1 }, { a : 2 } ]
expect(uniq(list)).toEqual([ { a : 1 }, { a : 2 } ])
})
test('with nested array', () => {
expect(uniq([ [ 42 ], [ 42 ] ])).toEqual([ [ 42 ] ])
})
test('with booleans', () => {
expect(uniq([ [ false ], [ false ], [ true ] ])).toEqual([ [ false ], [ true ] ])
})
test('with falsy values', () => {
expect(uniq([ undefined, null ])).toEqual([ undefined, null ])
})
test('can distinct between string and number', () => {
expect(uniq([ 1, '1' ])).toEqual([ 1, '1' ])
})
```
[](#uniq)
### uniqBy
It applies uniqueness to input list based on function that defines what to be used for comparison between elements.
`R.equals` is used to determine equality.
Try this R.uniqBy example in Rambda REPL
[](#uniqBy)
### uniqWith
```typescript
uniqWith(predicate: (x: T, y: T) => boolean, list: T[]): T[]
```
It returns a new array containing only one copy of each element in `list` according to `predicate` function.
This predicate should return true, if two elements are equal.
```javascript
const list = [
{id: 0, title:'foo'},
{id: 1, title:'bar'},
{id: 2, title:'baz'},
{id: 3, title:'foo'},
{id: 4, title:'bar'},
]
const expected = [
{id: 0, title:'foo'},
{id: 1, title:'bar'},
{id: 2, title:'baz'},
]
const predicate = (x,y) => x.title === y.title
const result = R.uniqWith(predicate, list)
// => `result` is equal to `expected`
```
Try this R.uniqWith example in Rambda REPL
R.uniqWith source
```javascript
function includesWith(
predicate, target, list
){
let willReturn = false
let index = -1
while (++index < list.length && !willReturn){
const value = list[ index ]
if (predicate(target, value)){
willReturn = true
}
}
return willReturn
}
export function uniqWith(predicate, list){
if (arguments.length === 1) return _list => uniqWith(predicate, _list)
let index = -1
const willReturn = []
while (++index < list.length){
const value = list[ index ]
if (!includesWith(
predicate, value, willReturn
)){
willReturn.push(value)
}
}
return willReturn
}
```
Tests
```javascript
import { uniqWith as uniqWithRamda } from 'ramda'
import { uniqWith } from './uniqWith.js'
const list = [ { a : 1 }, { a : 1 } ]
test('happy', () => {
const fn = (x, y) => x.a === y.a
const result = uniqWith(fn, list)
expect(result).toEqual([ { a : 1 } ])
})
test('with list of strings', () => {
const fn = (x, y) => x.length === y.length
const list = [ '0', '11', '222', '33', '4', '55' ]
const result = uniqWith(fn)(list)
const resultRamda = uniqWithRamda(fn, list)
expect(result).toEqual([ '0', '11', '222' ])
expect(resultRamda).toEqual([ '0', '11', '222' ])
})
```
[](#uniqWith)
### unless
```typescript
unless(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, x: T): T | U
```
The method returns function that will be called with argument `input`.
If `predicate(input)` returns `false`, then the end result will be the outcome of `whenFalse(input)`.
In the other case, the final output will be the `input` itself.
```javascript
const fn = R.unless(
x => x > 2,
x => x + 10
)
const result = [
fn(1),
fn(5)
]
// => [11, 5]
```
Try this R.unless example in Rambda REPL
R.unless source
```javascript
import { curry } from './curry.js'
function unlessFn(
predicate, whenFalseFn, input
){
if (predicate(input)) return input
return whenFalseFn(input)
}
export const unless = curry(unlessFn)
```
Tests
```javascript
import { inc } from './inc.js'
import { isNil } from './isNil.js'
import { unless } from './unless.js'
test('happy', () => {
const safeInc = unless(isNil, inc)
expect(safeInc(null)).toBeNull()
expect(safeInc(1)).toBe(2)
})
test('curried', () => {
const safeIncCurried = unless(isNil)(inc)
expect(safeIncCurried(null)).toBeNull()
})
test('with 3 inputs', () => {
let result = unless(x => x.startsWith('/'), x=> x.concat('/'), '/api')
expect(result).toBe('/api')
})
```
[](#unless)
### unnest
Try this R.unnest example in Rambda REPL
[](#unnest)
### unwind
Try this R.unwind example in Rambda REPL
[](#unwind)
### update
```typescript
update(index: number, newValue: T, list: T[]): T[]
```
It returns a copy of `list` with updated element at `index` with `newValue`.
```javascript
const index = 2
const newValue = 88
const list = [1, 2, 3, 4, 5]
const result = R.update(index, newValue, list)
// => [1, 2, 88, 4, 5]
```
Try this R.update example in Rambda REPL
R.update source
```javascript
import { cloneList } from './_internals/cloneList.js'
import { curry } from './curry.js'
export function updateFn(
index, newValue, list
){
const clone = cloneList(list)
if (index === -1) return clone.fill(newValue, index)
return clone.fill(
newValue, index, index + 1
)
}
export const update = curry(updateFn)
```
Tests
```javascript
import { update } from './update.js'
const list = [ 1, 2, 3 ]
test('happy', () => {
const newValue = 8
const index = 1
const result = update(
index, newValue, list
)
const curriedResult = update(index, newValue)(list)
const tripleCurriedResult = update(index)(newValue)(list)
const expected = [ 1, 8, 3 ]
expect(result).toEqual(expected)
expect(curriedResult).toEqual(expected)
expect(tripleCurriedResult).toEqual(expected)
})
test('list has no such index', () => {
const newValue = 8
const index = 10
const result = update(
index, newValue, list
)
expect(result).toEqual(list)
})
test('with negative index', () => {
expect(update(
-1, 10, [ 1 ]
)).toEqual([ 10 ])
expect(update(
-1, 10, []
)).toEqual([])
expect(update(
-1, 10, list
)).toEqual([ 1, 2, 10 ])
expect(update(
-2, 10, list
)).toEqual([ 1, 10, 3 ])
expect(update(
-3, 10, list
)).toEqual([ 10, 2, 3 ])
})
```
[](#update)
### updateObject
```typescript
updateObject