Extended version of Rambda(utility library) - Documentation
Rambda is smaller and faster alternative to the popular functional programming library Ramda. - Documentation
Rambdax passthrough all Rambda methods and introduce some new functions.
The idea of Rambdax is to extend Rambda without worring for Ramda compatibility.
import { composeAsync, filter, delay, mapAsync } from 'rambdax'
const result = await composeAsync(
mapAsync(async x => {
await delay(100)
return x + 1
}),
filter(x => x > 1)
)([1, 2, 3])
// => [3, 4]
You can test this example in Rambda's REPL
R.path, R.paths, R.assocPath and R.lensPathStandard 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} })
R.pick and R.omitSimilar 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
Rambdax implements some methods from Ramda community projects, such as R.lensSatisfies, R.lensEq and R.viewOr.
Most of the valid issues are fixed within 2-3 days.
Closing the issue is usually accompanied by publishing a new patch version of Rambdax to NPM.
yarn add rambdax
For UMD usage either use ./dist/rambdax.umd.js or the following CDN link:
https://unpkg.com/rambdax@CURRENT_VERSION/dist/rambdax.umd.js
import {compose, add} from 'https://raw.githubusercontent.com/selfrefactor/rambdax/master/dist/rambdax.esm.js'
Rambda's type detects async functions and unresolved Promises. The returned values are 'Async' and 'Promise'.
Rambda's type handles NaN input, in which case it returns NaN.
Rambda's forEach can iterate over objects not only arrays.
Rambda's map, filter, partition when they iterate over objects, they pass property and input object as predicate's argument.
Rambda's filter returns empty array with bad input(null or undefined), while Ramda throws.
Ramda's clamp work with strings, while Rambda's method work only with numbers.
Typescript definitions between rambda and @types/ramda may vary. List of all differences will be added soon.
If you need more Ramda methods in Rambda, you may either submit a
PRor check the extended version of Rambda - Rambdax. In case of the former, you may want to consult with Rambda contribution guidelines.
There are methods which are benchmarked only with Ramda and Rambda(i.e. no Lodash).
Note that some of these methods, are called with and without curring. This is done in order to give more detailed performance feedback.
The benchmarks results are produced from latest versions of Rambda, Lodash(4.17.19) and Ramda(0.27.0).
| method | Rambda | Ramda | Lodash |
|---|---|---|---|
| add | 96.25% slower | 96.24% slower | 🚀 Fastest |
| adjust | 🚀 Fastest | 5.52% slower | 🔳 |
| all | 🚀 Fastest | 94.95% slower | 🔳 |
| allPass | 🚀 Fastest | 98.95% slower | 🔳 |
| any | 🚀 Fastest | 98.18% slower | 6.18% slower |
| anyPass | 🚀 Fastest | 99.09% slower | 🔳 |
| append | 🚀 Fastest | 84.09% slower | 🔳 |
| applySpec | 🚀 Fastest | 75.73% slower | 🔳 |
| assoc | 87.98% slower | 57.39% slower | 🚀 Fastest |
| clone | 🚀 Fastest | 96.03% slower | 91.75% slower |
| compose | 🚀 Fastest | 96.45% slower | 77.83% slower |
| converge | 49.12% slower | 🚀 Fastest | 🔳 |
| curry | 🚀 Fastest | 34.9% slower | 🔳 |
| curryN | 63.32% slower | 🚀 Fastest | 🔳 |
| defaultTo | 🚀 Fastest | 50.3% slower | 🔳 |
| drop | 🚀 Fastest | 97.45% slower | 🔳 |
| dropLast | 🚀 Fastest | 97.07% slower | 🔳 |
| equals | 72.11% slower | 79.48% slower | 🚀 Fastest |
| filter | 🚀 Fastest | 94.74% slower | 58.18% slower |
| find | 🚀 Fastest | 98.2% slower | 88.96% slower |
| findIndex | 🚀 Fastest | 97.97% slower | 79.39% slower |
| flatten | 6.56% slower | 95.38% slower | 🚀 Fastest |
| ifElse | 🚀 Fastest | 70.97% slower | 🔳 |
| includes | 🚀 Fastest | 71.7% slower | 🔳 |
| indexOf | 🚀 Fastest | 84.08% slower | 7.86% slower |
| init | 94.42% slower | 97.55% slower | 🚀 Fastest |
| is | 🚀 Fastest | 11.72% slower | 🔳 |
| isEmpty | 51.68% slower | 93.82% slower | 🚀 Fastest |
| last | 🚀 Fastest | 99.64% slower | 1.05% slower |
| lastIndexOf | 🚀 Fastest | 42.38% slower | 🔳 |
| map | 🚀 Fastest | 69.63% slower | 4.68% slower |
| match | 🚀 Fastest | 46.75% slower | 🔳 |
| merge | 63.55% slower | 🚀 Fastest | 55.25% slower |
| none | 🚀 Fastest | 98.22% slower | 🔳 |
| omit | 🚀 Fastest | 70.66% slower | 97.56% slower |
| over | 🚀 Fastest | 50.77% slower | 🔳 |
| path | 🚀 Fastest | 74.94% slower | 5.72% slower |
| pick | 🚀 Fastest | 26.29% slower | 86.82% slower |
| prop | 🚀 Fastest | 89.89% slower | 🔳 |
| propEq | 🚀 Fastest | 95.26% slower | 🔳 |
| range | 95.17% slower | 90.22% slower | 🚀 Fastest |
| reduce | 52.76% slower | 74.02% slower | 🚀 Fastest |
| repeat | 85.91% slower | 95.31% slower | 🚀 Fastest |
| replace | 0.47% slower | 28.13% slower | 🚀 Fastest |
| set | 🚀 Fastest | 36.26% slower | 🔳 |
| sort | 🚀 Fastest | 63.15% slower | 🔳 |
| sortBy | 🚀 Fastest | 61.57% slower | 88.88% slower |
| split | 🚀 Fastest | 85.34% slower | 33.69% slower |
| splitEvery | 🚀 Fastest | 90.18% slower | 🔳 |
| take | 93.44% slower | 98.04% slower | 🚀 Fastest |
| takeLast | 92.61% slower | 98.83% slower | 🚀 Fastest |
| test | 🚀 Fastest | 94.42% slower | 🔳 |
| type | 18.91% slower | 🚀 Fastest | 🔳 |
| uniq | 98.98% slower | 96.58% slower | 🚀 Fastest |
| update | 🚀 Fastest | 38.88% slower | 🔳 |
| view | 🚀 Fastest | 82.21% slower | 🔳 |
Walmart Canada reported by w-b-dev
add(a: number, b: number): number
It adds a and b.
:boom: It doesn't work with strings, as the inputs are parsed to numbers before calculation.
R.add(2, 3) // => 5
Try this R.add example in Rambda REPL
add(a: number, b: number): number;
add(a: number): (b: number) => number;
import { add } from './add'
test('with number', () => {
expect(add(2, 3)).toEqual(5)
expect(add(7)(10)).toEqual(17)
})
test('string is bad input', () => {
expect(add('foo', 'bar')).toBeNaN()
})
test('ramda specs', () => {
expect(add('1', '2')).toEqual(3)
expect(add(1, '2')).toEqual(3)
expect(add(true, false)).toEqual(1)
expect(add(null, null)).toEqual(0)
expect(add(undefined, undefined)).toEqual(NaN)
expect(add(new Date(1), new Date(2))).toEqual(3)
})
adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[]
It replaces index in array list with the result of replaceFn(list[i]).
R.adjust(
0,
a => a + 1,
[0, 100]
) // => [1, 100]
Try this R.adjust example in Rambda REPL
adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[];
adjust<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[];
import { add } from './add'
import { adjust } from './adjust'
import { pipe } from './pipe'
const list = [ 0, 1, 2 ]
const expected = [ 0, 11, 2 ]
test('happy', () => {})
test('happy', () => {
expect(adjust(
1, add(10), list
)).toEqual(expected)
})
test('with curring type 1 1 1', () => {
expect(adjust(1)(add(10))(list)).toEqual(expected)
})
test('with curring type 1 2', () => {
expect(adjust(1)(add(10), list)).toEqual(expected)
})
test('with curring type 2 1', () => {
expect(adjust(1, add(10))(list)).toEqual(expected)
})
test('with negative index', () => {
expect(adjust(
-2, add(10), list
)).toEqual(expected)
})
test('when index is out of bounds', () => {
const list = [ 0, 1, 2, 3 ]
expect(adjust(
4, add(1), list
)).toEqual(list)
expect(adjust(
-5, add(1), list
)).toEqual(list)
})
all<T>(predicate: (x: T) => boolean, list: T[]): boolean
It returns true, if all members of array list returns true, when applied as argument to predicate function.
const list = [ 0, 1, 2, 3, 4 ]
const predicate = x => x > -1
const result = R.all(predicate, arr)
// => true
Try this R.all example in Rambda REPL
all<T>(predicate: (x: T) => boolean, list: T[]): boolean;
all<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
import { all } from './all'
const list = [ 0, 1, 2, 3, 4 ]
test('when true', () => {
const fn = x => x > -1
expect(all(fn)(list)).toBeTrue()
})
test('when false', () => {
const fn = x => x > 2
expect(all(fn, list)).toBeFalse()
})
allFalse(...inputs: any[]): boolean
It returns true if all inputs arguments are falsy(empty objects and empty arrays are considered falsy).
Functions are valid inputs, but these functions cannot have their own arguments.
This method is very similar to R.anyFalse, R.anyTrue and R.allTrue
R.allFalse(0, null, [], {}, '', () => false)
// => true
Try this R.allFalse example in Rambda REPL
allFalse(...inputs: any[]): boolean;
import { runTests } from 'helpers-fn'
import { allFalse } from './allFalse'
const happy = { ok : [ () => false, () => [], () => {}, null, false, [] ] }
const withArray = { fail : [ ...happy.ok, [ 1 ] ] }
const withObject = { fail : [ ...happy.ok, { a : 1 } ] }
const withFunction = { fail : [ ...happy.ok, () => ({ a : 1 }) ] }
const withBoolean = { fail : [ ...happy.ok, true ] }
const testData = {
label : 'R.allFalse',
data : [ happy, withArray, withObject, withFunction, withBoolean ],
fn : input => allFalse(...input),
}
runTests(testData)
allPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean
It returns true, if all functions of predicates return true, when input is their argument.
const input = {
a : 1,
b : 2,
}
const predicates = [
x => x.a === 1,
x => x.b === 2,
]
const result = R.allPass(predicates)(input) // => true
Try this R.allPass example in Rambda REPL
allPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
import { allPass } from './allPass'
test('happy', () => {
const rules = [ x => typeof x === 'number', x => x > 10, x => x * 7 < 100 ]
expect(allPass(rules)(11)).toBeTrue()
expect(allPass(rules)(undefined)).toBeFalse()
})
test('when returns true', () => {
const conditionArr = [ val => val.a === 1, val => val.b === 2 ]
expect(allPass(conditionArr)({
a : 1,
b : 2,
})).toBeTrue()
})
test('when returns false', () => {
const conditionArr = [ val => val.a === 1, val => val.b === 3 ]
expect(allPass(conditionArr)({
a : 1,
b : 2,
})).toBeFalse()
})
allTrue(...input: any[]): boolean
It returns true if all inputs arguments are truthy(empty objects and empty arrays are considered falsy).
R.allTrue(1, true, {a: 1}, [1], 'foo', () => true)
// => true
Try this R.allTrue example in Rambda REPL
allTrue(...input: any[]): boolean;
import { allTrue } from './allTrue'
test('with functions', () => {
const foo = () => 1
const bar = () => false
const baz = () => JSON.parse('{sda')
const result = allTrue(
foo, bar, baz
)
expect(result).toBeFalse()
})
test('usage with non boolean', () => {
const foo = { a : 1 }
const baz = [ 1, 2, 3 ]
const result = allTrue(
foo, foo, baz
)
expect(result).toBeTrue()
})
test('usage with boolean', () => {
const foo = 4
const baz = [ 1, 2, 3 ]
const result = allTrue(foo > 2, baz.length === 3)
expect(result).toBeTrue()
})
test('escapes early - case 0', () => {
const foo = undefined
const result = allTrue(foo, () => foo.a)
expect(result).toBeFalse()
})
test('escapes early - case 1', () => {
const foo = null
const result = allTrue(foo, () => foo.a)
expect(result).toBeFalse()
})
test('escapes early - case 2', () => {
const foo = { a : 'bar' }
const result = allTrue(
foo, foo.a, foo.a.b
)
expect(result).toBeFalse()
})
test('escapes early - case 3', () => {
const foo = { a : { b : 'foo' } }
const result = allTrue(
foo,
() => foo.a,
() => foo.a.b
)
expect(result).toBeTrue()
})
allType(targetType: RambdaTypes): (...input: any[]) => boolean
It returns a function which will return true if all of its inputs arguments belong to targetType.
:boom:
targetTypeis one of the possible returns ofR.type
const targetType = 'String'
const result = R.allType(
targetType
)('foo', 'bar', 'baz')
// => true
Try this R.allType example in Rambda REPL
allType(targetType: RambdaTypes): (...input: any[]) => boolean;
import { allType } from './allType'
test('when true', () => {
const result = allType('Array')(
[ 1, 2, 3 ], [], [ null ]
)
expect(result).toBeTrue()
})
test('when false', () => {
const result = allType('String')(
1, undefined, null, []
)
expect(result).toBeFalse()
})
always<T>(x: T): () => T
It returns function that always returns x.
const fn = R.always(7)
console.log(fn())// => 7
Try this R.always example in Rambda REPL
always<T>(x: T): () => T;
import { always } from './always'
import { F } from './F'
test('happy', () => {
const fn = always(7)
expect(fn()).toEqual(7)
expect(fn()).toEqual(7)
})
test('f', () => {
const fn = always(F())
expect(fn()).toBeFalse()
expect(fn()).toBeFalse()
})
and<T, U>(x: T, y: U): T | U
Logical AND
R.and(true, true); // => true
R.and(false, true); // => false
R.and(true, 'foo'); // => 'foo'
Try this R.and example in Rambda REPL
and<T, U>(x: T, y: U): T | U;
and<T>(x: T): <U>(y: U) => T | U;
import { and } from './and'
test('happy', () => {
expect(and(1, 'foo')).toBe('foo')
expect(and(true, true)).toBeTrue()
expect(and(true)(true)).toBeTrue()
expect(and(true, false)).toBeFalse()
expect(and(false, true)).toBeFalse()
expect(and(false, false)).toBeFalse()
})
any<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean
It returns true, if at least one member of list returns true, when passed to a predicate function.
const list = [1, 2, 3]
const predicate = x => x * x > 8
R.any(fn, list)
// => true
Try this R.any example in Rambda REPL
any<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean;
any<T>(predicate: (x: T) => boolean): (list: readonly T[]) => boolean;
import { any } from './any'
const list = [ 1, 2, 3 ]
test('happy', () => {
expect(any(x => x < 0, list)).toBeFalse()
})
test('with curry', () => {
expect(any(x => x > 2)(list)).toBeTrue()
})
anyFalse(...input: any[]): boolean
It returns true if any of inputs is falsy(empty objects and empty arrays are considered falsy).
R.anyFalse(1, {a: 1}, [1], () => false)
// => true
Try this R.anyFalse example in Rambda REPL
anyFalse(...input: any[]): boolean;
import { anyFalse } from './anyFalse'
test('when true', () => {
expect(anyFalse(
true, true, false
)).toBeTruthy()
})
test('when false', () => {
expect(anyFalse(true, true)).toBeFalsy()
})
test('supports function', () => {
expect(anyFalse(
true,
() => true,
() => false
)).toBeTruthy()
})
anyPass<T>(predicates: SafePred<T>[]): SafePred<T>
It accepts list of predicates and returns a function. This function with its input will return true, if any of predicates returns true for this input.
const isBig = x => x > 20
const isOdd = x => x % 2 === 1
const input = 11
const fn = R.anyPass(
[isBig, isOdd]
)
const result = fn(input)
// => true
Try this R.anyPass example in Rambda REPL
anyPass<T>(predicates: SafePred<T>[]): SafePred<T>;
import { anyPass } from './anyPass'
test('happy', () => {
const rules = [ x => typeof x === 'string', x => x > 10 ]
const predicate = anyPass(rules)
expect(predicate('foo')).toBeTrue()
expect(predicate(6)).toBeFalse()
})
test('happy', () => {
const rules = [ x => typeof x === 'string', x => x > 10 ]
expect(anyPass(rules)(11)).toBeTrue()
expect(anyPass(rules)(undefined)).toBeFalse()
})
const obj = {
a : 1,
b : 2,
}
test('when returns true', () => {
const conditionArr = [ val => val.a === 1, val => val.a === 2 ]
expect(anyPass(conditionArr)(obj)).toBeTrue()
})
test('when returns false + curry', () => {
const conditionArr = [ val => val.a === 2, val => val.b === 3 ]
expect(anyPass(conditionArr)(obj)).toBeFalse()
})
test('happy', () => {
expect(anyPass([])(3)).toEqual(false)
})
anyTrue(...input: any[]): boolean
It returns true if any of inputs arguments are truthy(empty objects and empty arrays are considered falsy).
R.anyTrue(0, null, [], {}, '', () => true)
// => true
Try this R.anyTrue example in Rambda REPL
anyTrue(...input: any[]): boolean;
import { anyTrue } from './anyTrue'
test('when true', () => {
expect(anyTrue(
true, true, false
)).toBeTruthy()
})
test('when false', () => {
expect(anyTrue(
false, false, false
)).toBeFalsy()
})
test('supports function', () => {
expect(anyTrue(
false,
false,
false,
() => false,
() => true
)).toBeTruthy()
})
anyType(targetType: RambdaTypes): (...input: any[]) => boolean
It returns a function which will return true if at least one of its inputs arguments belongs to targetType.
targetType is one of the possible returns of R.type
:boom:
targetTypeis one of the possible returns ofR.type
const targetType = 'String'
const result = R.anyType(
targetType
)(1, {}, 'foo')
// => true
Try this R.anyType example in Rambda REPL
anyType(targetType: RambdaTypes): (...input: any[]) => boolean;
import { anyType } from './anyType'
test('when true', () => {
const result = anyType('Array')(
1, undefined, null, []
)
expect(result).toBeTrue()
})
test('when false', () => {
const result = anyType('String')(
1, undefined, null, []
)
expect(result).toBeFalse()
})
append<T>(x: T, list: readonly T[]): T[]
It adds element x at the end of list.
const x = 'foo'
const result = R.append(x, ['bar', 'baz'])
// => ['bar', 'baz', 'foo']
Try this R.append example in Rambda REPL
append<T>(x: T, list: readonly T[]): T[];
append<T>(x: T): <T>(list: readonly T[]) => T[];
import { append } from './append'
test('happy', () => {
expect(append('tests', [ 'write', 'more' ])).toEqual([
'write',
'more',
'tests',
])
})
test('append to empty array', () => {
expect(append('tests')([])).toEqual([ 'tests' ])
})
test('with strings', () => {
expect(append('o', 'fo')).toEqual([ 'f', 'o', 'o' ])
})
applyDiff<Output>(rules: ApplyDiffRule[], obj: object): Output
It changes paths in an object according to a list of operations. Valid operations are add, update and delete. Its use-case is while writing tests and you need to change the test data.
Note, that you cannot use update operation, if the object path is missing in the input object.
Also, you cannot use add operation, if the object path has a value.
const obj = {a: {b:1, c:2}}
const rules = [
{op: 'remove', path: 'a.c'},
{op: 'add', path: 'a.d', value: 4},
{op: 'update', path: 'a.b', value: 2},
]
const result = R.applyDiff(rules, obj)
const expected = {a: {b: 2, d: 4}}
// => `result` is equal to `expected`
Try this R.applyDiff example in Rambda REPL
applyDiff<Output>(rules: ApplyDiffRule[], obj: object): Output;
applyDiff<Output>(rules: ApplyDiffRule[]): ( obj: object) => Output;
import { applyDiff } from './applyDiff'
test('remove operation', () => {
const rules = [
{
op : 'remove',
path : 'a.b',
},
]
const result = applyDiff(rules, {
a : {
b : 1,
c : 2,
},
})
expect(result).toEqual({ a : { c : 2 } })
})
test('update operation', () => {
const rules = [
{
op : 'update',
path : 'a.b',
value : 3,
},
{
op : 'update',
path : 'a.c.1',
value : 3,
},
{
op : 'update',
path : 'a.d',
value : 3,
},
]
const result = applyDiff(rules, {
a : {
b : 1,
c : [ 1, 2 ],
},
})
expect(result).toEqual({
a : {
b : 3,
c : [ 1, 3 ],
},
})
})
test('add operation', () => {
const rules = [
{
op : 'add',
path : 'a.b',
value : 3,
},
{
op : 'add',
path : 'a.d',
value : 3,
},
]
const result = applyDiff(rules, {
a : {
b : 1,
c : 2,
},
})
expect(result).toEqual({
a : {
b : 1,
c : 2,
d : 3,
},
})
})
applySpec<Spec extends Record<string, (...args: readonly any[]) => any>>(
spec: Spec
): (
...args: Parameters<ValueOfRecord<Spec>>
) => { [Key in keyof Spec]: ReturnType<Spec[Key]> }
It returns a curried function with the same arity as the longest function in the spec object. Arguments will be applied to the spec methods recursively.
:boom: The currying in this function works best with functions with 4 arguments or less. (arity of 4)
const spec = {
name: R.path('deeply.nested.firstname')
}
const json = {
deeply: {
nested: {
firstname: 'barry'
}
}
}
const result = R.applySpec(spec, json) // => { name: 'barry' }
// Second example
const getMetrics = R.applySpec({
sum: R.add,
nested: { mul: R.multiply }
})
getMetrics(2, 4)
// => { sum: 6, nested: { mul: 8 } }
Try this R.applySpec example in Rambda REPL
applySpec<Spec extends Record<string, (...args: readonly any[]) => any>>(
spec: Spec
): (
...args: Parameters<ValueOfRecord<Spec>>
) => { [Key in keyof Spec]: ReturnType<Spec[Key]> };
applySpec<T>(spec: any): (...args: readonly any[]) => T;
import { applySpec as applySpecRamda, nAry } from 'ramda'
import { add, always, compose, dec, inc, map, path, prop, T } from '../rambda'
import { applySpec } from './applySpec'
test('different than Ramda when bad spec', () => {
const result = applySpec({ sum : { a : 1 } })(1, 2)
const ramdaResult = applySpecRamda({ sum : { a : 1 } })(1, 2)
expect(result).toEqual({})
expect(ramdaResult).toEqual({ sum : { a : {} } })
})
test('works with empty spec', () => {
expect(applySpec({})()).toEqual({})
expect(applySpec([])(1, 2)).toEqual({})
expect(applySpec(null)(1, 2)).toEqual({})
})
test('works with unary functions', () => {
const result = applySpec({
v : inc,
u : dec,
})(1)
const expected = {
v : 2,
u : 0,
}
expect(result).toEqual(expected)
})
test('works with binary functions', () => {
const result = applySpec({ sum : add })(1, 2)
expect(result).toEqual({ sum : 3 })
})
test('works with nested specs', () => {
const result = applySpec({
unnested : always(0),
nested : { sum : add },
})(1, 2)
const expected = {
unnested : 0,
nested : { sum : 3 },
}
expect(result).toEqual(expected)
})
test('works with arrays of nested specs', () => {
const result = applySpec({
unnested : always(0),
nested : [ { sum : add } ],
})(1, 2)
expect(result).toEqual({
unnested : 0,
nested : [ { sum : 3 } ],
})
})
test('works with arrays of spec objects', () => {
const result = applySpec([ { sum : add } ])(1, 2)
expect(result).toEqual([ { sum : 3 } ])
})
test('works with arrays of functions', () => {
const result = applySpec([ map(prop('a')), map(prop('b')) ])([
{
a : 'a1',
b : 'b1',
},
{
a : 'a2',
b : 'b2',
},
])
const expected = [
[ 'a1', 'a2' ],
[ 'b1', 'b2' ],
]
expect(result).toEqual(expected)
})
test('works with a spec defining a map key', () => {
expect(applySpec({ map : prop('a') })({ a : 1 })).toEqual({ map : 1 })
})
test.skip('retains the highest arity', () => {
const f = applySpec({
f1 : nAry(2, T),
f2 : nAry(5, T),
})
expect(f.length).toBe(5)
})
test('returns a curried function', () => {
expect(applySpec({ sum : add })(1)(2)).toEqual({ sum : 3 })
})
// Additional tests
// ============================================
test('arity', () => {
const spec = {
one : x1 => x1,
two : (x1, x2) => x1 + x2,
three : (
x1, x2, x3
) => x1 + x2 + x3,
}
expect(applySpec(
spec, 1, 2, 3
)).toEqual({
one : 1,
two : 3,
three : 6,
})
})
test('arity over 5 arguments', () => {
const spec = {
one : x1 => x1,
two : (x1, x2) => x1 + x2,
three : (
x1, x2, x3
) => x1 + x2 + x3,
four : (
x1, x2, x3, x4
) => x1 + x2 + x3 + x4,
five : (
x1, x2, x3, x4, x5
) => x1 + x2 + x3 + x4 + x5,
}
expect(applySpec(
spec, 1, 2, 3, 4, 5
)).toEqual({
one : 1,
two : 3,
three : 6,
four : 10,
five : 15,
})
})
test('curried', () => {
const spec = {
one : x1 => x1,
two : (x1, x2) => x1 + x2,
three : (
x1, x2, x3
) => x1 + x2 + x3,
}
expect(applySpec(spec)(1)(2)(3)).toEqual({
one : 1,
two : 3,
three : 6,
})
})
test('curried over 5 arguments', () => {
const spec = {
one : x1 => x1,
two : (x1, x2) => x1 + x2,
three : (
x1, x2, x3
) => x1 + x2 + x3,
four : (
x1, x2, x3, x4
) => x1 + x2 + x3 + x4,
five : (
x1, x2, x3, x4, x5
) => x1 + x2 + x3 + x4 + x5,
}
expect(applySpec(spec)(1)(2)(3)(4)(5)).toEqual({
one : 1,
two : 3,
three : 6,
four : 10,
five : 15,
})
})
test('undefined property', () => {
const spec = { prop : path([ 'property', 'doesnt', 'exist' ]) }
expect(applySpec(spec, {})).toEqual({ prop : undefined })
})
test('restructure json object', () => {
const spec = {
id : path('user.id'),
name : path('user.firstname'),
profile : path('user.profile'),
doesntExist : path('user.profile.doesntExist'),
info : { views : compose(inc, prop('views')) },
type : always('playa'),
}
const data = {
user : {
id : 1337,
firstname : 'john',
lastname : 'shaft',
profile : 'shaft69',
},
views : 42,
}
expect(applySpec(spec, data)).toEqual({
id : 1337,
name : 'john',
profile : 'shaft69',
doesntExist : undefined,
info : { views : 43 },
type : 'playa',
})
})
assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & U
It makes a shallow clone of obj with setting or overriding the property prop with newValue.
:boom: This copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.
R.assoc('c', 3, {a: 1, b: 2})
//=> {a: 1, b: 2, c: 3}
Try this R.assoc example in Rambda REPL
assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & U;
assoc<T, K extends string>(prop: K, val: T): <U>(obj: U) => Record<K, T> & U;
assoc<K extends string>(prop: K): AssocPartialOne<K>;
import { assoc } from './assoc'
test('adds a key to an empty object', () => {
expect(assoc(
'a', 1, {}
)).toEqual({ a : 1 })
})
test('adds a key to a non-empty object', () => {
expect(assoc(
'b', 2, { a : 1 }
)).toEqual({
a : 1,
b : 2,
})
})
test('adds a key to a non-empty object - curry case 1', () => {
expect(assoc('b', 2)({ a : 1 })).toEqual({
a : 1,
b : 2,
})
})
test('adds a key to a non-empty object - curry case 2', () => {
expect(assoc('b')(2, { a : 1 })).toEqual({
a : 1,
b : 2,
})
})
test('adds a key to a non-empty object - curry case 3', () => {
const result = assoc('b')(2)({ a : 1 })
expect(result).toEqual({
a : 1,
b : 2,
})
})
test('changes an existing key', () => {
expect(assoc(
'a', 2, { a : 1 }
)).toEqual({ a : 2 })
})
test('undefined is considered an empty object', () => {
expect(assoc(
'a', 1, undefined
)).toEqual({ a : 1 })
})
test('null is considered an empty object', () => {
expect(assoc(
'a', 1, null
)).toEqual({ a : 1 })
})
test('value can be null', () => {
expect(assoc(
'a', null, null
)).toEqual({ a : null })
})
test('value can be undefined', () => {
expect(assoc(
'a', undefined, null
)).toEqual({ a : undefined })
})
test('assignment is shallow', () => {
expect(assoc(
'a', { b : 2 }, { a : { c : 3 } }
)).toEqual({ a : { b : 2 } })
})
assocPath<Output>(path: Path, newValue: any, obj: object): Output
It makes a shallow clone of obj with setting or overriding with newValue the property found with path.
const path = 'b.c'
const newValue = 2
const obj = { a: 1 }
R.assocPath(path, newValue, obj)
// => { a : 1, b : { c : 2 }}
Try this R.assocPath example in Rambda REPL
assocPath<Output>(path: Path, newValue: any, obj: object): Output;
assocPath<Output>(path: Path, newValue: any): (obj: object) => Output;
assocPath<Output>(path: Path): FunctionToolbelt.Curry<(newValue: any, obj: object) => Output>;
import { assocPath } from './assocPath'
test('string can be used as path input', () => {
const testObj = {
a : [ { b : 1 }, { b : 2 } ],
d : 3,
}
const result = assocPath(
'a.0.b', 10, testObj
)
const expected = {
a : [ { b : 10 }, { b : 2 } ],
d : 3,
}
expect(result).toEqual(expected)
})
test('bug', () => {
/*
https://github.com/selfrefactor/rambda/issues/524
*/
const state = {}
const withDateLike = assocPath(
[ 'outerProp', '2020-03-10' ],
{ prop : 2 },
state
)
const withNumber = assocPath(
[ 'outerProp', '5' ], { prop : 2 }, state
)
const withDateLikeExpected = { outerProp : { '2020-03-10' : { prop : 2 } } }
const withNumberExpected = { outerProp : { 5 : { prop : 2 } } }
expect(withDateLike).toEqual(withDateLikeExpected)
expect(withNumber).toEqual(withNumberExpected)
})
test('adds a key to an empty object', () => {
expect(assocPath(
[ 'a' ], 1, {}
)).toEqual({ a : 1 })
})
test('adds a key to a non-empty object', () => {
expect(assocPath(
'b', 2, { a : 1 }
)).toEqual({
a : 1,
b : 2,
})
})
test('adds a nested key to a non-empty object', () => {
expect(assocPath(
'b.c', 2, { a : 1 }
)).toEqual({
a : 1,
b : { c : 2 },
})
})
test('adds a nested key to a nested non-empty object - curry case 1', () => {
expect(assocPath('b.d',
3)({
a : 1,
b : { c : 2 },
})).toEqual({
a : 1,
b : {
c : 2,
d : 3,
},
})
})
test('adds a key to a non-empty object - curry case 1', () => {
expect(assocPath('b', 2)({ a : 1 })).toEqual({
a : 1,
b : 2,
})
})
test('adds a nested key to a non-empty object - curry case 1', () => {
expect(assocPath('b.c', 2)({ a : 1 })).toEqual({
a : 1,
b : { c : 2 },
})
})
test('adds a key to a non-empty object - curry case 2', () => {
expect(assocPath('b')(2, { a : 1 })).toEqual({
a : 1,
b : 2,
})
})
test('adds a key to a non-empty object - curry case 3', () => {
const result = assocPath('b')(2)({ a : 1 })
expect(result).toEqual({
a : 1,
b : 2,
})
})
test('changes an existing key', () => {
expect(assocPath(
'a', 2, { a : 1 }
)).toEqual({ a : 2 })
})
test('undefined is considered an empty object', () => {
expect(assocPath(
'a', 1, undefined
)).toEqual({ a : 1 })
})
test('null is considered an empty object', () => {
expect(assocPath(
'a', 1, null
)).toEqual({ a : 1 })
})
test('value can be null', () => {
expect(assocPath(
'a', null, null
)).toEqual({ a : null })
})
test('value can be undefined', () => {
expect(assocPath(
'a', undefined, null
)).toEqual({ a : undefined })
})
test('assignment is shallow', () => {
expect(assocPath(
'a', { b : 2 }, { a : { c : 3 } }
)).toEqual({ a : { b : 2 } })
})
test('empty array as path', () => {
const result = assocPath(
[], 3, {
a : 1,
b : 2,
}
)
expect(result).toEqual(3)
})
test('happy', () => {
const expected = { foo : { bar : { baz : 42 } } }
const result = assocPath(
[ 'foo', 'bar', 'baz' ], 42, { foo : null }
)
expect(result).toEqual(expected)
})
both(pred1: Pred, pred2: Pred): Pred
It returns a function with input argument.
This function will return true, if both firstCondition and secondCondition return true when input is passed as their argument.
const firstCondition = x => x > 10
const secondCondition = x => x < 20
const fn = R.both(secondCondition)
const result = [fn(15), fn(30)]
// => [true, false]
Try this R.both example in Rambda REPL
both(pred1: Pred, pred2: Pred): Pred;
both<T>(pred1: Predicate<T>, pred2: Predicate<T>): Predicate<T>;
both<T>(pred1: Predicate<T>): (pred2: Predicate<T>) => Predicate<T>;
both(pred1: Pred): (pred2: Pred) => Pred;
import { both } from './both'
const firstFn = val => val > 0
const secondFn = val => val < 10
test('with curry', () => {
expect(both(firstFn)(secondFn)(17)).toBeFalse()
})
test('without curry', () => {
expect(both(firstFn, secondFn)(7)).toBeTrue()
})
test('with multiple inputs', () => {
const between = function (
a, b, c
){
return a < b && b < c
}
const total20 = function (
a, b, c
){
return a + b + c === 20
}
const fn = both(between, total20)
expect(fn(
5, 7, 8
)).toBeTrue()
})
test('skip evaluation of the second expression', () => {
let effect = 'not evaluated'
const F = function (){
return false
}
const Z = function (){
effect = 'Z got evaluated'
}
both(F, Z)()
expect(effect).toBe('not evaluated')
})
chain<T, U>(fn: (n: T) => U[], list: readonly T[]): U[]
The method is also known as flatMap.
const duplicate = n => [ n, n ]
const list = [ 1, 2, 3 ]
const result = chain(duplicate, list)
// => [ 1, 1, 2, 2, 3, 3 ]
Try this R.chain example in Rambda REPL
chain<T, U>(fn: (n: T) => U[], list: readonly T[]): U[];
chain<T, U>(fn: (n: T) => U[]): (list: readonly T[]) => U[];
chain<X0, X1, R>(fn: (x0: X0, x1: X1) => R, fn1: (x1: X1) => X0): (x1: X1) => R;
import { chain } from './chain'
const duplicate = n => [ n, n ]
test('happy', () => {
const fn = x => [ x * 2 ]
const list = [ 1, 2, 3 ]
const result = chain(fn, list)
expect(result).toEqual([ 2, 4, 6 ])
})
test('maps then flattens one level', () => {
expect(chain(duplicate, [ 1, 2, 3 ])).toEqual([ 1, 1, 2, 2, 3, 3 ])
})
test('maps then flattens one level - curry', () => {
expect(chain(duplicate)([ 1, 2, 3 ])).toEqual([ 1, 1, 2, 2, 3, 3 ])
})
test('flattens only one level', () => {
const nest = n => [ [ n ] ]
expect(chain(nest, [ 1, 2, 3 ])).toEqual([ [ 1 ], [ 2 ], [ 3 ] ])
})
clamp(min: number, max: number, input: number): number
Restrict a number input to be withing min and max limits.
If input is bigger than max, then the result is max.
If input is smaller than min, then the result is min.
R.clamp(0, 10, 5) //=> 5
R.clamp(0, 10, -1) //=> 0
R.clamp(0, 10, 11) //=> 10
Try this R.clamp example in Rambda REPL
clamp(min: number, max: number, input: number): number;
clamp(min: number, max: number): (input: number) => number;
import { clamp } from './clamp'
test('when min is greater than max', () => {
expect(() => clamp(
-5, -10, 5
)).toThrowWithMessage(Error,
'min must not be greater than max in clamp(min, max, value)')
})
test('rambda specs', () => {
expect(clamp(
1, 10, 0
)).toEqual(1)
expect(clamp(
3, 12, 1
)).toEqual(3)
expect(clamp(
-15, 3, -100
)).toEqual(-15)
expect(clamp(
1, 10, 20
)).toEqual(10)
expect(clamp(
3, 12, 23
)).toEqual(12)
expect(clamp(
-15, 3, 16
)).toEqual(3)
expect(clamp(
1, 10, 4
)).toEqual(4)
expect(clamp(
3, 12, 6
)).toEqual(6)
expect(clamp(
-15, 3, 0
)).toEqual(0)
})
clone<T>(input: T): T
It creates a deep copy of the input, which may contain (nested) Arrays and Objects, Numbers, Strings, Booleans and Dates.
const objects = [{a: 1}, {b: 2}];
const objectsClone = R.clone(objects);
const result = [
R.equals(objects, objectsClone),
R.equals(objects[0], objectsClone[0]),
] // => [ true, true ]
Try this R.clone example in Rambda REPL
clone<T>(input: T): T;
clone<T>(input: readonly T[]): T[];
import assert from 'assert'
import { clone } from './clone'
import { equals } from './equals'
test('with array', () => {
const arr = [
{
b : 2,
c : 'foo',
d : [ 1, 2, 3 ],
},
1,
new Date(),
null,
]
expect(clone(arr)).toEqual(arr)
})
test('with object', () => {
const obj = {
a : 1,
b : 2,
c : 3,
d : [ 1, 2, 3 ],
e : new Date(),
}
expect(clone(obj)).toEqual(obj)
})
test('with date', () => {
const date = new Date(
2014, 10, 14, 23, 59, 59, 999
)
const cloned = clone(date)
assert.notStrictEqual(date, cloned)
expect(cloned).toEqual(new Date(
2014, 10, 14, 23, 59, 59, 999
))
expect(cloned.getDay()).toEqual(5)
})
test('with R.equals', () => {
const objects = [ { a : 1 }, { b : 2 } ]
const objectsClone = clone(objects)
const result = [
equals(objects, objectsClone),
equals(objects[ 0 ], objectsClone[ 0 ]),
]
expect(result).toEqual([ true, true ])
})
complement(pred: (...args: readonly any[]) => boolean): (...args: readonly any[]) => boolean
It returns inverted version of origin function that accept input as argument.
The return value of inverted is the negative boolean value of origin(input).
const origin = x => x > 5
const inverted = complement(origin)
const result = [
origin(7),
inverted(7)
] => [ true, false ]
Try this R.complement example in Rambda REPL
complement(pred: (...args: readonly any[]) => boolean): (...args: readonly any[]) => boolean;
import { complement } from './complement'
test('happy', () => {
const fn = complement(x => x.length === 0)
expect(fn([ 1, 2, 3 ])).toBeTrue()
})
test('with multiple parameters', () => {
const between = function (
a, b, c
){
return a < b && b < c
}
const f = complement(between)
expect(f(
4, 5, 11
)).toEqual(false)
expect(f(
12, 2, 6
)).toEqual(true)
})
compose<T1>(fn0: () => T1): () => T1
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]
Try this R.compose example in Rambda REPL
compose<T1>(fn0: () => T1): () => T1;
compose<V0, T1>(fn0: (x0: V0) => T1): (x0: V0) => T1;
compose<V0, V1, T1>(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1;
compose<V0, V1, V2, T1>(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1;
compose<T1, T2>(fn1: (x: T1) => T2, fn0: () => T1): () => T2;
compose<V0, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0) => T1): (x0: V0) => T2;
compose<V0, V1, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T2;
compose<V0, V1, V2, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T2;
compose<T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T3;
compose<V0, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T3;
compose<V0, V1, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T3;
compose<V0, V1, V2, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T3;
compose<T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T4;
compose<V0, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T4;
compose<V0, V1, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T4;
compose<V0, V1, V2, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T4;
compose<T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T5;
compose<V0, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T5;
compose<V0, V1, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T5;
compose<V0, V1, V2, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T5;
compose<T1, T2, T3, T4, T5, T6>(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T6;
compose<V0, T1, T2, T3, T4, T5, T6>(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T6;
compose<V0, V1, T1, T2, T3, T4, T5, T6>(
fn5: (x: T5) => T6,
fn4: (x: T4) => T5,
fn3: (x: T3) => T4,
fn2: (x: T2) => T3,
fn1: (x: T1) => T2,
fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T6;
compose<V0, V1, V2, T1, T2, T3, T4, T5, T6>(
fn5: (x: T5) => T6,
fn4: (x: T4) => T5,
fn3: (x: T3) => T4,
fn2: (x: T2) => T3,
fn1: (x: T1) => T2,
fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T6;
import { add } from './add'
import { compose } from './compose'
import { filter } from './filter'
import { last } from './last'
import { map } from './map'
test('happy', () => {
const result = compose(
last, map(add(10)), map(add(1))
)([ 1, 2, 3 ])
expect(result).toEqual(14)
})
test('can accepts initially two arguments', () => {
const result = compose(map(x => x * 2),
(list, limit) => filter(x => x > limit, list))([ 1, 2, 3, 4, false ], 2)
expect(result).toEqual([ 6, 8 ])
})
test('when no arguments is passed', () => {
expect(() => compose()).toThrow('compose requires at least one argument')
})
test('ramda spec', () => {
const f = function (
a, b, c
){
return [ a, b, c ]
}
const g = compose(f)
expect(g(
1, 2, 3
)).toEqual([ 1, 2, 3 ])
})
composeAsync<Out>(
...fns: (Async<any> | Func<any>)[]
): (input: any) => Promise<Out>
Asynchronous version of R.compose
:boom: It doesn't work with promises or function returning promises such as
const foo = input => new Promise(...).
const add = async x => {
await R.delay(100)
return x + 1
}
const multiply = async x => {
await R.delay(100)
return x * 2
}
const result = await R.composeAsync(
add,
multiply
)(1)
// `result` resolves to `3`
Try this R.composeAsync example in Rambda REPL
composeAsync<Out>(
...fns: (Async<any> | Func<any>)[]
): (input: any) => Promise<Out>;
composeAsync<Out>(
...fns: (Async<any> | Func<any>)[]
): (input: any) => Promise<Out>;
import { composeAsync } from './composeAsync'
import { delay } from './delay'
async function identity(x){
await delay(100)
return x
}
test('happy', async () => {
const fn1 = async x => {
await delay(100)
return x.map(xx => xx + 1)
}
const fn2 = async x => {
await delay(100)
return x.map(xx => xx * 2)
}
const result = await composeAsync(fn1,
fn2)(await Promise.all([ identity(1), identity(2), identity(3) ]))
expect(result).toEqual([ 3, 5, 7 ])
})
const delayFn = ms =>
new Promise(resolve => {
resolve(ms + 1)
})
test('with function returning promise', async () => {
const result = await composeAsync(
x => x,
x => x + 1,
delayFn,
x => x
)(1)
expect(result).toEqual(3)
})
test('throw error', async () => {
const fn = async () => {
await delay(1)
JSON.parse('{foo')
}
let didThrow = false
try {
await composeAsync(fn, x => x + 1)(20)
} catch (e){
didThrow = true
}
expect(didThrow).toBeTrue()
})
concat<T>(x: readonly T[], y: readonly T[]): T[]
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'
Try this R.concat example in Rambda REPL
concat<T>(x: readonly T[], y: readonly T[]): T[];
concat<T>(x: readonly T[]): (y: readonly T[]) => T[];
concat(x: string, y: string): string;
concat(x: string): (y: string) => string;
import { concat } from './concat'
test('happy', () => {
const arr1 = [ 'a', 'b', 'c' ]
const arr2 = [ 'd', 'e', 'f' ]
const a = concat(arr1, arr2)
const b = concat(arr1)(arr2)
const expectedResult = [ 'a', 'b', 'c', 'd', 'e', 'f' ]
expect(a).toEqual(expectedResult)
expect(b).toEqual(expectedResult)
})
test('with strings', () => {
expect(concat('ABC', 'DEF')).toEqual('ABCDEF')
})
cond(conditions: [Pred, (...a: readonly any[]) => any][]): (...x: readonly any[]) => any
It takes list with conditions and returns a new function fn that expects input as argument.
This function will start evaluating the conditions in order to find the first winner(order of conditions matter).
The winner is this condition, which left side returns true when input is its argument. Then the evaluation of the right side of the winner will be the final result.
If no winner is found, then fn returns undefined.
const fn = R.cond([
[ x => x > 25, R.always('more than 25') ],
[ x => x > 15, R.always('more than 15') ],
[ R.T, x => `${x} is nothing special` ],
])
const result = [
fn(30),
fn(20),
fn(10),
]
// => ['more than 25', 'more than 15', '10 is nothing special']
Try this R.cond example in Rambda REPL
cond(conditions: [Pred, (...a: readonly any[]) => any][]): (...x: readonly any[]) => any;
cond<A, B>(conditions: [SafePred<A>, (...a: readonly A[]) => B][]): (...x: readonly A[]) => B;
import { always } from './always'
import { cond } from './cond'
import { equals } from './equals'
import { T } from './T'
test('returns a function', () => {
expect(typeof cond([])).toEqual('function')
})
test('returns a conditional function', () => {
const fn = cond([
[ equals(0), always('water freezes at 0°C') ],
[ equals(100), always('water boils at 100°C') ],
[
T,
function (temp){
return 'nothing special happens at ' + temp + '°C'
},
],
])
expect(fn(0)).toEqual('water freezes at 0°C')
expect(fn(50)).toEqual('nothing special happens at 50°C')
expect(fn(100)).toEqual('water boils at 100°C')
})
test('no winner', () => {
const fn = cond([
[ equals('foo'), always(1) ],
[ equals('bar'), always(2) ],
])
expect(fn('quux')).toEqual(undefined)
})
test('predicates are tested in order', () => {
const fn = cond([
[ T, always('foo') ],
[ T, always('bar') ],
[ T, always('baz') ],
])
expect(fn()).toEqual('foo')
})
converge(after: ((...a: any[]) => any), fns: Array<((...x: any[]) => any)>): (...y: any[]) => any
converge(after: ((...a: any[]) => any), fns: Array<((...x: any[]) => any)>): (...y: any[]) => any;
import { add } from './add'
import { converge } from './converge'
const mult = (a, b) => a * b
const f1 = converge(mult, [ a => a + 1, a => a + 10 ])
const f2 = converge(mult, [ a => a + 1, (a, b) => a + b + 10 ])
const f3 = converge(mult, [ a => a + 1, (
a, b, c
) => a + b + c + 10 ])
test('happy', () => {
expect(f2(6, 7)).toEqual(161)
})
test('passes the results of applying the arguments individually', () => {
const result = converge(mult)([ add(1), add(3) ])(2)
expect(result).toEqual(15)
})
test('returns a function with the length of the longest argument', () => {
expect(f1.length).toEqual(1)
expect(f2.length).toEqual(2)
expect(f3.length).toEqual(3)
})
test('passes context to its functions', () => {
const a = function (x){
return this.f1(x)
}
const b = function (x){
return this.f2(x)
}
const c = function (x, y){
return this.f3(x, y)
}
const d = converge(c, [ a, b ])
const context = {
f1 : add(1),
f2 : add(2),
f3 : add,
}
expect(a.call(context, 1)).toEqual(2)
expect(b.call(context, 1)).toEqual(3)
expect(d.call(context, 1)).toEqual(5)
})
test('works with empty functions list', () => {
const fn = converge(function (){
return arguments.length
}, [])
expect(fn.length).toEqual(0)
expect(fn()).toEqual(0)
})
count<T>(searchFor: T, list: readonly any[]): number
It counts how many times searchFor is within list according to R.equals.
const list = [1, {a:1}, 1, 'foo']
const searchFor = 1
const result = R.count(searchFor, list)
// => 2
Try this R.count example in Rambda REPL
count<T>(searchFor: T, list: readonly any[]): number;
count<T>(searchFor: T): (list: readonly any[]) => number;
import { count } from './count'
test('when 0', () => {
const target = { a : 1 }
const list = []
const result = count(target, list)
const expectedResult = 0
expect(result).toEqual(expectedResult)
})
test('when 2', () => {
const target = { a : 1 }
const list = [ 2, 1, 2, { a : 1 }, 22, { a : 1 } ]
const result = count(target)(list)
const expectedResult = 2
expect(result).toEqual(expectedResult)
})
curry(fn: (...args: any[]) => any): (...a: any[]) => any
It expects a function as input and returns its curried version.
const fn = (a, b, c) => a + b + c
const curried = R.curry(fn)
const sum = curried(1,2)
const result = sum(3) // => 6
Try this R.curry example in Rambda REPL
curry(fn: (...args: any[]) => any): (...a: any[]) => any;
import { curry } from './curry'
test('happy', () => {
const addFourNumbers = (
a, b, c, d
) => a + b + c + d
const curriedAddFourNumbers = curry(addFourNumbers)
const f = curriedAddFourNumbers(1, 2)
const g = f(3)
expect(g(4)).toEqual(10)
})
test('when called with more arguments', () => {
const add = curry((n, n2) => n + n2)
expect(add(
1, 2, 3
)).toEqual(3)
})
test('when called with zero arguments', () => {
const sub = curry((a, b) => a - b)
const s0 = sub()
expect(s0(5, 2)).toEqual(3)
})
test('when called via multiple curry stages', () => {
const join = curry((
a, b, c, d
) => [ a, b, c, d ].join('-'))
const stage1 = join('A')
const stage2 = stage1('B', 'C')
expect(stage2('D')).toEqual('A-B-C-D')
})
curryN(length: number, fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any
It returns a curried equivalent of the provided function, with the specified arity.
curryN(length: number, fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any;
import { curryN } from './curryN'
function source(
a, b, c, d
){
void d
return a * b * c
}
test('accepts an arity', () => {
const curried = curryN(3, source)
expect(curried(1)(2)(3)).toEqual(6)
expect(curried(1, 2)(3)).toEqual(6)
expect(curried(1)(2, 3)).toEqual(6)
expect(curried(
1, 2, 3
)).toEqual(6)
})
test('can be partially applied', () => {
const curry3 = curryN(3)
const curried = curry3(source)
expect(curried.length).toEqual(3)
expect(curried(1)(2)(3)).toEqual(6)
expect(curried(1, 2)(3)).toEqual(6)
expect(curried(1)(2, 3)).toEqual(6)
expect(curried(
1, 2, 3
)).toEqual(6)
})
test('preserves context', () => {
const ctx = { x : 10 }
const f = function (a, b){
return a + b * this.x
}
const g = curryN(2, f)
expect(g.call(
ctx, 2, 4
)).toEqual(42)
expect(g.call(ctx, 2).call(ctx, 4)).toEqual(42)
})
test('forwards extra arguments', () => {
const f = function (){
return Array.prototype.slice.call(arguments)
}
const g = curryN(3, f)
expect(g(
1, 2, 3
)).toEqual([ 1, 2, 3 ])
expect(g(
1, 2, 3, 4
)).toEqual([ 1, 2, 3, 4 ])
expect(g(1, 2)(3, 4)).toEqual([ 1, 2, 3, 4 ])
expect(g(1)(
2, 3, 4
)).toEqual([ 1, 2, 3, 4 ])
expect(g(1)(2)(3, 4)).toEqual([ 1, 2, 3, 4 ])
})
debounce<T, U>(fn: (input: T) => U, ms: number): (input: T) => U
It creates a debounced function that delays invoking fn until after wait milliseconds ms have elapsed since the last time the debounced function was invoked.
:boom: Description is taken from
Lodashdocs
let counter = 0
const increment = () => {
counter++
}
const debounced = R.debounce(increment, 1000)
const result = async function(){
debounced()
await R.delay(500)
debounced()
await R.delay(800)
console.log(counter) // => 0
await R.delay(1200)
console.log(counter) // => 1
return counter
}
// `result` resolves to `1`
Try this R.debounce example in Rambda REPL
debounce<T, U>(fn: (input: T) => U, ms: number): (input: T) => U;
debounce<T, Q, U>(fn: (input1: T, input2: Q) => U, ms: number): (input1: T, input2: Q) => U;
debounce<T, Q, Z, U>(fn: (input1: T, input2: Q, input3: Z) => U, ms: number): (input1: T, input2: Q, input3: Z) => U;
import { debounce } from './debounce'
import { delay } from './delay'
test('happy', async () => {
let counter = 0
let aHolder
let bHolder
const inc = (a, b) => {
aHolder = a
bHolder = b
counter++
}
const incWrapped = debounce(inc, 500)
incWrapped(1, 2)
expect(counter).toBe(0)
expect(aHolder).toBe(undefined)
expect(bHolder).toBe(undefined)
await delay(200)
incWrapped(2, 3)
expect(counter).toBe(0)
await delay(200)
incWrapped(3, 4)
expect(counter).toBe(0)
expect(aHolder).toBe(undefined)
expect(bHolder).toBe(undefined)
await delay(200)
incWrapped(5, 6)
expect(counter).toBe(0)
await delay(700)
expect(counter).toBe(1)
expect(aHolder).toBe(5)
expect(bHolder).toBe(6)
})
test('immediate debounce', async () => {
let counter = 0
const inc = () => {
counter++
}
const incWrapped = debounce(
inc, 500, true
)
incWrapped()
expect(counter).toBe(1)
await delay(200)
incWrapped()
expect(counter).toBe(1)
await delay(200)
incWrapped()
expect(counter).toBe(1)
await delay(700)
incWrapped()
expect(counter).toBe(2)
})
dec(x: number): number
It decrements a number.
dec(x: number): number;
import { dec } from './dec'
test('happy', () => {
expect(dec(2)).toBe(1)
})
defaultTo<T>(defaultValue: T): (...inputArguments: (T | null | undefined)[]) => T
It returns defaultValue, if all of inputArguments are undefined, null or NaN.
Else, it returns the first truthy inputArguments instance(from left to right).
:boom: Rambda's defaultTo accept indefinite number of arguments when non curried, i.e.
R.defaultTo(2, foo, bar, baz).
// With single input argument
R.defaultTo('foo', 'bar') // => 'bar'
R.defaultTo('foo', undefined) // => 'foo'
// With multiple input arguments
R.defaultTo('foo', undefined, null, NaN) // => 'foo'
R.defaultTo('foo', undefined, 'bar', NaN, 'qux') // => 'bar'
R.defaultTo('foo', undefined, null, NaN, 'quz') // => 'qux'
Try this R.defaultTo example in Rambda REPL
defaultTo<T>(defaultValue: T): (...inputArguments: (T | null | undefined)[]) => T;
defaultTo<T>(defaultValue: T, ...inputArguments: (T | null | undefined)[]): T;
defaultTo<T, U>(defaultValue: T | U, ...inputArguments: (T | U | null | undefined)[]): T | U;
import { defaultTo } from './defaultTo'
test('with undefined', () => {
expect(defaultTo('foo')(undefined)).toEqual('foo')
})
test('with null', () => {
expect(defaultTo('foo')(null)).toEqual('foo')
})
test('with NaN', () => {
expect(defaultTo('foo')(NaN)).toEqual('foo')
})
test('with empty string', () => {
expect(defaultTo('foo', '')).toEqual('')
})
test('with false', () => {
expect(defaultTo('foo', false)).toEqual(false)
})
test('when inputArgument passes initial check', () => {
expect(defaultTo('foo', 'bar')).toEqual('bar')
})
test('default extends to indefinite input arguments - case 1', () => {
const result = defaultTo(
'foo', null, 'bar'
)
const expected = 'bar'
expect(result).toEqual(expected)
})
test('default extends to indefinite input arguments - case 2', () => {
const result = defaultTo(
'foo', null, NaN, 'bar'
)
const expected = 'bar'
expect(result).toEqual(expected)
})
test('default extends to indefinite input arguments - case 3', () => {
const result = defaultTo(
'foo', null, NaN, undefined
)
const expected = 'foo'
expect(result).toEqual(expected)
})
test('default extends to indefinite input arguments - case 4', () => {
const result = defaultTo(
'foo', null, NaN, undefined, 'bar'
)
const expected = 'bar'
expect(result).toEqual(expected)
})
test('default extends to indefinite input arguments - case 5', () => {
const result = defaultTo(
'foo', null, NaN, 'bar', 'baz'
)
const expected = 'bar'
expect(result).toEqual(expected)
})
test('default extends to indefinite input arguments - case 6', () => {
const result = defaultTo(
'foo', null, NaN, undefined, null, NaN
)
const expected = 'foo'
expect(result).toEqual(expected)
})
delay(ms: number): Promise<'RAMBDAX_DELAY'>
setTimeout as a promise that resolves to R.DELAY variable after ms milliseconds.
const result = R.delay(1000)
// `result` resolves to `RAMBDAX_DELAY`
Try this R.delay example in Rambda REPL
delay(ms: number): Promise<'RAMBDAX_DELAY'>;
import { DELAY, delay } from './delay'
test('usage with variables', async () => {
expect(await delay(500)).toBe(DELAY)
})
difference<T>(a: readonly T[], b: readonly T[]): T[]
It returns the uniq set of all elements in the first list a not contained in the second list b.
const a = [ 1, 2, 3, 4 ]
const b = [ 3, 4, 5, 6 ]
const result = difference(a, b)
// => [ 1, 2 ]
Try this R.difference example in Rambda REPL
difference<T>(a: readonly T[], b: readonly T[]): T[];
difference<T>(a: readonly T[]): (b: readonly T[]) => T[];
import { difference } from './difference'
test('difference', () => {
const a = [ 1, 2, 3, 4 ]
const b = [ 3, 4, 5, 6 ]
expect(difference(a)(b)).toEqual([ 1, 2 ])
expect(difference([], [])).toEqual([])
})
test('difference with objects', () => {
const a = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
const b = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
expect(difference(a, b)).toEqual([ { id : 1 }, { id : 2 } ])
})
test('no duplicates in first list', () => {
const M2 = [ 1, 2, 3, 4, 1, 2, 3, 4 ]
const N2 = [ 3, 3, 4, 4, 5, 5, 6, 6 ]
expect(difference(M2, N2)).toEqual([ 1, 2 ])
})
test('should use R.equals', () => {
expect(difference([ NaN ], [ NaN ]).length).toEqual(0)
})
dissoc<T>(prop: string, obj: any): T
It returns a new object that does not contain property prop.
R.dissoc('b', {a: 1, b: 2, c: 3})
//=> {a: 1, c: 3}
Try this R.dissoc example in Rambda REPL
dissoc<T>(prop: string, obj: any): T;
dissoc<T>(prop: string): (obj: any) => T;
import { dissoc } from './dissoc'
test('input is null or undefined', () => {
expect(dissoc('b', null)).toEqual({})
expect(dissoc('b', undefined)).toEqual({})
})
test('property exists curried', () => {
expect(dissoc('b')({
a : 1,
b : 2,
})).toEqual({ a : 1 })
})
test('property doesn\'t exists', () => {
expect(dissoc('c', {
a : 1,
b : 2,
})).toEqual({
a : 1,
b : 2,
})
})
test('works with non-string property', () => {
expect(dissoc(42, {
a : 1,
42 : 2,
})).toEqual({ a : 1 })
expect(dissoc(null, {
a : 1,
null : 2,
})).toEqual({ a : 1 })
expect(dissoc(undefined, {
a : 1,
undefined : 2,
})).toEqual({ a : 1 })
})
test('includes prototype properties', () => {
function Rectangle(width, height){
this.width = width
this.height = height
}
const area = Rectangle.prototype.area = function (){
return this.width * this.height
}
const rect = new Rectangle(7, 6)
expect(dissoc('area', rect)).toEqual({
width : 7,
height : 6,
})
expect(dissoc('width', rect)).toEqual({
height : 6,
area : area,
})
expect(dissoc('depth', rect)).toEqual({
width : 7,
height : 6,
area : area,
})
})
divide(x: number, y: number): number
R.divide(71, 100) // => 0.71
Try this R.divide example in Rambda REPL
divide(x: number, y: number): number;
divide(x: number): (y: number) => number;
import { divide } from './divide'
test('happy', () => {
expect(divide(71, 100)).toEqual(0.71)
expect(divide(71)(100)).toEqual(0.71)
})
drop<T>(howMany: number, input: readonly T[]): T[]
It returns howMany items dropped from beginning of list or string input.
R.drop(2, ['foo', 'bar', 'baz']) // => ['baz']
R.drop(2, 'foobar') // => 'obar'
Try this R.drop example in Rambda REPL
drop<T>(howMany: number, input: readonly T[]): T[];
drop(howMany: number, input: string): string;
drop<T>(howMany: number): {
<T>(input: readonly T[]): T[];
(input: string): string;
};
import assert from 'assert'
import { drop } from './drop'
test('with array', () => {
expect(drop(2)([ 'foo', 'bar', 'baz' ])).toEqual([ 'baz' ])
expect(drop(3, [ 'foo', 'bar', 'baz' ])).toEqual([])
expect(drop(4, [ 'foo', 'bar', 'baz' ])).toEqual([])
})
test('with string', () => {
expect(drop(3, 'rambda')).toEqual('bda')
})
test('with non-positive count', () => {
expect(drop(0, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
expect(drop(-1, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
expect(drop(-Infinity, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
})
test('should return copy', () => {
const xs = [ 1, 2, 3 ]
assert.notStrictEqual(drop(0, xs), xs)
assert.notStrictEqual(drop(-1, xs), xs)
})
dropLast<T>(howMany: number, input: readonly T[]): T[]
It returns howMany items dropped from the end of list or string input.
R.dropLast(2, ['foo', 'bar', 'baz']) // => ['foo']
R.dropLast(2, 'foobar') // => 'foob'
Try this R.dropLast example in Rambda REPL
dropLast<T>(howMany: number, input: readonly T[]): T[];
dropLast(howMany: number, input: string): string;
dropLast<T>(howMany: number): {
<T>(input: readonly T[]): T[];
(input: string): string;
};
import assert from 'assert'
import { dropLast } from './dropLast'
test('with array', () => {
expect(dropLast(2)([ 'foo', 'bar', 'baz' ])).toEqual([ 'foo' ])
expect(dropLast(3, [ 'foo', 'bar', 'baz' ])).toEqual([])
expect(dropLast(4, [ 'foo', 'bar', 'baz' ])).toEqual([])
})
test('with string', () => {
expect(dropLast(3, 'rambda')).toEqual('ram')
})
test('with non-positive count', () => {
expect(dropLast(0, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
expect(dropLast(-1, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
expect(dropLast(-Infinity, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ])
})
test('should return copy', () => {
const xs = [ 1, 2, 3 ]
assert.notStrictEqual(dropLast(0, xs), xs)
assert.notStrictEqual(dropLast(-1, xs), xs)
})
either(firstPredicate: Pred, secondPredicate: Pred): Pred
It returns a new predicate function from firstPredicate and secondPredicate inputs.
This predicate function will return true, if any of the two input predicates return true.
const firstPredicate = x => x > 10
const secondPredicate = x => x % 2 === 0
const predicate = R.either(firstPredicate, secondPredicate)
const result = [
predicate(15),
predicate(8),
predicate(7),
]
//=> [true, true, false]
Try this R.either example in Rambda REPL
either(firstPredicate: Pred, secondPredicate: Pred): Pred;
either<T>(firstPredicate: Predicate<T>, secondPredicate: Predicate<T>): Predicate<T>;
either<T>(firstPredicate: Predicate<T>): (secondPredicate: Predicate<T>) => Predicate<T>;
either(firstPredicate: Pred): (secondPredicate: Pred) => Pred;
import { either } from './either'
test('with multiple inputs', () => {
const between = function (
a, b, c
){
return a < b && b < c
}
const total20 = function (
a, b, c
){
return a + b + c === 20
}
const fn = either(between, total20)
expect(fn(
7, 8, 5
)).toBeTrue()
})
test('skip evaluation of the second expression', () => {
let effect = 'not evaluated'
const F = function (){
return true
}
const Z = function (){
effect = 'Z got evaluated'
}
either(F, Z)()
expect(effect).toBe('not evaluated')
})
test('case 1', () => {
const firstFn = val => val > 0
const secondFn = val => val * 5 > 10
expect(either(firstFn, secondFn)(1)).toBeTrue()
})
test('case 2', () => {
const firstFn = val => val > 0
const secondFn = val => val === -10
const fn = either(firstFn)(secondFn)
expect(fn(-10)).toBeTrue()
})
endsWith(target: string, str: string): boolean
Curried version of String.prototype.endsWith
:boom: It doesn't work with arrays unlike its corresponding Ramda method.
const str = 'foo-bar'
const target = '-bar'
const result = R.endsWith(target, str)
// => true
Try this R.endsWith example in Rambda REPL
endsWith(target: string, str: string): boolean;
endsWith(target: string): (str: string) => boolean;
import { endsWith } from './endsWith'
test('happy', () => {
expect(endsWith('bar', 'foo-bar')).toBeTrue()
expect(endsWith('baz')('foo-bar')).toBeFalse()
})
test('does not work with arrays', () => {
expect(() => endsWith([ 'c' ], [ 'a', 'b', 'c' ])).toThrowWithMessage(Error,
'str.endsWith is not a function')
})
equals<T>(x: T, y: T): boolean
It deeply compares x and y and returns true if they are equal.
:boom: It doesn't handle cyclical data structures and functions
R.equals(
[1, {a:2}, [{b: 3}]],
[1, {a:2}, [{b: 3}]]
) // => true
Try this R.equals example in Rambda REPL
equals<T>(x: T, y: T): boolean;
equals<T>(x: T): (y: T) => boolean;
// import { equals } from 'ramda'
import { equals } from './equals'
test('with array of objects', () => {
const list1 = [ { a : 1 }, [ { b : 2 } ] ]
const list2 = [ { a : 1 }, [ { b : 2 } ] ]
const list3 = [ { a : 1 }, [ { b : 3 } ] ]
expect(equals(list1, list2)).toBeTrue()
expect(equals(list1, list3)).toBeFalse()
})
test('with regex', () => {
expect(equals(/s/, /s/)).toEqual(true)
expect(equals(/s/, /d/)).toEqual(false)
expect(equals(/a/gi, /a/gi)).toEqual(true)
expect(equals(/a/gim, /a/gim)).toEqual(true)
expect(equals(/a/gi, /a/i)).toEqual(false)
})
test('not a number', () => {
expect(equals([ NaN ], [ NaN ])).toBeTrue()
})
test('new number', () => {
expect(equals(new Number(0), new Number(0))).toEqual(true)
expect(equals(new Number(0), new Number(1))).toEqual(false)
expect(equals(new Number(1), new Number(0))).toEqual(false)
})
test('new string', () => {
expect(equals(new String(''), new String(''))).toEqual(true)
expect(equals(new String(''), new String('x'))).toEqual(false)
expect(equals(new String('x'), new String(''))).toEqual(false)
expect(equals(new String('foo'), new String('foo'))).toEqual(true)
expect(equals(new String('foo'), new String('bar'))).toEqual(false)
expect(equals(new String('bar'), new String('foo'))).toEqual(false)
})
test('new Boolean', () => {
expect(equals(new Boolean(true), new Boolean(true))).toEqual(true)
expect(equals(new Boolean(false), new Boolean(false))).toEqual(true)
expect(equals(new Boolean(true), new Boolean(false))).toEqual(false)
expect(equals(new Boolean(false), new Boolean(true))).toEqual(false)
})
test('new Error', () => {
expect(equals(new Error('XXX'), {})).toEqual(false)
expect(equals(new Error('XXX'), new TypeError('XXX'))).toEqual(false)
expect(equals(new Error('XXX'), new Error('YYY'))).toEqual(false)
expect(equals(new Error('XXX'), new Error('XXX'))).toEqual(true)
expect(equals(new Error('XXX'), new TypeError('YYY'))).toEqual(false)
})
test('with dates', () => {
expect(equals(new Date(0), new Date(0))).toEqual(true)
expect(equals(new Date(1), new Date(1))).toEqual(true)
expect(equals(new Date(0), new Date(1))).toEqual(false)
expect(equals(new Date(1), new Date(0))).toEqual(false)
expect(equals(new Date(0), {})).toEqual(false)
expect(equals({}, new Date(0))).toEqual(false)
})
test('ramda spec', () => {
expect(equals({}, {})).toEqual(true)
expect(equals({
a : 1,
b : 2,
},
{
a : 1,
b : 2,
})).toEqual(true)
expect(equals({
a : 2,
b : 3,
},
{
b : 3,
a : 2,
})).toEqual(true)
expect(equals({
a : 2,
b : 3,
},
{
a : 3,
b : 3,
})).toEqual(false)
expect(equals({
a : 2,
b : 3,
c : 1,
},
{
a : 2,
b : 3,
})).toEqual(false)
})
test('works with boolean tuple', () => {
expect(equals([ true, false ], [ true, false ])).toBeTrue()
expect(equals([ true, false ], [ true, true ])).toBeFalse()
})
test('works with equal objects within array', () => {
const objFirst = {
a : {
b : 1,
c : 2,
d : [ 1 ],
},
}
const objSecond = {
a : {
b : 1,
c : 2,
d : [ 1 ],
},
}
const x = [ 1, 2, objFirst, null, '', [] ]
const y = [ 1, 2, objSecond, null, '', [] ]
expect(equals(x, y)).toBeTrue()
})
test('works with different objects within array', () => {
const objFirst = { a : { b : 1 } }
const objSecond = { a : { b : 2 } }
const x = [ 1, 2, objFirst, null, '', [] ]
const y = [ 1, 2, objSecond, null, '', [] ]
expect(equals(x, y)).toBeFalse()
})
test('works with undefined as second argument', () => {
expect(equals(1, undefined)).toBeFalse()
expect(equals(undefined, undefined)).toBeTrue()
})
test('various examples', () => {
expect(equals([ 1, 2, 3 ])([ 1, 2, 3 ])).toBeTrue()
expect(equals([ 1, 2, 3 ], [ 1, 2 ])).toBeFalse()
expect(equals(1, 1)).toBeTrue()
expect(equals(1, '1')).toBeFalse()
expect(equals({}, {})).toBeTrue()
expect(equals({
a : 1,
b : 2,
},
{
b : 2,
a : 1,
})).toBeTrue()
expect(equals({
a : 1,
b : 2,
},
{
a : 1,
b : 1,
})).toBeFalse()
expect(equals({
a : 1,
b : false,
},
{
a : 1,
b : 1,
})).toBeFalse()
expect(equals({
a : 1,
b : 2,
},
{
b : 2,
a : 1,
c : 3,
})).toBeFalse()
expect(equals({
x : {
a : 1,
b : 2,
},
},
{
x : {
b : 2,
a : 1,
c : 3,
},
})).toBeFalse()
expect(equals({
a : 1,
b : 2,
},
{
b : 3,
a : 1,
})).toBeFalse()
expect(equals({ a : { b : { c : 1 } } }, { a : { b : { c : 1 } } })).toBeTrue()
expect(equals({ a : { b : { c : 1 } } }, { a : { b : { c : 2 } } })).toBeFalse()
expect(equals({ a : {} }, { a : {} })).toBeTrue()
expect(equals('', '')).toBeTrue()
expect(equals('foo', 'foo')).toBeTrue()
expect(equals('foo', 'bar')).toBeFalse()
expect(equals(0, false)).toBeFalse()
expect(equals(/\s/g, null)).toBeFalse()
expect(equals(null, null)).toBeTrue()
expect(equals(false)(null)).toBeFalse()
})
test('with custom functions', () => {
function foo(){
return 1
}
foo.prototype.toString = () => ''
const result = equals(foo, foo)
expect(result).toBeFalse()
})
test('with classes', () => {
class Foo{}
const foo = new Foo()
const result = equals(foo, foo)
expect(result).toBeTrue()
})
test('with negative zero', () => {
expect(equals(-0, -0)).toBeTrue()
expect(equals(-0, 0)).toBeFalse()
expect(equals(0, 0)).toBeTrue()
expect(equals(-0, 1)).toBeFalse()
})
excludes(valueToFind: string, input: string[] | string): boolean
Opposite of R.includes
const result = [
R.excludes('ar', 'foo'),
R.excludes({a: 2}, [{a: 1}])
]
// => [true, true ]
Try this R.excludes example in Rambda REPL
excludes(valueToFind: string, input: string[] | string): boolean;
excludes(valueToFind: string): (input: string[] | string) => boolean;
excludes<T>(valueToFind: T, input: T[]): boolean;
excludes<T>(valueToFind: T): (input: T[]) => boolean;
import { excludes } from './excludes'
test('excludes with string', () => {
const str = 'more is less'
expect(excludes('less')(str)).toBeFalse()
expect(excludes('never', str)).toBeTrue()
})
test('excludes with array', () => {
const arr = [ 1, 2, 3 ]
expect(excludes(2)(arr)).toBeFalse()
expect(excludes(4, arr)).toBeTrue()
})
F(): boolean
F() // => false
Try this R.F example in Rambda REPL
F(): boolean;
filter<T>(predicate: FilterFunctionArray<T>): (input: readonly T[]) => T[]
It filters list or object input using a predicate function.
const list = [3, 4, 3, 2]
const listPredicate = x => x > 2
const object = {abc: 'fo', xyz: 'bar', baz: 'foo'}
const objectPredicate = (x, prop) => x.length + prop.length > 5
const result = [
R.filter(listPredicate, list),
R.filter(objectPredicate, object)
]
// => [ [3, 4], { xyz: 'bar', baz: 'foo'} ]
Try this R.filter example in Rambda REPL
filter<T>(predicate: FilterFunctionArray<T>): (input: readonly T[]) => T[];
filter<T>(predicate: FilterFunctionArray<T>, input: readonly T[]): T[];
filter<T, U>(predicate: FilterFunctionObject<T>): (x: Dictionary<T>) => Dictionary<T>;
filter<T>(predicate: FilterFunctionObject<T>, x: Dictionary<T>): Dictionary<T>;
import Ramda from 'ramda'
import { F } from './F'
import { filter } from './filter'
import { T } from './T'
const sampleObject = {
a : 1,
b : 2,
c : 3,
d : 4,
}
test('happy', () => {
const isEven = n => n % 2 === 0
expect(filter(isEven, [ 1, 2, 3, 4 ])).toEqual([ 2, 4 ])
expect(filter(isEven, {
a : 1,
b : 2,
d : 3,
})).toEqual({ b : 2 })
})
test('bad inputs difference between Ramda and Rambda', () => {
expect(filter(T)(undefined)).toEqual([])
expect(filter(F, null)).toEqual([])
expect(() => Ramda.filter(T, null)).toThrowWithMessage(TypeError,
'Cannot read property \'filter\' of null')
expect(() => Ramda.filter(T, undefined)).toThrowWithMessage(TypeError,
'Cannot read property \'filter\' of undefined')
})
test('predicate when input is object', () => {
const obj = {
a : 1,
b : 2,
}
const predicate = (
val, prop, inputObject
) => {
expect(inputObject).toEqual(obj)
expect(typeof prop).toEqual('string')
return val < 2
}
expect(filter(predicate, obj)).toEqual({ a : 1 })
})
test('with object', () => {
const isEven = n => n % 2 === 0
const result = filter(isEven, sampleObject)
const expectedResult = {
b : 2,
d : 4,
}
expect(result).toEqual(expectedResult)
})
filterAsync<T>(fn: AsyncPredicate<T>, list: readonly T[]): Promise<T[]>
Asynchronous version of R.filter
const predicate = async x => {
await R.delay(100)
return x % 2 === 1
}
const result = await R.filterAsync(predicate, [ 1, 2, 3 ])
// => [ 1, 3 ]
Try this R.filterAsync example in Rambda REPL
filterAsync<T>(fn: AsyncPredicate<T>, list: readonly T[]): Promise<T[]>;
filterAsync<T>(fn: AsyncPredicateIndexed<T>, list: readonly T[]): Promise<T[]>;
filterAsync<T>(fn: AsyncPredicate<T>) : ( list: readonly T[]) => Promise<T[]>;
filterAsync<T>(fn: AsyncPredicateIndexed<T>) : ( list: readonly T[]) => Promise<T[]>;
import { delay } from './delay'
import { filterAsync } from './filterAsync'
test('happy', async () => {
const predicate = async (x, i) => {
expect(i).toBeNumber()
await delay(100)
return x % 2 === 1
}
const result = await filterAsync(predicate)([ 1, 2, 3 ])
expect(result).toEqual([ 1, 3 ])
})
test('with object', async () => {
const predicate = async (x, prop) => {
expect(prop).toBeString()
await delay(100)
return x % 2 === 1
}
const result = await filterAsync(predicate, {
a : 1,
b : 2,
c : 3,
d : 4,
e : 5,
})
expect(result).toEqual({
a : 1,
c : 3,
e : 5,
})
})
filterIndexed<T>(predicate: FilterPredicateIndexed<T>): (x: readonly T[]) => T[]
Same as R.filter, but it passes index as second argument to the predicate, when looping over arrays.
filterIndexed<T>(predicate: FilterPredicateIndexed<T>): (x: readonly T[]) => T[];
filterIndexed<T>(predicate: FilterPredicateIndexed<T>, x: readonly T[]): T[];
filterIndexed<T, U>(predicate: FilterFunctionObject<T>): (x: Dictionary<T>) => Dictionary<T>;
filterIndexed<T>(predicate: FilterFunctionObject<T>, x: Dictionary<T>): Dictionary<T>;
import { filter } from './filter'
import { filterIndexed } from './filterIndexed'
const iterator = (x, i) => {
expect(x).toBeNumber()
expect(i).toBeNumber()
}
test('happy', () => {
const list = [ 1, 2, 3 ]
filterIndexed(iterator, list)
filterIndexed(iterator)(list)
})
test('with object', () => {
const iterator = x => x + 1
const obj = { a : 1 }
expect(filterIndexed(iterator, obj)).toEqual(filter(iterator, obj))
})
test('with bad input', () => {
expect(filterIndexed(iterator, undefined)).toEqual([])
})
find<T>(predicate: (x: T) => boolean, list: readonly T[]): T | undefined
It returns the first element of list that satisfy the predicate.
If there is no such element, it returns undefined.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 'bar'}, {foo: 1}]
const result = R.find(predicate, list)
// => {foo: 1}
Try this R.find example in Rambda REPL
find<T>(predicate: (x: T) => boolean, list: readonly T[]): T | undefined;
find<T>(predicate: (x: T) => boolean): (list: readonly T[]) => T | undefined;
import { find } from './find'
import { propEq } from './propEq'
const list = [ { a : 1 }, { a : 2 }, { a : 3 } ]
test('happy', () => {
const fn = propEq('a', 2)
expect(find(fn, list)).toEqual({ a : 2 })
})
test('with curry', () => {
const fn = propEq('a', 4)
expect(find(fn)(list)).toBeUndefined()
})
test('with empty list', () => {
expect(find(() => true, [])).toBeUndefined()
})
findIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number
It returns the index of the first element of list satisfying the predicate function.
If there is no such element, then -1 is returned.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 'bar'}, {foo: 1}]
const result = R.findIndex(predicate, list)
// => 1
Try this R.findIndex example in Rambda REPL
findIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number;
findIndex<T>(predicate: (x: T) => boolean): (list: readonly T[]) => number;
import { findIndex } from './findIndex'
import { propEq } from './propEq'
const list = [ { a : 1 }, { a : 2 }, { a : 3 } ]
test('happy', () => {
expect(findIndex(propEq('a', 2), list)).toEqual(1)
expect(findIndex(propEq('a', 1))(list)).toEqual(0)
expect(findIndex(propEq('a', 4))(list)).toEqual(-1)
})
findLast<T>(fn: (x: T) => boolean, list: readonly T[]): T | undefined
It returns the last element of list satisfying the predicate function.
If there is no such element, then undefined is returned.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 0}, {foo: 1}]
const result = R.findLast(predicate, list)
// => {foo: 1}
Try this R.findLast example in Rambda REPL
findLast<T>(fn: (x: T) => boolean, list: readonly T[]): T | undefined;
findLast<T>(fn: (x: T) => boolean): (list: readonly T[]) => T | undefined;
import { findLast } from './findLast'
test('happy', () => {
const result = findLast(x => {
return x > 1
},
[ 1, 1, 1, 2, 3, 4, 1 ]
)
expect(result).toEqual(4)
expect(findLast(x => x === 0, [ 0, 1, 1, 2, 3, 4, 1 ])).toEqual(0)
})
test('with curry', () => {
expect(findLast(x => x > 1)([ 1, 1, 1, 2, 3, 4, 1 ])).toEqual(4)
})
const obj1 = { x : 100 }
const obj2 = { x : 200 }
const a = [ 11, 10, 9, 'cow', obj1, 8, 7, 100, 200, 300, obj2, 4, 3, 2, 1, 0 ]
const even = function (x){
return x % 2 === 0
}
const gt100 = function (x){
return x > 100
}
const isStr = function (x){
return typeof x === 'string'
}
const xGt100 = function (o){
return o && o.x > 100
}
test('ramda 1', () => {
expect(findLast(even, a)).toEqual(0)
expect(findLast(gt100, a)).toEqual(300)
expect(findLast(isStr, a)).toEqual('cow')
expect(findLast(xGt100, a)).toEqual(obj2)
})
test('ramda 2', () => {
expect(findLast(even, [ 'zing' ])).toEqual(undefined)
})
test('ramda 3', () => {
expect(findLast(even, [ 2, 3, 5 ])).toEqual(2)
})
test('ramda 4', () => {
expect(findLast(even, [])).toEqual(undefined)
})
findLastIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number
It returns the index of the last element of list satisfying the predicate function.
If there is no such element, then -1 is returned.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 0}, {foo: 1}]
const result = R.findLastIndex(predicate, list)
// => 1
Try this R.findLastIndex example in Rambda REPL
findLastIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number;
findLastIndex<T>(predicate: (x: T) => boolean): (list: readonly T[]) => number;
import { findLastIndex } from './findLastIndex'
test('happy', () => {
const result = findLastIndex((x) => {
return x > 1
},
[ 1, 1, 1, 2, 3, 4, 1 ])
expect(result).toEqual(5)
expect(findLastIndex(x => x === 0, [ 0, 1, 1, 2, 3, 4, 1 ])).toEqual(0)
})
test('with curry', () => {
expect(findLastIndex(x => x > 1)([ 1, 1, 1, 2, 3, 4, 1 ])).toEqual(5)
})
const obj1 = { x : 100 }
const obj2 = { x : 200 }
const a = [ 11, 10, 9, 'cow', obj1, 8, 7, 100, 200, 300, obj2, 4, 3, 2, 1, 0 ]
const even = function (x){
return x % 2 === 0
}
const gt100 = function (x){
return x > 100
}
const isStr = function (x){
return typeof x === 'string'
}
const xGt100 = function (o){
return o && o.x > 100
}
test('ramda 1', () => {
expect(findLastIndex(even, a)).toEqual(15)
expect(findLastIndex(gt100, a)).toEqual(9)
expect(findLastIndex(isStr, a)).toEqual(3)
expect(findLastIndex(xGt100, a)).toEqual(10)
})
test('ramda 2', () => {
expect(findLastIndex(even, [ 'zing' ])).toEqual(-1)
})
test('ramda 3', () => {
expect(findLastIndex(even, [ 2, 3, 5 ])).toEqual(0)
})
test('ramda 4', () => {
expect(findLastIndex(even, [])).toEqual(-1)
})
flatten<T>(list: readonly any[]): T[]
It deeply flattens an array.
const result = R.flatten([
1,
2,
[3, 30, [300]],
[4]
])
// => [ 1, 2, 3, 30, 300, 4 ]
Try this R.flatten example in Rambda REPL
flatten<T>(list: readonly any[]): T[];
import { flatten } from './flatten'
test('happy', () => {
expect(flatten([ 1, 2, 3, [ [ [ [ [ 4 ] ] ] ] ] ])).toEqual([ 1, 2, 3, 4 ])
expect(flatten([ 1, [ 2, [ [ 3 ] ] ], [ 4 ] ])).toEqual([ 1, 2, 3, 4 ])
expect(flatten([ 1, [ 2, [ [ [ 3 ] ] ] ], [ 4 ] ])).toEqual([ 1, 2, 3, 4 ])
expect(flatten([ 1, 2, [ 3, 4 ], 5, [ 6, [ 7, 8, [ 9, [ 10, 11 ], 12 ] ] ] ])).toEqual([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ])
})
test('readme example', () => {
const result = flatten([ 1, 2, [ 3, 30, [ 300 ] ], [ 4 ] ])
expect(result).toEqual([ 1, 2, 3, 30, 300, 4 ])
})
flip<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult
It returns function which calls fn with exchanged first and second argument.
:boom: Rambda's flip will throw if the arity of the input function is greater or equal to 5.
const subtractFlip = R.flip(R.subtract)
const result = [
subtractFlip(1,7),
R.flip(1, 6)
]
// => [6, -6]
Try this R.flip example in Rambda REPL
flip<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult;
flip<F extends (...args: any) => any, P extends FunctionToolbelt.Parameters<F>>(fn: F): FunctionToolbelt.Curry<(...args: ListToolbelt.Merge<[P[1], P[0]], P>) => FunctionToolbelt.Return<F>>;
import { flip } from './flip'
import { subtract } from './subtract'
import { update } from './update'
test('function with arity of 2', () => {
const subtractFlipped = flip(subtract)
expect(subtractFlipped(1)(7)).toEqual(6)
expect(subtractFlipped(1, 7)).toEqual(6)
expect(subtractFlipped(
1, 7, 9
)).toEqual(6)
})
test('function with arity of 3', () => {
const updateFlipped = flip(update)
const result = updateFlipped(
88, 0, [ 1, 2, 3 ]
)
const curriedResult = updateFlipped(88, 0)([ 1, 2, 3 ])
const tripleCurriedResult = updateFlipped(88)(0)([ 1, 2, 3 ])
expect(result).toEqual([ 88, 2, 3 ])
expect(curriedResult).toEqual([ 88, 2, 3 ])
expect(tripleCurriedResult).toEqual([ 88, 2, 3 ])
})
test('function with arity of 4', () => {
const testFunction = (
a, b, c, d
) => `${ a - b }==${ c - d }`
const testFunctionFlipped = flip(testFunction)
const result = testFunction(
1, 2, 3, 4
)
const flippedResult = testFunctionFlipped(
2, 1, 3, 4
)
expect(result).toEqual(flippedResult)
expect(result).toEqual('-1==-1')
})
test('function with arity of 5', () => {
const testFunction = (
a, b, c, d, e
) => `${ a - b }==${ c - d - e }`
const testFunctionFlipped = flip(testFunction)
expect(() => testFunctionFlipped(
1, 2, 3, 4, 5
)).toThrowWithMessage(Error,
'R.flip doesn\'t work with arity > 4')
})
forEach<T>(fn: MapFunctionArray<T, void>, list: readonly T[]): T[]
It applies iterable function over all members of list and returns list.
:boom: It works with objects, unlike
Ramda.
const sideEffect = {}
const result = R.forEach(
x => sideEffect[`foo${x}`] = x
)([1, 2])
sideEffect //=> {foo1: 1, foo2: 2}
result //=> [1, 2]
Try this R.forEach example in Rambda REPL
forEach<T>(fn: MapFunctionArray<T, void>, list: readonly T[]): T[];
forEach<T>(fn: MapFunctionArray<T, void>): (list: readonly T[]) => T[];
forEach<T>(fn: MapFunctionObject<T, void>, list: Dictionary<T>): Dictionary<T>;
forEach<T, U>(fn: MapFunctionObject<T, void>): (list: Dictionary<T>) => Dictionary<T>;
import { forEach } from './forEach'
import { type } from './type'
test('iterate over object', () => {
const obj = {
a : 1,
b : [ 1, 2 ],
c : { d : 7 },
f : 'foo',
}
const result = {}
const returned = forEach((
val, prop, inputObj
) => {
expect(type(inputObj)).toBe('Object')
result[ prop ] = `${ prop }-${ type(val) }`
})(obj)
const expected = {
a : 'a-Number',
b : 'b-Array',
c : 'c-Object',
f : 'f-String',
}
expect(result).toEqual(expected)
expect(returned).toEqual(obj)
})
test('happy', () => {
const sideEffect = {}
forEach(x => sideEffect[ `foo${ x }` ] = x + 10)([ 1, 2 ])
expect(sideEffect).toEqual({
foo1 : 11,
foo2 : 12,
})
})
test('with empty list', () => {
const list = []
const result = forEach(x => x * x)(list)
expect(result).toEqual(list)
})
test('with wrong input', () => {
const list = undefined
const result = forEach(x => x * x)(list)
expect(result).toBeUndefined()
})
test('returns the input', () => {
const list = [ 1, 2, 3 ]
const result = forEach(x => x * x)(list)
expect(result).toEqual(list)
})
forEachIndexed<T>(fn: MapFunctionArrayIndexed<T, void>, list: readonly T[]): T[]
forEachIndexed<T>(fn: MapFunctionArrayIndexed<T, void>, list: readonly T[]): T[];
forEachIndexed<T>(fn: MapFunctionArrayIndexed<T, void>): (list: readonly T[]) => T[];
forEachIndexed<T>(fn: MapFunctionObject<T, void>, list: Dictionary<T>): Dictionary<T>;
forEachIndexed<T, U>(fn: MapFunctionObject<T, void>): (list: Dictionary<T>) => Dictionary<T>;
// RAMBDAX_MARKER_END
// ============================================
export as namespace R
import { forEachIndexed } from './forEachIndexed'
const list = [ 1, 2, 3 ]
const iterator = (x, i) => {
expect(x).toBeNumber()
expect(i).toBeNumber()
}
test('happy', () => {
const result = forEachIndexed(iterator, list)
expect(result).toEqual(list)
})
test('curried', () => {
const result = forEachIndexed(iterator)(list)
expect(result).toEqual(list)
})
fromPairs<V>(listOfPairs: KeyValuePair<string, V>[]): { [index: string]: V }
It transforms a listOfPairs to an object.
const listOfPairs = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ] ]
const expected = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
const result = R.fromPairs(listOfPairs)
// => `result` is equal to `expected`
Try this R.fromPairs example in Rambda REPL
fromPairs<V>(listOfPairs: KeyValuePair<string, V>[]): { [index: string]: V };
fromPairs<V>(listOfPairs: KeyValuePair<number, V>[]): { [index: number]: V };
import { fromPairs } from './fromPairs'
const list = [
[ 'a', 1 ],
[ 'b', 2 ],
[ 'c', [ 3, 4 ] ],
]
const expected = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
test('happy', () => {
expect(fromPairs(list)).toEqual(expected)
})
getter<T>(keyOrKeys: string | string[] | undefined): T
The set of methods R.setter, R.getter and R.reset allow different parts of your logic to access comminicate indirectly via shared cache object.
Usually these methods show that you might need to refactor to classes. Still, they can be helpful meanwhile.
R.getter: It provides access to the cache object. If undefined is used as a key, this method will return the whole cache object. If string is passed, then it will return cache value for this key. If array of string is passed, then it assume that this is array of keys and it will return the corresponding cache values for these keys.
R.setter: It allows cache object's keys to be changed. You can either set individual key-value pairs with R.setter(key, value) or you pass directly object, which will be merged with the cache object.
R.reset: It resets the cache object.
R.setter('foo','bar')
R.setter('a', 1)
R.getter(['foo','a']) // => {foo: 'bar', a: 1}
R.setter('a', 2)
R.getter('a') // => 2
R.reset()
R.getter('a') // => undefined
Try this R.getter example in Rambda REPL
getter<T>(keyOrKeys: string | string[] | undefined): T;
import { add } from './add'
import { getter, reset, setter } from './getter'
afterEach(() => {
reset()
})
test('happy', () => {
const key = 'foo'
setter(key, 1)
expect(getter(key)).toBe(1)
})
test('docs example', () => {
setter('foo', 'bar')
setter('a', 1)
expect(getter([ 'foo', 'a' ])).toEqual({
foo : 'bar',
a : 1,
})
setter('a', 2)
expect(getter('a')).toBe(2)
reset()
expect(getter('a')).toBeUndefined()
})
test('when array is key in getter', () => {
setter({
a : 1,
b : 2,
c : 3,
})
expect(getter([ 'a', 'b' ])).toEqual({
a : 1,
b : 2,
})
})
test('getter with undefined as key returns all', () => {
const data = {
a : 1,
b : 2,
c : 3,
}
setter(data)
expect(getter()).toEqual(data)
})
test('function as setter value', () => {
const data = {
a : 1,
b : 2,
c : 3,
}
setter(data)
setter('a', add(10))
expect(getter()).toEqual({
a : 11,
b : 2,
c : 3,
})
})
test('setter fallbacks to undefined', () => {
expect(setter()).toBeUndefined
})
glue(input: string, glueString?: string): string
It transforms multiline string to single line by gluing together the separate lines with the glueString and removing the empty spaces. By default glueString is equal to single space, so if that is what you need, then you can just pass a single argument.
const result = R.glue(`
foo
bar
baz
`)
// => 'foo bar baz'
Try this R.glue example in Rambda REPL
glue(input: string, glueString?: string): string;
import { glue } from './glue'
test('empty string as a glue', () => {
const result = glue(`
foo
bar
baz
`,
'')
const expectedResult = 'foobarbaz'
expect(result).toBe(expectedResult)
})
test('case 0', () => {
const zero = 'node node_modules/jest'
const first = '--runInBand'
const last = '-- src/a.spec.js'
const flag = false
const result = glue(`
${ zero }
${ first }
${ flag ? '--env=node' : '' }
${ last }
`)
const expectedResult = `${ zero } ${ first } ${ last }`
expect(result).toBe(expectedResult)
})
test('case 1', () => {
const zero = 'node node_modules/jest'
const first = '--runInBand'
const last = '-- src/a.spec.js'
const flag = true
const result = glue(`
${ zero }
${ first }
${ flag ? '--env=node' : '' }
${ last }
`)
const expectedResult = `${ zero } ${ first } --env=node ${ last }`
expect(result).toBe(expectedResult)
})
test('case 2', () => {
const first = '--runInBand'
const result = glue(`
zero
${ first }
last
`)
const expectedResult = `zero ${ first } last`
expect(result).toBe(expectedResult)
})
test('case 3', () => {
const result = glue(`
foo
bar
baz
`)
const expectedResult = 'foo bar baz'
expect(result).toBe(expectedResult)
})
test('with glue', () => {
const result = glue(`
foo
bar
baz
`,
'==')
const expectedResult = 'foo==bar==baz'
expect(result).toBe(expectedResult)
})
groupBy<T>(groupFn: (x: T) => string, list: readonly T[]): { [index: string]: T[] }
It splits list according to a provided groupFn function and returns an object.
const list = [ 'a', 'b', 'aa', 'bb' ]
const groupFn = x => x.length
const result = R.groupBy(groupFn, list)
// => { '1': ['a', 'b'], '2': ['aa', 'bb'] }
Try this R.groupBy example in Rambda REPL
groupBy<T>(groupFn: (x: T) => string, list: readonly T[]): { [index: string]: T[] };
groupBy<T>(groupFn: (x: T) => string): (list: readonly T[]) => { [index: string]: T[] };
import { groupBy } from './groupBy'
import { prop } from './prop'
test('groupBy', () => {
const list = [
{
age : 12,
name : 'john',
},
{
age : 12,
name : 'jack',
},
{
age : 24,
name : 'mary',
},
{
age : 24,
name : 'steve',
},
]
const expectedResult = {
12 : [
{
age : 12,
name : 'john',
},
{
age : 12,
name : 'jack',
},
],
24 : [
{
age : 24,
name : 'mary',
},
{
age : 24,
name : 'steve',
},
],
}
expect(groupBy(prop('age'))(list)).toEqual(expectedResult)
expect(groupBy(prop('age'), list)).toEqual(expectedResult)
})
groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: readonly T[]) => T[][]
It returns separated version of list or string input, where separation is done with equality compareFn function.
const compareFn = (x, y) => x === y
const list = [1, 2, 2, 1, 1, 2]
const result = R.groupWith(isConsecutive, list)
// => [[1], [2,2], [1,1], [2]]
Try this R.groupWith example in Rambda REPL
groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: readonly T[]) => T[][];
groupWith<T>(compareFn: (x: T, y: T) => boolean, input: readonly T[]): T[][];
groupWith<T>(compareFn: (x: T, y: T) => boolean, input: string): string[];
import { equals } from './equals'
import { groupWith } from './groupWith'
test('issue is fixed', () => {
const result = groupWith(equals, [ 1, 2, 2, 3 ])
const expected = [ [ 1 ], [ 2, 2 ], [ 3 ] ]
expect(result).toEqual(expected)
})
test('long list', () => {
const result = groupWith(equals, [
0,
1,
1,
2,
3,
5,
8,
13,
21,
21,
21,
1,
2,
])
const expected = [
[ 0 ],
[ 1, 1 ],
[ 2 ],
[ 3 ],
[ 5 ],
[ 8 ],
[ 13 ],
[ 21, 21, 21 ],
[ 1 ],
[ 2 ],
]
expect(result).toEqual(expected)
})
test('readme example', () => {
const list = [ 4, 3, 6, 2, 2, 1 ]
const result = groupWith((a, b) => a - b === 1, list)
const expected = [ [ 4, 3 ], [ 6 ], [ 2 ], [ 2, 1 ] ]
expect(result).toEqual(expected)
})
test('throw with string as input', () => {
expect(() => groupWith(equals, 'Mississippi')).toThrowWithMessage(TypeError,
'list.reduce is not a function')
})
const isConsecutive = function (a, b){
return a + 1 === b
}
test('fix coverage', () => {
expect(groupWith(isConsecutive, [ 1, 2, 3, 0 ])).toEqual([ [ 1, 2, 3 ], [ 0 ] ])
})
test('from ramda 0', () => {
expect(groupWith(equals, [])).toEqual([])
expect(groupWith(isConsecutive, [])).toEqual([])
})
test('from ramda 1', () => {
expect(groupWith(isConsecutive, [ 4, 3, 2, 1 ])).toEqual([
[ 4 ],
[ 3 ],
[ 2 ],
[ 1 ],
])
})
test('from ramda 2', () => {
expect(groupWith(isConsecutive, [ 1, 2, 3, 4 ])).toEqual([ [ 1, 2, 3, 4 ] ])
})
test('from ramda 3', () => {
expect(groupWith(isConsecutive, [ 1, 2, 2, 3 ])).toEqual([
[ 1, 2 ],
[ 2, 3 ],
])
expect(groupWith(isConsecutive, [ 1, 2, 9, 3, 4 ])).toEqual([
[ 1, 2 ],
[ 9 ],
[ 3, 4 ],
])
})
test('list with single item', () => {
const result = groupWith(equals, [ 0 ])
const expected = [ [ 0 ] ]
expect(result).toEqual(expected)
})
has<T>(prop: string, obj: T): boolean
It returns true if obj has property prop.
const obj = {a: 1}
const result = [
R.has('a', obj),
R.has('b', obj)
]
// => [true, false]
Try this R.has example in Rambda REPL
has<T>(prop: string, obj: T): boolean;
has(prop: string): <T>(obj: T) => boolean;
import { has } from './has'
test('happy', () => {
expect(has('a')({ a : 1 })).toBeTrue()
expect(has('b', { a : 1 })).toBeFalse()
})
test('with non-object', () => {
expect(has('a', undefined)).toEqual(false)
expect(has('a', null)).toEqual(false)
expect(has('a', true)).toEqual(false)
expect(has('a', '')).toEqual(false)
expect(has('a', /a/)).toEqual(false)
})
hasPath<T>(
path: string | readonly string[],
input: object
): boolean
It will return true, if input object has truthy path(calculated with R.path).
const path = 'a.b'
const pathAsArray = ['a', 'b']
const obj = {a: {b: []}}
const result = [
R.hasPath(path, obj),
R.hasPath(pathAsArray, obj),
R.hasPath('a.c', obj),
]
// => [true, true, false]
Try this R.hasPath example in Rambda REPL
hasPath<T>(
path: string | readonly string[],
input: object
): boolean;
hasPath<T>(
path: string | readonly string[]
): (input: object) => boolean;
import { hasPath } from './hasPath'
test('when true', () => {
const path = 'a.b'
const obj = { a : { b : [] } }
const result = hasPath(path)(obj)
const expectedResult = true
expect(result).toEqual(expectedResult)
})
test('when false', () => {
const path = 'a.b'
const obj = {}
const result = hasPath(path, obj)
const expectedResult = false
expect(result).toEqual(expectedResult)
})
head<T>(input: readonly T[]): T | undefined
It returns the first element of list or string input.
const result = [
R.head([1, 2, 3]),
R.head('foo')
]
// => [1, 'f']
Try this R.head example in Rambda REPL
head<T>(input: readonly T[]): T | undefined;
head(input: string): string;
import { head } from './head'
test('head', () => {
expect(head([ 'fi', 'fo', 'fum' ])).toEqual('fi')
expect(head([])).toEqual(undefined)
expect(head('foo')).toEqual('f')
expect(head('')).toEqual('')
})
identical<T>(x: T, y: T): boolean
It returns true if its arguments a and b are identical.
Otherwise, it returns false.
:boom: Values are identical if they reference the same memory.
NaNis identical toNaN;0and-0are not identical.
const obj = {a: 1};
R.identical(obj, obj); //=> true
R.identical(1, 1); //=> true
R.identical(1, '1'); //=> false
R.identical([], []); //=> false
R.identical(0, -0); //=> false
R.identical(NaN, NaN); //=> true
Try this R.identical example in Rambda REPL
identical<T>(x: T, y: T): boolean;
identical<T>(x: T): (y: T) => boolean;
import { F, T } from '../rambda'
import { _isInteger } from './_internals/_isInteger'
import { _objectIs } from './_internals/_objectIs'
import { identical } from './identical'
test('with boolean', () => {
expect(F()).toBeFalse()
expect(T()).toBeTrue()
})
test('internal isInteger', () => {
expect(_isInteger(1)).toBeTrue()
expect(_isInteger(0.3)).toBeFalse()
})
test('internal objectIs', () => {
expect(_objectIs(1, 1)).toBeTrue()
expect(_objectIs(NaN, NaN)).toBeTrue()
})
test('identical', () => {
const a = {}
expect(identical(100)(100)).toEqual(true)
expect(identical(100, '100')).toEqual(false)
expect(identical('string', 'string')).toEqual(true)
expect(identical([], [])).toEqual(false)
expect(identical(a, a)).toEqual(true)
expect(identical(undefined, undefined)).toEqual(true)
expect(identical(null, undefined)).toEqual(false)
})
identity<T>(input: T): T
It just passes back the supplied input argument.
:boom: Logic
R.identity(7) // => 7
Try this R.identity example in Rambda REPL
identity<T>(input: T): T;
import { identity } from './identity'
test('happy', () => {
expect(identity(7)).toEqual(7)
expect(identity(true)).toEqual(true)
expect(identity({ a : 1 })).toEqual({ a : 1 })
})
ifElse<T, U>(
condition: (x: T) => boolean,
onTrue: (x: T) => U,
onFalse: (x: T) => U,
): (x: T) => U
It expects condition, onTrue and onFalse functions as inputs and it returns a new function with example name of fn.
When fn`` is called with inputargument, it will return eitheronTrue(input)oronFalse(input)depending oncondition(input)` evaluation.
const fn = R.ifElse(
x => x>10,
x => x*2,
x => x*10
)
const result = [ fn(8), fn(18) ]
// => [80, 36]
Try this R.ifElse example in Rambda REPL
ifElse<T, U>(
condition: (x: T) => boolean,
onTrue: (x: T) => U,
onFalse: (x: T) => U,
): (x: T) => U;
ifElse<T, K, U>(
condition: (x: T, y: K) => boolean,
onTrue: (x: T, y: K) => U,
onFalse: (x: T, y: K) => U,
): (x: T, y: K) => U;
import { always } from './always'
import { has } from './has'
import { identity } from './identity'
import { ifElse } from './ifElse'
import { prop } from './prop'
const condition = has('foo')
const v = function (a){
return typeof a === 'number'
}
const t = function (a){
return a + 1
}
const ifFn = x => prop('foo', x).length
const elseFn = () => false
test('happy', () => {
const fn = ifElse(condition, ifFn)(elseFn)
expect(fn({ foo : 'bar' })).toEqual(3)
expect(fn({ fo : 'bar' })).toEqual(false)
})
test('ramda spec', () => {
const ifIsNumber = ifElse(v)
expect(ifIsNumber(t, identity)(15)).toEqual(16)
expect(ifIsNumber(t, identity)('hello')).toEqual('hello')
})
test('pass all arguments', () => {
const identity = function (a){
return a
}
const v = function (){
return true
}
const onTrue = function (a, b){
expect(a).toEqual(123)
expect(b).toEqual('abc')
}
ifElse(
v, onTrue, identity
)(123, 'abc')
})
test('accept constant as condition', () => {
const fn = ifElse(true)(always(true))(always(false))
expect(fn()).toEqual(true)
})
test('accept constant as condition - case 2', () => {
const fn = ifElse(
false, always(true), always(false)
)
expect(fn()).toEqual(false)
})
test('curry 1', () => {
const fn = ifElse(condition, ifFn)(elseFn)
expect(fn({ foo : 'bar' })).toEqual(3)
expect(fn({ fo : 'bar' })).toEqual(false)
})
test('curry 2', () => {
const fn = ifElse(condition)(ifFn)(elseFn)
expect(fn({ foo : 'bar' })).toEqual(3)
expect(fn({ fo : 'bar' })).toEqual(false)
})
test('simple arity of 1', () => {
const condition = x => x > 5
const onTrue = x => x + 1
const onFalse = x => x + 10
const result = ifElse(
condition, onTrue, onFalse
)(1)
expect(result).toBe(11)
})
test('simple arity of 2', () => {
const condition = (x, y) => x + y > 5
const onTrue = (x, y) => x + y + 1
const onFalse = (x, y) => x + y + 10
const result = ifElse(
condition, onTrue, onFalse
)(1, 10)
expect(result).toBe(12)
})
ifElseAsync<T, U>(
condition: (x: T) => Promise<boolean>,
onTrue: (x: T) => U,
onFalse: (x: T) => U,
): (x: T) => Promise<U>
Asynchronous version of R.ifElse. Any of condition, ifFn and elseFn can be either asynchronous or synchronous function.
const condition = async x => {
await R.delay(100)
return x > 1
}
const ifFn = async x => {
await R.delay(100)
return x + 1
}
const elseFn = async x => {
await R.delay(100)
return x - 1
}
const result = await R.ifElseAsync(
condition,
ifFn,
elseFn
)(1)
// => 0
Try this R.ifElseAsync example in Rambda REPL
ifElseAsync<T, U>(
condition: (x: T) => Promise<boolean>,
onTrue: (x: T) => U,
onFalse: (x: T) => U,
): (x: T) => Promise<U>;
ifElseAsync<T, U>(
condition: (x: T) => boolean,
onTrue: (x: T) => Promise<U>,
onFalse: (x: T) => Promise<U>,
): (x: T) => Promise<U>;
ifElseAsync<T, U>(
condition: (x: T) => Promise<boolean>,
onTrue: (x: T) => Promise<U>,
onFalse: (x: T) => Promise<U>,
): (x: T) => Promise<U>;
ifElseAsync<T, K, U>(
condition: (x: T, y: K) => Promise<boolean>,
onTrue: (x: T, y: K) => U,
onFalse: (x: T, y: K) => U,
): (x: T, y: K) => Promise<U>;
ifElseAsync<T, K, U>(
condition: (x: T, y: K) => boolean,
onTrue: (x: T, y: K) => Promise<U>,
onFalse: (x: T, y: K) => Promise<U>,
): (x: T, y: K) => Promise<U>;
ifElseAsync<T, K, U>(
condition: (x: T, y: K) => Promise<boolean>,
onTrue: (x: T, y: K) => Promise<U>,
onFalse: (x: T, y: K) => Promise<U>,
): (x: T, y: K) => Promise<U>;
import { delay } from './delay'
import { ifElseAsync } from './ifElseAsync'
test('arity of 1 - condition is async', async () => {
const condition = async x => {
await delay(100)
return x > 4
}
const whenTrue = x => x + 1
const whenFalse = x => x + 10
const fn = ifElseAsync(
condition, whenTrue, whenFalse
)
const result = await Promise.all([ fn(5), fn(1) ])
expect(result).toEqual([ 6, 11 ])
})
test('arity of 1 - condition is sync', async () => {
const condition = x => x > 4
const whenTrue = async x => {
await delay(100)
return x + 1
}
const whenFalse = async x => {
await delay(100)
return x + 10
}
const fn = ifElseAsync(
condition, whenTrue, whenFalse
)
const result = await Promise.all([ fn(5), fn(1) ])
expect(result).toEqual([ 6, 11 ])
})
test('arity of 1 - all inputs are async', async () => {
const condition = async x => {
await delay(100)
return x > 4
}
const whenTrue = async x => {
await delay(100)
return x + 1
}
const whenFalse = async x => {
await delay(100)
return x + 10
}
const fn = ifElseAsync(
condition, whenTrue, whenFalse
)
const result = await Promise.all([ fn(5), fn(1) ])
expect(result).toEqual([ 6, 11 ])
})
test('arity of 2 - condition is async', async () => {
const condition = async (x, y) => {
await delay(100)
return x + y > 4
}
const whenTrue = (x, y) => x + y + 1
const whenFalse = (x, y) => x + y + 10
const fn = ifElseAsync(
condition, whenTrue, whenFalse
)
const result = await Promise.all([ fn(14, 20), fn(1, 3) ])
expect(result).toEqual([ 35, 14 ])
})
test('arity of 2 - condition is sync', async () => {
const condition = (x, y) => x + y > 4
const whenTrue = async (x, y) => {
await delay(100)
return x + y + 1
}
const whenFalse = async (x, y) => {
await delay(100)
return x + y + 10
}
const fn = ifElseAsync(
condition, whenTrue, whenFalse
)
const result = await Promise.all([ fn(14, 20), fn(1, 3) ])
expect(result).toEqual([ 35, 14 ])
})
test('arity of 2 - all inputs are async', async () => {
const condition = async (x, y) => {
await delay(100)
return x + y > 4
}
const whenTrue = async (x, y) => {
await delay(100)
return x + y + 1
}
const whenFalse = async (x, y) => {
await delay(100)
return x + y + 10
}
const fn = ifElseAsync(
condition, whenTrue, whenFalse
)
const result = await Promise.all([ fn(14, 20), fn(1, 3) ])
expect(result).toEqual([ 35, 14 ])
})
inc(x: number): number
It increments a number.
R.inc(1) // => 2
Try this R.inc example in Rambda REPL
inc(x: number): number;
import { inc } from './inc'
test('happy', () => {
expect(inc(1)).toBe(2)
})
includes(valueToFind: string, input: readonly string[] | string): boolean
If input is string, then this method work as native String.includes.
If input is array, then R.equals is used to define if valueToFind belongs to the list.
const result = [
R.includes('oo', 'foo'),
R.includes({a: 1}, [{a: 1}])
]
// => [true, true ]
Try this R.includes example in Rambda REPL
includes(valueToFind: string, input: readonly string[] | string): boolean;
includes(valueToFind: string): (input: readonly string[] | string) => boolean;
includes<T>(valueToFind: T, input: readonly T[]): boolean;
includes<T>(valueToFind: T): (input: readonly T[]) => boolean;
import R from 'ramda'
import { includes } from './includes'
test('includes with string', () => {
const str = 'foo bar'
expect(includes('bar')(str)).toBeTrue()
expect(R.includes('bar')(str)).toBeTrue()
expect(includes('never', str)).toBeFalse()
expect(R.includes('never', str)).toBeFalse()
})
test('includes with array', () => {
const arr = [ 1, 2, 3 ]
expect(includes(2)(arr)).toBeTrue()
expect(R.includes(2)(arr)).toBeTrue()
expect(includes(4, arr)).toBeFalse()
expect(R.includes(4, arr)).toBeFalse()
})
test('with wrong input that does not throw', () => {
const result = includes(1, /foo/g)
const ramdaResult = R.includes(1, /foo/g)
expect(result).toBeFalse()
expect(ramdaResult).toBeFalse()
})
test('throws on wrong input - match ramda behaviour', () => {
expect(() => includes(2, null)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of null')
expect(() => R.includes(2, null)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of null')
expect(() => includes(2, undefined)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of undefined')
expect(() => R.includes(2, undefined)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of undefined')
})
indexBy<T>(condition: (x: T) => string, list: readonly T[]): { [key: string]: T }
It generates object with properties provided by condition and values provided by list array.
If condition is a function, then all list members are passed through it.
If condition is a string, then all list members are passed through R.path(condition).
const list = [ {id: 10}, {id: 20} ]
const withFunction = R.indexBy(
x => x.id,
list
)
const withString = R.indexBy(
'id',
list
)
const result = [
withFunction,
R.equals(withFunction, withString)
]
// => [ { 10: {id: 10}, 20: {id: 20} }, true ]
Try this R.indexBy example in Rambda REPL
indexBy<T>(condition: (x: T) => string, list: readonly T[]): { [key: string]: T };
indexBy<T>(condition: string, list: readonly T[]): { [key: string]: T };
indexBy<T>(condition: (x: T) => string): (list: readonly T[]) => { [key: string]: T };
indexBy<T>(condition: string): (list: readonly T[]) => { [key: string]: T };
import { indexBy } from './indexBy'
import { prop } from './prop'
test('happy', () => {
const list = [
{ id : 1 },
{
id : 1,
a : 2,
},
{ id : 2 },
{ id : 10 },
{ id : 'a' },
]
expect(indexBy(prop('id'))(list)).toEqual({
1 : {
id : 1,
a : 2,
},
2 : { id : 2 },
10 : { id : 10 },
a : { id : 'a' },
})
})
test('with string as condition', () => {
const list = [ { id : 1 }, { id : 2 }, { id : 10 }, { id : 'a' } ]
const standardResult = indexBy(obj => obj.id, list)
const suggestionResult = indexBy('id', list)
expect(standardResult).toEqual(suggestionResult)
})
test('with string - bad path', () => {
const list = [
{
a : {
b : 1,
c : 2,
},
},
{ a : { c : 4 } },
{},
{
a : {
b : 10,
c : 20,
},
},
]
const result = indexBy('a.b', list)
const expected = {
1 : {
a : {
b : 1,
c : 2,
},
},
10 : {
a : {
b : 10,
c : 20,
},
},
undefined : {},
}
expect(result).toEqual(expected)
})
indexOf<T>(valueToFind: T, list: readonly T[]): number
It returns the index of the first element of list equals to valueToFind.
If there is no such element, it returns -1.
const list = [0, 1, 2, 3]
const result = [
R.indexOf(2, list),
R.indexOf(0, list)
]
// => [2, -1]
Try this R.indexOf example in Rambda REPL
indexOf<T>(valueToFind: T, list: readonly T[]): number;
indexOf<T>(valueToFind: T): (list: readonly T[]) => number;
import { indexOf } from './indexOf'
test('happy', () => {
expect(indexOf(3, [ 1, 2, 3, 4 ])).toEqual(2)
expect(indexOf(10)([ 1, 2, 3, 4 ])).toEqual(-1)
})
init<T>(input: readonly T[]): T[]
It returns all but the last element of list or string input.
const result = [
R.init([1, 2, 3]) ,
R.init('foo') // => 'fo'
]
// => [[1, 2], 'fo']
Try this R.init example in Rambda REPL
init<T>(input: readonly T[]): T[];
init(input: string): string;
import { init } from './init'
test('with array', () => {
expect(init([ 1, 2, 3 ])).toEqual([ 1, 2 ])
expect(init([ 1, 2 ])).toEqual([ 1 ])
expect(init([ 1 ])).toEqual([])
expect(init([])).toEqual([])
expect(init([])).toEqual([])
expect(init([ 1 ])).toEqual([])
})
test('with string', () => {
expect(init('foo')).toEqual('fo')
expect(init('f')).toEqual('')
expect(init('')).toEqual('')
})
interpolate(inputWithTags: string, templateArguments: object): string
It generages a new string from inputWithTags by replacing all {{x}} occurances with values provided by templateArguments.
const inputWithTags = 'foo is {{bar}} even {{a}} more'
const templateArguments = {"bar":"BAR", a: 1}
const result = R.interpolate(inputWithTags, templateArguments)
const expected = 'foo is BAR even 1 more'
// => `result` is equal to `expected`
Try this R.interpolate example in Rambda REPL
interpolate(inputWithTags: string, templateArguments: object): string;
interpolate(inputWithTags: string): (templateArguments: object) => string;
import { interpolate } from './interpolate'
test('within bracets', () => {
const input = 'foo is { {{bar}} } even {{a}} more'
const templateInput = {
bar : 'BAR',
a : 1,
}
const result = interpolate(input, templateInput)
const expectedResult = 'foo is { BAR } even 1 more'
expect(result).toEqual(expectedResult)
})
test('happy', () => {
const input = 'foo is {{bar}} even {{a}} more'
const templateInput = {
bar : 'BAR',
a : 1,
}
const result = interpolate(input, templateInput)
const expectedResult = 'foo is BAR even 1 more'
expect(result).toEqual(expectedResult)
})
test('no interpolation + curry', () => {
const input = 'foo is bar even more'
const templateInput = { bar : 'BAR' }
const result = interpolate(input)(templateInput)
const expectedResult = 'foo is bar even more'
expect(result).toEqual(expectedResult)
})
test('with missing template input', () => {
const input = 'foo is {{bar}} even {{a}} more'
const templateInput = {
baz : 'BAR',
a : 1,
}
const result = interpolate(input, templateInput)
const expectedResult = 'foo is {{bar}} even 1 more'
expect(result).toEqual(expectedResult)
})
test('with arbitrary expression', () => {
const input = '1 + 2 = {{ 1 + 2 }}'
const templateInput = {}
const expectedResult = '1 + 2 = 3'
const result = interpolate(input, templateInput)
expect(result).toEqual(expectedResult)
})
intersection<T>(listA: readonly T[], listB: readonly T[]): T[]
It loops throw listA and listB and returns the intersection of the two according to R.equals.
const listA = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
const listB = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
const result = intersection(listA, listB)
// => [{ id : 3 }, { id : 4 }]
Try this R.intersection example in Rambda REPL
intersection<T>(listA: readonly T[], listB: readonly T[]): T[];
intersection<T>(listA: readonly T[]): (listB: readonly T[]) => T[];
import { intersection } from './intersection'
test('intersection', () => {
const list1 = [ 1, 2, 3, 4 ]
const list2 = [ 3, 4, 5, 6 ]
expect(intersection(list1)(list2)).toEqual([ 3, 4 ])
expect(intersection([], [])).toEqual([])
})
test('intersection with objects', () => {
const list1 = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
const list2 = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
expect(intersection(list1)(list2)).toEqual([ { id : 3 }, { id : 4 } ])
})
intersperse<T>(separator: T, list: readonly T[]): T[]
It adds a separator between members of list.
const list = [ 0, 1, 2, 3 ]
const separator = '|'
const result = intersperse(separator, list)
// => [0, '|', 1, '|', 2, '|', 3]
Try this R.intersperse example in Rambda REPL
intersperse<T>(separator: T, list: readonly T[]): T[];
intersperse<T>(separator: T): (list: readonly T[]) => T[];
import { intersperse } from './intersperse'
test('intersperse', () => {
const list = [ { id : 1 }, { id : 2 }, { id : 10 }, { id : 'a' } ]
expect(intersperse('!', list)).toEqual([
{ id : 1 },
'!',
{ id : 2 },
'!',
{ id : 10 },
'!',
{ id : 'a' },
])
expect(intersperse('!')([])).toEqual([])
})
is(targetPrototype: any, x: any): boolean
It returns true if x is instance of targetPrototype.
const result = [
R.is(String, 'foo'),
R.is(Array, 1)
]
// => [true, false]
Try this R.is example in Rambda REPL
is(targetPrototype: any, x: any): boolean;
is(targetPrototype: any): (x: any) => boolean;
import { is } from './is'
test('works with built-in types', () => {
expect(is(Array, undefined)).toBeFalse()
expect(is(Array)([])).toBeTrue()
expect(is(Boolean, new Boolean(false))).toBeTrue()
expect(is(Date, new Date())).toBeTrue()
expect(is(Function, () => {})).toBeTrue()
expect(is(Number, new Number(0))).toBeTrue()
expect(is(Object, {})).toBeTrue()
expect(is(RegExp, /(?:)/)).toBeTrue()
expect(is(String, new String(''))).toBeTrue()
})
test('works with user-defined types', () => {
function Foo(){}
function Bar(){}
Bar.prototype = new Foo()
const foo = new Foo()
const bar = new Bar()
expect(is(Foo, foo)).toBeTrue()
expect(is(Bar, bar)).toBeTrue()
expect(is(Foo, bar)).toBeTrue()
expect(is(Bar, foo)).toBeFalse()
})
test('does not coerce', () => {
expect(is(Boolean, 1)).toBeFalse()
expect(is(Number, '1')).toBeFalse()
expect(is(Number, false)).toBeFalse()
})
test('recognizes primitives as their object equivalents', () => {
expect(is(Boolean, false)).toBeTrue()
expect(is(Number, 0)).toBeTrue()
expect(is(String, '')).toBeTrue()
})
test('does not consider primitives to be instances of Object', () => {
expect(is(Object, false)).toBeFalse()
expect(is(Object, 0)).toBeFalse()
expect(is(Object, '')).toBeFalse()
})
isEmpty<T>(x: T): boolean
It returns true if x is empty.
const result = [
R.isEmpty(''),
R.isEmpty({ x : 0 })
]
// => [true, false]
Try this R.isEmpty example in Rambda REPL
isEmpty<T>(x: T): boolean;
import { isEmpty } from './isEmpty'
test('happy', () => {
expect(isEmpty(undefined)).toEqual(false)
expect(isEmpty('')).toEqual(true)
expect(isEmpty(null)).toEqual(false)
expect(isEmpty(' ')).toEqual(false)
expect(isEmpty(new RegExp(''))).toEqual(false)
expect(isEmpty([])).toEqual(true)
expect(isEmpty([ [] ])).toEqual(false)
expect(isEmpty({})).toEqual(true)
expect(isEmpty({ x : 0 })).toEqual(false)
expect(isEmpty(0)).toEqual(false)
expect(isEmpty(NaN)).toEqual(false)
expect(isEmpty([ '' ])).toEqual(false)
})
isFunction(input: any): boolean
It returns true if R.type of input is Async or Function.
const result = [
R.isFunction(R.mapAsync),
R.isFunction(R.add),
]
// => [true, true]
Try this R.isFunction example in Rambda REPL
isFunction(input: any): boolean;
import { isFunction } from './isFunction'
test('when function', () => {
const fn = () => {}
expect(isFunction(fn)).toEqual(true)
})
test('when promise', () => {
const fn = Promise.resolve(2)
expect(isFunction(fn)).toBeFalse()
})
test('when async', () => {
const fn = async x => x
expect(isFunction(fn)).toEqual(true)
})
test('when false', () => {
expect(isFunction(null)).toEqual(false)
})
isNil(x: any): x is null | undefined
It returns true if x is either null or undefined.
const result = [
R.isNil(null),
R.isNil(1),
]
// => [true, false]
Try this R.isNil example in Rambda REPL
isNil(x: any): x is null | undefined;
import { isNil } from './isNil'
test('happy', () => {
expect(isNil(null)).toBeTrue()
expect(isNil(undefined)).toBeTrue()
expect(isNil([])).toBeFalse()
})
isPromise(input: any): boolean
isPromise(input: any): boolean;
isType(targetType: RambdaTypes, input: any): boolean
It returns true if targetType is equal to type of input according to R.type.
R.isType('Async',R.delay(1000))
// => true
Try this R.isType example in Rambda REPL
isType(targetType: RambdaTypes, input: any): boolean;
isType(targetType: RambdaTypes): (input: any) => boolean;
import { isType } from './isType'
const list = [ 1, 2, 3 ]
test('array', () => {
expect(isType('Array', list)).toBeTruthy()
expect(isType('Array')([])).toBeTruthy()
})
test('promise', () => {
expect(isType('Promise', Promise.resolve(1))).toBeTruthy()
})
isValid({input: object, schema: Schema}): boolean
It checks if input is following schema specifications.
If validation fails, it returns false.
Please check the detailed explanation as it is hard to write a short description for this method.
:boom: Independently, somebody else came with very similar idea called superstruct
const input = {a: ['foo', 'bar']}
const invalidInput = {a: ['foo', 'bar', 1]}
const schema = {a: [String]}
const result = [
R.isValid({schema, input}),
R.isValid({schema, input: invalidInput})
]
// => [true, false]
Try this R.isValid example in Rambda REPL
isValid({input: object, schema: Schema}): boolean;
import { delay } from './delay'
import { isPrototype, isValid } from './isValid'
test('is prototype', () => {
expect(isPrototype(Promise)).toBeTrue()
expect(isPrototype(Number)).toBeTrue()
expect(isPrototype(Boolean)).toBeTrue()
expect(isPrototype(String)).toBeTrue()
expect(isPrototype(0)).toBeFalse()
})
test('prototype inside array', () => {
const input = { a : [ 1, 2, 3, 4 ] }
const schema = { a : [ Number ] }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('with Promise prototype', () => {
const input = { a : [ delay(1), delay(2) ] }
const schema = { a : [ Promise ] }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('object prototype as rule - true', () => {
const input = { a : {} }
const schema = { a : Object }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('list of functions', () => {
const input = { a : [ () => {}, delay ] }
const schema = { a : [ 'function' ] }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('function schema type can be only string', () => {
const input = { a : [ () => {}, delay ] }
const schema = { a : [ Function ] }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('object prototype as rule - false', () => {
const input = { a : null }
const schema = { a : Object }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('number prototype as rule - true', () => {
const input = { a : 1 }
const schema = { a : Number }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('array prototype as rule - true', () => {
const input = { a : [ 1, 2, 3 ] }
const schema = { a : Array }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('array prototype as rule - false', () => {
const input = { a : null }
const schema = { a : Array }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('string prototype as rule - true', () => {
const input = { a : 'foo' }
const schema = { a : String }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('string prototype as rule - false', () => {
const input = { a : null }
const schema = { a : String }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('boolean prototype as rule - true', () => {
const input = { a : true }
const schema = { a : Boolean }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('boolean prototype as rule - false', () => {
const input = { a : null }
const schema = { a : Boolean }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('regex prototype cannot be rule - true', () => {
const input = { a : /foo/g }
const schema = { a : new RegExp('foo') }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('undefined as a rule - true', () => {
const input = { a : undefined }
const schema = { a : undefined }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('undefined as a rule - false', () => {
const input = { a : null }
const schema = { a : undefined }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('null as a rule - true', () => {
const input = { a : null }
const schema = { a : null }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('null as a rule - false', () => {
const input = { a : undefined }
const schema = { a : null }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('`any` safeguard against `null`', () => {
const input = { a : null }
const schema = { a : 'any' }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('`any` safeguard against `undefined`', () => {
const input = { a : undefined }
const schema = { a : 'any' }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('type can be `"any"`', () => {
const input = { a : () => {} }
const schema = { a : 'any' }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('type can be `"function"`', () => {
const input = { a : () => {} }
const schema = { a : 'function' }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('type can be `async`', () => {
const input = { a : async () => {} }
const schema = { a : 'async' }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('type can be `promise`', () => {
const input = { a : delay(1999) }
const schema = { a : 'promise' }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('type can be `promise` list', () => {
const input = { a : [ delay(1999) ] }
const schema = { a : [ 'promise' ] }
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('function as schema - false', () => {
const input = {
a : {
ab : () => true,
ac : 3,
},
c : [ 1, 2 ],
}
const schema = {
'a' : {
ab : /fo/,
ac : 'number',
},
'b?' : 'string',
'c' : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('regex ok', () => {
const input = {
a : {
ab : 'foo',
ac : 3,
},
c : [ 1, 2 ],
}
const schema = {
'a' : {
ab : /fo/,
ac : 'number',
},
'b?' : 'string',
'c' : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('regex !ok', () => {
const input = {
a : {
ab : 'foo',
ac : 3,
},
c : [ 1, 2 ],
}
const schema = {
'a' : {
ab : /ba/,
ac : 'number',
},
'b?' : 'string',
'c' : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('optional props is missing', () => {
const input = {
a : {
ab : 'foo',
ac : 3,
},
c : [ 1, 2 ],
}
const schema = {
'a' : {
ab : 'string',
ac : 'number',
},
'b?' : 'string',
'c' : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('optional props is wrong type', () => {
const input = {
a : {
ab : 'foo',
ac : 3,
},
b : [],
c : [ 1, 2 ],
}
const schema = {
'a' : {
ab : 'string',
ac : 'number',
},
'b?' : 'string',
'c' : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('optional props - nested', () => {
const input = {
a : {
ab : 'foo',
ac : 3,
},
b : [],
c : [ 1, 2 ],
}
const schema = {
a : {
'ab' : 'string',
'ac?' : 'number',
},
b : 'array',
c : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('optional props is missing - nested', () => {
const input = {
a : { ab : 'foo' },
b : [],
c : [ 1, 2 ],
}
const schema = {
a : {
'ab' : 'string',
'ac?' : 'number',
},
b : 'array',
c : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('optional props is wrong type - nested', () => {
const input = {
a : {
ab : 'foo',
ac : 'bar',
},
b : [],
c : [ 1, 2 ],
}
const schema = {
a : {
'ab' : 'string',
'ac?' : 'number',
},
b : 'array',
c : [ 'number' ],
}
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('nested schema', () => {
const input = {
a : {
b : 'str',
c : 3,
d : 'str',
},
b : 'foo',
}
const schema = {
a : {
b : 'string',
c : 'number',
d : 'string',
},
b : 'string',
}
expect(isValid({
input,
schema,
})).toBeTruthy()
const invalidInputFirst = {
a : {
b : 'str',
c : 3,
d : 'str',
},
b : 5,
}
expect(isValid({
input : invalidInputFirst,
schema,
})).toBeFalsy()
const invalidInputSecond = {
a : {
b : 'str',
c : 'str',
d : 'str',
},
b : 5,
}
expect(isValid({
input : invalidInputSecond,
schema,
})).toBeFalsy()
const invalidInputThird = {
a : { b : 'str' },
b : 5,
}
expect(isValid({
input : invalidInputThird,
schema,
})).toBeFalsy()
})
test('array of type', () => {
const input = {
a : [ 1, 2 ],
b : 'foo',
}
const schema = {
a : [ 'number' ],
b : 'string',
}
expect(isValid({
input,
schema,
})).toBeTruthy()
const invalidInput = {
a : [ 1, '1' ],
b : 'foo',
}
expect(isValid({
input : invalidInput,
schema,
})).toBeFalsy()
})
test('function as rule', () => {
const input = {
a : [ 1, 2, 3, 4 ],
b : 'foo',
}
const invalidInput = {
a : [ 4 ],
b : 'foo',
}
const schema = {
a : x => x.length > 2,
b : 'string',
}
expect(isValid({
input,
schema,
})).toBeTruthy()
expect(isValid({
input : invalidInput,
schema,
})).toBeFalsy()
})
test('input prop is undefined', () => {
const input = { b : 3 }
const schema = { a : 'number' }
expect(isValid({
input,
schema,
})).toBeFalsy()
})
test('enum', () => {
const input = { a : 'foo' }
const invalidInput = { a : '' }
const schema = { a : [ 'foo', 'bar', 'baz' ] }
expect(isValid({
input,
schema,
})).toBeTruthy()
expect(isValid({
input : invalidInput,
schema,
})).toBeFalsy()
})
test('readme example', () => {
const basicSchema = { a : [ 'string' ] }
const schema = {
b : [ basicSchema ],
c : {
d : { e : 'boolean' },
f : 'array',
},
g : [ 'foo', 'bar', 'baz' ],
}
const input = {
b : [ { a : [ 'led', 'zeppelin' ] } ],
c : {
d : { e : true },
f : [ 'any', 1, null, 'value' ],
},
g : 'foo',
}
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('should allow additional properties', () => {
const input = {
title : 'You shook me',
year : 1969,
}
expect(isValid({
input,
schema : { title : 'string' },
})).toBeTruthy()
})
test('accepts values as schemas', () => {
const input = {
title : 'You shook me',
genre : 'Blues',
year : 1969,
}
const schema = {
title : 'You shook me',
year : 1969,
}
expect(isValid({
input,
schema,
})).toBeTruthy()
})
test('compatible schemas with nested object', () => {
const input = {
foo : 'bar',
baz : { a : { b : 'c' } },
}
const invalidInputFirst = {
foo : 'bar',
baz : { a : { b : 1 } },
}
const invalidInputSecond = {
foo : 'bar',
baz : { a : { b : [] } },
}
const invalidInputThird = {
foo : 'bar',
baz : { a : { b : null } },
}
const schema = {
foo : 'string',
baz : { a : { b : 'string' } },
}
expect(isValid({
input,
schema,
})).toBeTruthy()
expect(isValid({
input : invalidInputFirst,
schema,
})).toBeFalsy()
expect(isValid({
input : invalidInputSecond,
schema,
})).toBeFalsy()
expect(isValid({
input : invalidInputThird,
schema,
})).toBeFalsy()
})
test('should return true when schema is empty object', () => {
expect(isValid({
input : { a : 1 },
schema : {},
})).toBeTruthy()
})
test('when schema is undefined', () => {
expect(isValid({
input : { a : 1 },
schema : undefined,
})).toBeFalsy()
})
test('should return false with invalid schema rule', () => {
const input = {
foo : 'bar',
a : {},
}
const inputSecond = { foo : 'bar' }
const schema = {
foo : 'string',
baz : { a : {} },
}
expect(isValid({
input,
schema,
})).toBeFalsy()
expect(isValid({
input : inputSecond,
schema,
})).toBeFalsy()
})
test('array of schemas', () => {
const input = {
b : [
{
a : 'led',
b : 1,
},
{
a : 'dancing',
b : 1,
},
],
}
const basicSchema = {
a : String,
b : Number,
}
const schema = { b : [ basicSchema ] }
const result = isValid({
input,
schema,
})
expect(result).toBeTruthy()
})
isValidAsync(x: IsValidAsync): Promise<boolean>
Asynchronous version of R.isValid
const input = {a: 1, b: 2}
const invalidInput = {a: 1, b: 'foo'}
const schema = {a: Number, b: async x => {
await R.delay(100)
return typeof x === 'number'
}}
const result = await Promise.all([
R.isValidAsync({schema, input}),
R.isValidAsync({schema, input: invalidInput})
])
// => [true, false]
Try this R.isValidAsync example in Rambda REPL
isValidAsync(x: IsValidAsync): Promise<boolean>;
import { result } from 'lodash'
import { delay } from './delay'
import { isValidAsync } from './isValidAsync'
const simplePredicate = async x => {
await delay(100)
return x > 5
}
test('happy', async () => {
const input = {
a : 1,
b : 7,
c : 9,
additional : 'foo',
}
const invalidInput = {
a : 1,
b : 2,
c : 9,
}
const schema = {
a : Number,
b : simplePredicate,
c : simplePredicate,
}
const invalidSchema = {
a : Boolean,
b : simplePredicate,
c : simplePredicate,
}
const result = await isValidAsync({
input,
schema,
})
const invalidResult = await isValidAsync({
input,
schema : invalidSchema,
})
const withInvalidInput = await isValidAsync({
input : invalidInput,
schema,
})
expect(result).toBeTruthy()
expect(invalidResult).toBeFalsy()
expect(withInvalidInput).toBeFalsy()
})
test('without async rules', async () => {
const input = {
a : 1,
b : 7,
}
const schema = {
a : Number,
b : x => x > 2,
}
const invalidSchema = {
a : Number,
b : Boolean,
}
const result = await isValidAsync({
input,
schema,
})
const invalidResult = await isValidAsync({
input,
schema : invalidSchema,
})
expect(result).toBeTruthy()
expect(invalidResult).toBeFalsy()
})
test('readme example', async () => {
const input = {
a : 1,
b : 2,
}
const invalidInput = {
a : 1,
b : 'foo',
}
const schema = {
a : Number,
b : async x => {
await delay(100)
return typeof x === 'number'
},
}
const result = await Promise.all([
isValidAsync({
schema,
input,
}),
isValidAsync({
schema,
input : invalidInput,
}),
])
expect(result).toEqual([ true, false ])
})
join<T>(glue: string, list: readonly T[]): string
It returns a string of all list instances joined with a glue.
R.join('-', [1, 2, 3]) // => '1-2-3'
Try this R.join example in Rambda REPL
join<T>(glue: string, list: readonly T[]): string;
join<T>(glue: string): (list: readonly T[]) => string;
import { join } from './join'
test('curry', () => {
expect(join('|')([ 'foo', 'bar', 'baz' ])).toEqual('foo|bar|baz')
expect(join('|', [ 1, 2, 3 ])).toEqual('1|2|3')
const spacer = join(' ')
expect(spacer([ 'a', 2, 3.4 ])).toEqual('a 2 3.4')
})
keys<T extends object>(x: T): (keyof T)[]
It applies Object.keys over x and returns its keys.
R.keys({a:1, b:2}) // => ['a', 'b']
Try this R.keys example in Rambda REPL
keys<T extends object>(x: T): (keyof T)[];
keys<T>(x: T): string[];
import { keys } from './keys'
test('happy', () => {
expect(keys({ a : 1 })).toEqual([ 'a' ])
})
last(str: string): string
It returns the last element of input, as the input can be either a string or an array.
const result = [
R.last([1, 2, 3]),
R.last('foo'),
]
// => [3, 'o']
Try this R.last example in Rambda REPL
last(str: string): string;
last(emptyList: []): undefined;
last<T extends any>(list: readonly T[]): T | undefined;
import { last } from './last'
test('happy', () => {
expect(last([ 'foo', 'bar', 'baz' ])).toEqual('baz')
expect(last([])).toEqual(undefined)
expect(last('abc')).toEqual('c')
expect(last('')).toEqual('')
})
lastIndexOf<T>(target: T, list: readonly T[]): number
It returns the last index of target in list array.
R.equals is used to determine equality between target and members of list.
If there is no such index, then -1 is returned.
const list = [1, 2, 3, 1, 2, 3]
const result = [
R.lastIndexOf(2, list),
R.lastIndexOf(4, list),
]
// => [4, -1]
Try this R.lastIndexOf example in Rambda REPL
lastIndexOf<T>(target: T, list: readonly T[]): number;
lastIndexOf<T>(target: T): (list: readonly T[]) => number;
import { lastIndexOf } from './lastIndexOf'
test('happy', () => {
const a = lastIndexOf(1, [ 1, 2, 3, 1, 2 ])
const b = lastIndexOf(1)([ 1, 2, 3, 1, 2 ])
expect(a).toEqual(3)
expect(b).toEqual(3)
})
test('false', () => {
const a = lastIndexOf(10, [ 1, 2, 3, 1, 2 ])
expect(a).toEqual(-1)
})
length<T>(input: readonly T[]): number
It returns the length property of list or string input.
const result = [
R.length([1, 2, 3, 4]),
R.length('foo'),
]
// => [4, 3]
Try this R.length example in Rambda REPL
length<T>(input: readonly T[]): number;
import { length } from './length'
test('happy', () => {
expect(length('foo')).toEqual(3)
expect(length([ 1, 2, 3 ])).toEqual(3)
expect(length([])).toEqual(0)
})
test('with empty string', () => {
expect(length('')).toEqual(0)
})
test('with bad input returns NaN', () => {
expect(length(0)).toBeNaN()
expect(length({})).toBeNaN()
expect(length(null)).toBeNaN()
expect(length(undefined)).toBeNaN()
})
lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens
It returns a lens for the given getter and setter functions.
The getter gets the value of the focus; the setter sets the value of the focus.
The setter should not mutate the data structure.
const xLens = R.lens(R.prop('x'), R.assoc('x'));
R.view(xLens, {x: 1, y: 2}) // => 1
R.set(xLens, 4, {x: 1, y: 2}) // => {x: 4, y: 2}
R.over(xLens, R.negate, {x: 1, y: 2}) // => {x: -1, y: 2}
Try this R.lens example in Rambda REPL
lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
import { compose } from './compose'
import { lensIndex } from './lensIndex'
import { lensPath } from './lensPath'
import { lensProp } from './lensProp'
import { over } from './over'
import { toUpper } from './toUpper'
import { view } from './view'
const testObject = {
foo : [ 'a', 'b', 'c' ],
baz : {
a : 'x',
b : 'y',
},
}
const propLens = lensProp('foo')
const indexLens = lensIndex(2)
const composedLens = compose(propLens, indexLens)
const pathLens = lensPath('baz.a')
const composedPathLens = compose(lensPath('baz'), lensPath('a'))
test('composed lenses', () => {
expect(view(composedPathLens, testObject)).toEqual(view(pathLens, testObject))
expect(view(composedLens, testObject)).toEqual('c')
expect(over(
composedLens, toUpper, testObject
)).toEqual({
...testObject,
foo : [ 'a', 'b', 'C' ],
})
})
lensEq<T, U>(lens: Lens, target: T, input: U): boolean
It returns true if data structure focused by the given lens equals to the target value.
R.equals is used to determine equality.
:boom: Idea for this method comes from
ramda-adjunctlibrary
const list = [ 1, 2, 3 ]
const lens = R.lensIndex(0)
const result = R.lensEq(
lens, 1, list
)
// => true
Try this R.lensEq example in Rambda REPL
lensEq<T, U>(lens: Lens, target: T, input: U): boolean;
lensEq<T, U>(lens: Lens, target: T): (input: U) => boolean;
lensEq<T>(lens: Lens, target: T, input: Array<T>): boolean;
lensEq<T>(lens: Lens, target: T): (input: Array<T>) => boolean;
import { lensEq } from './lensEq'
import { lensIndex } from './lensIndex'
import { lensPath } from './lensPath'
test('with list', () => {
const list = [ 1, 2, 3 ]
const lens = lensIndex(0)
expect(lensEq(
lens, 1, list
)).toBeTrue()
expect(lensEq(lens, 2)(list)).toBeFalse()
})
test('with R.lensPath', () => {
const input = { a : { b : { c : 1 } } }
const target = { c : 1 }
const lens = lensPath('a.b')
expect(lensEq(lens)(target)(input)).toBeTrue()
expect(lensEq(
lens, target, { c : 2 }
)).toBeFalse()
})
lensIndex(index: number): Lens
It returns a lens that focuses on specified index.
const list = ['a', 'b', 'c']
const headLens = R.lensIndex(0)
R.view(headLens, list) // => 'a'
R.set(headLens, 'x', list) // => ['x', 'b', 'c']
R.over(headLens, R.toUpper, list) // => ['A', 'b', 'c']
Try this R.lensIndex example in Rambda REPL
lensIndex(index: number): Lens;
import { compose } from './compose'
import { keys } from './keys'
import { lensIndex } from './lensIndex'
import { over } from './over'
import { set } from './set'
import { view } from './view'
const testList = [ { a : 1 }, { b : 2 }, { c : 3 } ]
test('focuses list element at the specified index', () => {
expect(view(lensIndex(0), testList)).toEqual({ a : 1 })
})
test('returns undefined if the specified index does not exist', () => {
expect(view(lensIndex(10), testList)).toEqual(undefined)
})
test('sets the list value at the specified index', () => {
expect(set(
lensIndex(0), 0, testList
)).toEqual([ 0, { b : 2 }, { c : 3 } ])
})
test('applies function to the value at the specified list index', () => {
expect(over(
lensIndex(2), keys, testList
)).toEqual([ { a : 1 }, { b : 2 }, [ 'c' ] ])
})
test('can be composed', () => {
const nestedList = [ 0, [ 10, 11, 12 ], 1, 2 ]
const composedLens = compose(lensIndex(1), lensIndex(0))
expect(view(composedLens, nestedList)).toEqual(10)
})
test('set s (get s) === s', () => {
expect(set(
lensIndex(0), view(lensIndex(0), testList), testList
)).toEqual(testList)
})
test('get (set s v) === v', () => {
expect(view(lensIndex(0), set(
lensIndex(0), 0, testList
))).toEqual(0)
})
test('get (set(set s v1) v2) === v2', () => {
expect(view(lensIndex(0),
set(
lensIndex(0), 11, set(
lensIndex(0), 10, testList
)
))).toEqual(11)
})
lensPath(path: RamdaPath): Lens
It returns a lens that focuses on specified path.
const lensPath = R.lensPath(['x', 0, 'y'])
const input = {x: [{y: 2, z: 3}, {y: 4, z: 5}]}
R.view(lensPath, input) //=> 2
R.set(lensPath, 1, input)
//=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
R.over(xHeadYLens, R.negate, input)
//=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}
Try this R.lensPath example in Rambda REPL
lensPath(path: RamdaPath): Lens;
lensPath(path: string): Lens;
import { compose } from './compose'
import { identity } from './identity'
import { inc } from './inc'
import { lensPath } from './lensPath'
import { lensProp } from './lensProp'
import { over } from './over'
import { set } from './set'
import { view } from './view'
const testObj = {
a : [ { b : 1 }, { b : 2 } ],
d : 3,
}
test('view', () => {
expect(view(lensPath('d'), testObj)).toEqual(3)
expect(view(lensPath('a.0.b'), testObj)).toEqual(1)
// this is different to ramda, as ramda will return a clone of the input object
expect(view(lensPath(''), testObj)).toEqual(undefined)
})
test('set', () => {
expect(set(
lensProp('d'), 0, testObj
)).toEqual({
a : [ { b : 1 }, { b : 2 } ],
d : 0,
})
expect(set(
lensPath('a.0.b'), 0, testObj
)).toEqual({
a : [ { b : 0 }, { b : 2 } ],
d : 3,
})
expect(set(
lensPath('a.0.X'), 0, testObj
)).toEqual({
a : [
{
b : 1,
X : 0,
},
{ b : 2 },
],
d : 3,
})
expect(set(
lensPath([]), 0, testObj
)).toEqual(0)
})
test('over', () => {
expect(over(
lensPath('d'), inc, testObj
)).toEqual({
a : [ { b : 1 }, { b : 2 } ],
d : 4,
})
expect(over(
lensPath('a.1.b'), inc, testObj
)).toEqual({
a : [ { b : 1 }, { b : 3 } ],
d : 3,
})
expect(over(
lensProp('X'), identity, testObj
)).toEqual({
a : [ { b : 1 }, { b : 2 } ],
d : 3,
X : undefined,
})
expect(over(
lensPath('a.0.X'), identity, testObj
)).toEqual({
a : [
{
b : 1,
X : undefined,
},
{ b : 2 },
],
d : 3,
})
})
test('compose', () => {
const composedLens = compose(lensPath('a'), lensPath('1.b'))
expect(view(composedLens, testObj)).toEqual(2)
})
test('set s (get s) === s', () => {
expect(set(
lensPath([ 'd' ]), view(lensPath([ 'd' ]), testObj), testObj
)).toEqual(testObj)
expect(set(
lensPath([ 'a', 0, 'b' ]),
view(lensPath([ 'a', 0, 'b' ]), testObj),
testObj
)).toEqual(testObj)
})
test('get (set s v) === v', () => {
expect(view(lensPath([ 'd' ]), set(
lensPath([ 'd' ]), 0, testObj
))).toEqual(0)
expect(view(lensPath([ 'a', 0, 'b' ]), set(
lensPath([ 'a', 0, 'b' ]), 0, testObj
))).toEqual(0)
})
test('get (set(set s v1) v2) === v2', () => {
const p = [ 'd' ]
const q = [ 'a', 0, 'b' ]
expect(view(lensPath(p), set(
lensPath(p), 11, set(
lensPath(p), 10, testObj
)
))).toEqual(11)
expect(view(lensPath(q), set(
lensPath(q), 11, set(
lensPath(q), 10, testObj
)
))).toEqual(11)
})
lensProp(prop: string): {
<T, U>(obj: T): U
It returns a lens that focuses on specified property prop.
const xLens = R.lensProp('x');
const input = {x: 1, y: 2}
R.view(xLens, input) // => 1
R.set(xLens, 4, input)
// => {x: 4, y: 2}
R.over(xLens, R.negate, input)
// => {x: -1, y: 2}
Try this R.lensProp example in Rambda REPL
lensProp(prop: string): {
<T, U>(obj: T): U;
set<T, U, V>(val: T, obj: U): V;
};
import { compose } from './compose'
import { identity } from './identity'
import { inc } from './inc'
import { lensProp } from './lensProp'
import { over } from './over'
import { set } from './set'
import { view } from './view'
const testObj = {
a : 1,
b : 2,
c : 3,
}
test('focuses object the specified object property', () => {
expect(view(lensProp('a'), testObj)).toEqual(1)
})
test('returns undefined if the specified property does not exist', () => {
expect(view(lensProp('X'), testObj)).toEqual(undefined)
})
test('sets the value of the object property specified', () => {
expect(set(
lensProp('a'), 0, testObj
)).toEqual({
a : 0,
b : 2,
c : 3,
})
})
test('adds the property to the object if it doesn\'t exist', () => {
expect(set(
lensProp('d'), 4, testObj
)).toEqual({
a : 1,
b : 2,
c : 3,
d : 4,
})
})
test('applies function to the value of the specified object property', () => {
expect(over(
lensProp('a'), inc, testObj
)).toEqual({
a : 2,
b : 2,
c : 3,
})
})
test('applies function to undefined and adds the property if it doesn\'t exist', () => {
expect(over(
lensProp('X'), identity, testObj
)).toEqual({
a : 1,
b : 2,
c : 3,
X : undefined,
})
})
test('can be composed', () => {
const nestedObj = {
a : { b : 1 },
c : 2,
}
const composedLens = compose(lensProp('a'), lensProp('b'))
expect(view(composedLens, nestedObj)).toEqual(1)
})
test('set s (get s) === s', () => {
expect(set(
lensProp('a'), view(lensProp('a'), testObj), testObj
)).toEqual(testObj)
})
test('get (set s v) === v', () => {
expect(view(lensProp('a'), set(
lensProp('a'), 0, testObj
))).toEqual(0)
})
test('get (set(set s v1) v2) === v2', () => {
expect(view(lensProp('a'),
set(
lensProp('a'), 11, set(
lensProp('a'), 10, testObj
)
))).toEqual(11)
})
lensSatisfies<T, U>(predicate: (x: T) => boolean, lens: Lens, input: U): boolean
It returns true if data structure focused by the given lens satisfies the predicate.
:boom: Idea for this method comes from
ramda-adjunctlibrary
const fn = R.lensSatisfies(x => x > 5, R.lensIndex(0))
const result = [
fn([10, 20, 30]),
fn([1, 2, 3]),
]
// => [true, false]
Try this R.lensSatisfies example in Rambda REPL
lensSatisfies<T, U>(predicate: (x: T) => boolean, lens: Lens, input: U): boolean;
lensSatisfies<T, U>(predicate: (x: T) => boolean, lens: Lens): (input: U) => boolean;
lensSatisfies<T>(predicate: (x: T) => boolean, lens: Lens, input: Array<T>): boolean;
lensSatisfies<T>(predicate: (x: T) => boolean, lens: Lens): (input: Array<T>) => boolean;
import { lensIndex } from './lensIndex'
import { lensPath } from './lensPath'
import { lensSatisfies } from './lensSatisfies'
const predicate = x => x > 1
test('with list', () => {
const lens = lensIndex(0)
const fn = lensSatisfies(predicate, lens)
expect(fn([ 10, 20, 30 ])).toBeTrue()
expect(fn([ 1, 2, 3 ])).toBeFalse()
})
test('with R.lensPath', () => {
const input1 = { a : { b : 10 } }
const input2 = { a : { b : 1 } }
const lens = lensPath('a.b')
const fn = lensSatisfies(predicate, lens)
expect(fn(input1)).toBeTrue()
expect(fn(input2)).toBeFalse()
})
map<T, U>(fn: MapFunctionObject<T, U>, iterable: Dictionary<T>): Dictionary<U>
It returns the result of looping through iterable with fn.
It works with both array and object.
:boom: Unlike Ramda's
map, here property and input object are passed as arguments tofn, wheniterableis an object.
const fn = x => x * 2
const fnWhenObject = (val, prop)=>{
return `${prop}-${val}`
}
const iterable = [1, 2]
const obj = {a: 1, b: 2}
const result = [
R.map(fn, list),
R.map(fnWhenObject, obj)
]
// => [ [1, 4], {a: 'a-1', b: 'b-2'}]
Try this R.map example in Rambda REPL
map<T, U>(fn: MapFunctionObject<T, U>, iterable: Dictionary<T>): Dictionary<U>;
map<T, U>(fn: MapIterator<T, U>, iterable: readonly T[]): U[];
map<T, U>(fn: MapIterator<T, U>): (iterable: readonly T[]) => U[];
map<T, U, S>(fn: MapFunctionObject<T, U>): (iterable: Dictionary<T>) => Dictionary<U>;
map<T>(fn: MapIterator<T, T>): (iterable: readonly T[]) => T[];
map<T>(fn: MapIterator<T, T>, iterable: readonly T[]): T[];
import { map } from './map'
const double = x => x * 2
const sampleObject = {
a : 1,
b : 2,
c : 3,
d : 4,
}
test('with array', () => {
expect(map(double, [ 1, 2, 3 ])).toEqual([ 2, 4, 6 ])
})
test('with object', () => {
const obj = {
a : 1,
b : 2,
}
expect(map(double, obj)).toEqual({
a : 2,
b : 4,
})
})
test('pass input object as third argument', () => {
const obj = {
a : 1,
b : 2,
}
const iterator = (
val, prop, inputObject
) => {
expect(inputObject).toEqual(obj)
return val * 2
}
expect(map(iterator, obj)).toEqual({
a : 2,
b : 4,
})
})
test('with object passes property as second argument', () => {
map((_, prop) => {
expect(typeof prop).toEqual('string')
})(sampleObject)
})
/**
* https://github.com/selfrefactor/rambda/issues/77
*/
test('when undefined instead of array', () => {
expect(map(double, undefined)).toEqual([])
})
mapAsync<T, K>(fn: AsyncIterable<T, K>, list: readonly T[]): Promise<K[]>
Sequential asynchronous mapping with fn over members of list.
async function fn(x){
await R.delay(1000)
return x+1
}
const result = R.mapAsync(fn, [1, 2, 3])
// `result` resolves after 3 seconds to `[2, 3, 4]`
Try this R.mapAsync example in Rambda REPL
mapAsync<T, K>(fn: AsyncIterable<T, K>, list: readonly T[]): Promise<K[]>;
mapAsync<T, K>(fn: AsyncIterableIndexed<T, K>, list: readonly T[]): Promise<K[]>;
mapAsync<T, K>(fn: AsyncIterable<T, K>) : ( list: readonly T[]) => Promise<K[]>;
mapAsync<T, K>(fn: AsyncIterableIndexed<T, K>) : ( list: readonly T[]) => Promise<K[]>;
import { composeAsync } from './composeAsync'
import { delay } from './delay'
import { map } from './map'
import { mapAsync } from './mapAsync'
const rejectDelay = a =>
new Promise((_, reject) => {
setTimeout(() => {
reject(a + 20)
}, 100)
})
test('happy', async () => {
const fn = async (x, prop) => {
await delay(100)
expect(prop).toBeNumber()
return x + 1
}
const result = await mapAsync(fn, [ 1, 2, 3 ])
expect(result).toEqual([ 2, 3, 4 ])
})
test('with object', async () => {
const fn = async (x, prop) => {
expect(prop).toBeString()
return x + 1
}
const result = await mapAsync(fn, {
a : 1,
b : 2,
})
expect(result).toEqual({
a : 2,
b : 3,
})
})
test('with R.composeAsync', async () => {
const result = await composeAsync(
map(x => x + 1),
mapAsync(async x => {
delay(x)
return x
}),
map(x => x * 10)
)([ 1, 2, 3 ])
expect(result).toEqual([ 11, 21, 31 ])
})
test('error', async () => {
try {
await mapAsync(rejectDelay)([ 1, 2, 3 ])
} catch (err){
expect(err).toBe(21)
}
})
mapAsyncLimit<T, K>(fn: AsyncIterable<T, K>, limit: number, list: readonly T[]): Promise<K[]>
It is similar to R.mapFastAsync in that it uses Promise.all but not over the whole list, rather than with only slice from list with length limit.
:boom: For example usage, please check
R.mapAsyncLimittests.
mapAsyncLimit<T, K>(fn: AsyncIterable<T, K>, limit: number, list: readonly T[]): Promise<K[]>;
mapAsyncLimit<T, K>(fn: AsyncIterable<T, K>, limit: number): (list: readonly T[]) => Promise<K[]>;
mapAsyncLimit<T, K>(fn: AsyncIterableIndexed<T, K>, limit: number, list: readonly T[]): Promise<K[]>;
mapAsyncLimit<T, K>(fn: AsyncIterableIndexed<T, K>, limit: number): (list: readonly T[]) => Promise<K[]>;
import isCI from 'is-ci'
import { composeAsync } from './composeAsync'
import { delay } from './delay'
import { mapAsync } from './mapAsync'
import { mapAsyncLimit } from './mapAsyncLimit'
import { toDecimal } from './toDecimal'
jest.setTimeout(30000)
test('happy', async () => {
const limit = 3
const startTime = new Date().getTime()
const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
const iterable = async x => {
await delay(500)
return x + 1
}
const result = await mapAsyncLimit(
iterable, limit, list
)
const endTime = new Date().getTime()
const diffTime = endTime - startTime
const startTime2 = new Date().getTime()
await mapAsync(iterable, list)
const endTime2 = new Date().getTime()
const diffTime2 = endTime2 - startTime2
const methodScale = toDecimal((diffTime2 - diffTime) / 1000, 0)
expect(result).toEqual([ 2, 3, 4, 5, 6, 7, 8, 9, 10 ])
if (!isCI) expect(methodScale).toBe(limit)
})
const fn = async x => {
await delay(100)
return x + 1
}
test('with R.composeAsync', async () => {
const result = await composeAsync(mapAsyncLimit(fn, 2), x =>
x.map(xx => xx + 1))([ 1, 2, 3, 4, 5, 6 ])
expect(result).toEqual([ 3, 4, 5, 6, 7, 8 ])
})
test('fallback to R.mapFastAsync', async () => {
const result = await mapAsyncLimit(
fn, 4, [ 1, 2, 3 ]
)
expect(result).toEqual([ 2, 3, 4 ])
})
mapFastAsync<T, K>(fn: AsyncIterable<T, K>, list: readonly T[]): Promise<K[]>
Parrallel asynchronous mapping with fn over members of list.
async function fn(x){
await R.delay(1000)
return x+1
}
const result = R.mapFastAsync(fn, [1, 2, 3])
// `result` resolves after 1 second to `[2, 3, 4]`
Try this R.mapFastAsync example in Rambda REPL
mapFastAsync<T, K>(fn: AsyncIterable<T, K>, list: readonly T[]): Promise<K[]>;
mapFastAsync<T, K>(fn: AsyncIterableIndexed<T, K>, list: readonly T[]): Promise<K[]>;
mapFastAsync<T, K>(fn: AsyncIterable<T, K>) : ( list: readonly T[]) => Promise<K[]>;
mapFastAsync<T, K>(fn: AsyncIterableIndexed<T, K>) : ( list: readonly T[]) => Promise<K[]>;
import { composeAsync } from './composeAsync'
import { delay } from './delay'
import { map } from './map'
import { mapFastAsync } from './mapFastAsync'
test('happy', async () => {
const fn = async x => {
await delay(100)
return x + 10
}
const result = await mapFastAsync(fn, [ 1, 2, 3 ])
const curriedResult = await mapFastAsync(fn)([ 1, 2, 3 ])
expect(result).toEqual([ 11, 12, 13 ])
expect(curriedResult).toEqual([ 11, 12, 13 ])
})
test('composeAsync', async () => {
const result = await composeAsync(
mapFastAsync(async x => {
await delay(100)
return x + 1
}),
mapFastAsync(async x => {
await delay(100)
return x + 10
}),
map(x => x * 10)
)([ 1, 2, 3 ])
expect(result).toEqual([ 21, 31, 41 ])
})
test('error', async () => {
try {
const fn = async x => {
JSON.parse('{:')
}
const result = await mapFastAsync(fn, [ 1, 2, 3 ])
} catch (err){
expect(err.message).toBe('Unexpected token : in JSON at position 1')
}
})
test('pass index as second argument', async () => {
await mapFastAsync((x, i) => {
expect(x % 10).toBe(0)
expect(typeof i).toBe('number')
},
[ 10, 20, 30 ])
})
mapIndexed<T, U>(fn: MapFunctionObject<T, U>, iterable: Dictionary<T>): Dictionary<U>
Same as R.map, but it passes index as second argument to the iterator, when looping over arrays.
mapIndexed<T, U>(fn: MapFunctionObject<T, U>, iterable: Dictionary<T>): Dictionary<U>;
mapIndexed<T, U>(fn: MapIndexedIterator<T, U>, iterable: readonly T[]): U[];
mapIndexed<T, U>(fn: MapIndexedIterator<T, U>): (iterable: readonly T[]) => U[];
mapIndexed<T, U, S>(fn: MapFunctionObject<T, U>): (iterable: Dictionary<T>) => Dictionary<U>;
mapIndexed<T>(fn: MapIndexedIterator<T, T>): (iterable: readonly T[]) => T[];
mapIndexed<T>(fn: MapIndexedIterator<T, T>, iterable: readonly T[]): T[];
import { map } from './map'
import { mapIndexed } from './mapIndexed'
const iterator = (x, i) => {
expect(x).toBeNumber()
expect(i).toBeNumber()
}
test('happy', () => {
const list = [ 1, 2, 3 ]
mapIndexed(iterator, list)
mapIndexed(iterator)(list)
})
test('with object', () => {
const iterator = x => x + 1
const obj = { a : 1 }
expect(mapIndexed(iterator, obj)).toEqual(map(iterator, obj))
})
test('with bad input', () => {
expect(mapIndexed(iterator, undefined)).toEqual([])
})
mapKeys<T, U>(changeKeyFn: (x: string) => string, obj: { [key: string]: T}): U
It takes an object and returns a new object with changed keys according to changeKeyFn function.
const obj = {a: 1, b: 2}
const changeKeyFn = prop => `{prop}_foo`
const result = R.mapKeys(changeKeyFn, obj)
// => {a_foo: 1, b_foo: 2}
Try this R.mapKeys example in Rambda REPL
mapKeys<T, U>(changeKeyFn: (x: string) => string, obj: { [key: string]: T}): U;
mapKeys<T, U>(changeKeyFn: (x: string) => string): (obj: { [key: string]: T}) => U;
import { mapKeys } from './mapKeys'
const obj = {
a : 1,
b : 2,
}
const changeKeyFn = prop => `${ prop }_foo`
const expected = {
a_foo : 1,
b_foo : 2,
}
test('happy', () => {
const result = mapKeys(changeKeyFn, obj)
expect(result).toEqual(expected)
})
test('curried', () => {
const result = mapKeys(changeKeyFn)(obj)
expect(result).toEqual(expected)
})
mapToObject<T, U>(fn: (input: T) => object|false, list: readonly T[]): U
This method allows to generate an object from a list using input function fn.
This function must return either an object or false for every member of list input.
If false is returned, then this element of list will be skipped in the calculation of the result.
All of returned objects will be merged to generate the final result.
const list = [1, 2, 3, 12]
const fn = x => {
if(x > 10) return false
return x % 2 ? {[x]: x + 1}: {[x]: x + 10}
}
const result = mapToObject(fn, list)
const expected = {'1': 2, '2': 12, '3': 4}
// => `result` is equal to `expected`
Try this R.mapToObject example in Rambda REPL
mapToObject<T, U>(fn: (input: T) => object|false, list: readonly T[]): U;
mapToObject<T, U>(fn: (input: T) => object|false): (list: readonly T[]) => U;
import { mapToObject } from './mapToObject'
const list = [ 1, 2, 3 ]
const fn = x => x % 2 ? { [ x ] : x + 1 } : { [ x ] : x + 10 }
const expected = {
1 : 2,
2 : 12,
3 : 4,
}
test('happy', () => {
const result = mapToObject(fn, list)
expect(result).toEqual(expected)
})
test('curried', () => {
const result = mapToObject(fn)(list)
expect(result).toEqual(expected)
})
test('string.fn test', () => {
const list = [ 'auto', 'bar=false', 'foo', 'baz=1.5', 's=more', 'k=2' ]
const fn = x => {
const [ key, value ] = x.split('=')
if (value === undefined || value === 'true'){
return { [ key ] : true }
}
if (value === 'false'){
return { [ key ] : false }
}
if (Number.isNaN(Number(value))){
return { [ key ] : value }
}
return { [ key ] : Number(value) }
}
const expectedResult = {
auto : true,
foo : true,
bar : false,
baz : 1.5,
s : 'more',
k : 2,
}
const result = mapToObject(fn, list)
expect(result).toEqual(expectedResult)
})
test('bad path', () => {
expect(() => mapToObject(1, null)).toThrow()
})
mapToObjectAsync<T, U>(fn: (input: T) => Promise<object|false>, list: readonly T[]): Promise<U>
Asynchronous version of R.mapToObject
mapToObjectAsync<T, U>(fn: (input: T) => Promise<object|false>, list: readonly T[]): Promise<U>;
mapToObjectAsync<T, U>(fn: (input: T) => Promise<object|false>): (list: readonly T[]) => Promise<U>;
import { composeAsync } from './composeAsync'
import { delay } from './delay'
import { mapToObjectAsync } from './mapToObjectAsync'
const list = [ 1, 2, 3, 12 ]
const fn = async x => {
await delay(100)
if (x > 10) return false
return x % 2 ? { [ `key${ x }` ] : x + 1 } : { [ `key${ x }` ] : x + 10 }
}
const expected = {
key1 : 2,
key2 : 12,
key3 : 4,
}
test('happy', async () => {
const result = await mapToObjectAsync(fn, list)
expect(result).toEqual(expected)
})
test('with R.composeAsync', async () => {
const result = await composeAsync(mapToObjectAsync(fn), x =>
x.filter(xx => xx > 1))(list)
expect(result).toEqual({
key2 : 12,
key3 : 4,
})
})
match(regExpression: RegExp, str: string): string[]
Curried version of String.prototype.match which returns empty array, when there is no match.
const result = [
R.match('a', 'foo'),
R.match(/([a-z]a)/g, 'bananas')
]
// => [[], ['ba', 'na', 'na']]
Try this R.match example in Rambda REPL
match(regExpression: RegExp, str: string): string[];
match(regExpression: RegExp): (str: string) => string[];
import { equals } from './equals'
import { match } from './match'
test('happy', () => {
expect(match(/a./g)('foo bar baz')).toEqual([ 'ar', 'az' ])
})
test('fallback', () => {
expect(match(/a./g)('foo')).toEqual([])
})
test('with string', () => {
expect(match('a', 'foo')).toEqual([])
expect(equals(match('o', 'foo'), [ 'o' ])).toBeTrue()
})
test('throwing', () => {
expect(() => {
match(/a./g, null)
}).toThrowWithMessage(TypeError, 'Cannot read property \'match\' of null')
})
mathMod(x: number, y: number): number
R.mathMod behaves like the modulo operator should mathematically, unlike the % operator (and by extension, R.modulo). So while -17 % 5 is -2, mathMod(-17, 5) is 3.
:boom: Explanation is taken from
Ramdadocumentation site.
const result = [
R.mathMod(-17, 5),
R.mathMod(17, 5),
R.mathMod(17, -5),
R.mathMod(17, 0)
]
// => [3, 2, NaN, NaN]
Try this R.mathMod example in Rambda REPL
mathMod(x: number, y: number): number;
mathMod(x: number): (y: number) => number;
import { mathMod } from './mathMod'
test('happy', () => {
expect(mathMod(-17)(5)).toEqual(3)
expect(mathMod(17, 5)).toEqual(2)
expect(mathMod(17, -5)).toBeNaN()
expect(mathMod(17, 0)).toBeNaN()
expect(mathMod('17', 5)).toBeNaN()
expect(mathMod({}, 2)).toBeNaN()
expect(mathMod([], 2)).toBeNaN()
expect(mathMod(Symbol(), 2)).toBeNaN()
})
max<T extends Ord>(x: T, y: T): T
It returns the greater value between x and y.
const result = [
R.max(5, 7),
R.max('bar', 'foo'),
]
// => [7, 'foo']
Try this R.max example in Rambda REPL
max<T extends Ord>(x: T, y: T): T;
max<T extends Ord>(x: T): (y: T) => T;
import { max } from './max'
test('with number', () => {
expect(max(2, 1)).toBe(2)
})
test('with string', () => {
expect(max('foo')('bar')).toBe('foo')
expect(max('bar')('baz')).toBe('baz')
})
maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T
It returns the greater value between x and y according to compareFn function.
const compareFn = Math.abs
R.maxBy(compareFn, 5, -7) // => -7
Try this R.maxBy example in Rambda REPL
maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T;
maxBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;
maxBy<T>(compareFn: (input: T) => Ord): FunctionToolbelt.Curry<(x: T, y: T) => T>;
import { maxBy } from './maxBy'
test('happy', () => {
expect(maxBy(
Math.abs, -5, 2
)).toEqual(-5)
})
test('curried', () => {
expect(maxBy(Math.abs)(2, -5)).toEqual(-5)
expect(maxBy(Math.abs)(2)(-5)).toEqual(-5)
})
maybe<T>(ifRule: boolean, whenIf: T | Func<T>, whenElse: T | Func<T>): T
It acts as ternary operator and it is helpful when we have nested ternaries.
All of the inputs can be either direct values or anonymous functions. This is helpful if we don't want to evaluate certain paths as we can wrap this logic in a function.
const x = 4
const y = 8
const ifRule = x > 2
const whenIf = y > 10 ? 3 : 7
const whenElse = () => {
// just to show that it won't be evaluated
return JSON.parse('{a:')
}
const result = R.maybe(
ifRule,
whenIf,
whenElse,
)
// `result` is `7`
Try this R.maybe example in Rambda REPL
maybe<T>(ifRule: boolean, whenIf: T | Func<T>, whenElse: T | Func<T>): T;
maybe<T>(ifRule: VoidInputFunc<boolean>, whenIf: T | Func<T>, whenElse: T | Func<T>): T;
import { maybe } from './maybe'
const WHEN_IF = 'WHEN_IF'
const WHEN_ELSE = 'WHEN_ELSE'
test('prevent type error', () => {
const x = 5
const y = null
const ifRule = x > 3
const result = maybe(
ifRule, WHEN_IF, () => y.a === 'foo'
)
expect(result).toBe(WHEN_IF)
})
test('whenElse is a function', () => {
const x = 2
const y = { a : 1 }
const ifRule = x > 3
const result = maybe(
ifRule, WHEN_IF, () => y.a === 'foo'
)
expect(result).toBeFalse()
})
test('whenIf', () => {
const x = 5
const ifRule = x > 3
const result = maybe(
ifRule, WHEN_IF, WHEN_ELSE
)
expect(result).toBe(WHEN_IF)
})
test('whenIf is a function', () => {
const x = 5
const ifRule = () => x > 3
const result = maybe(
ifRule, () => WHEN_IF, WHEN_ELSE
)
expect(result).toBe(WHEN_IF)
})
test('whenElse', () => {
const x = 1
const ifRule = x > 3
const result = maybe(
ifRule, WHEN_IF, WHEN_ELSE
)
expect(result).toBe(WHEN_ELSE)
})
mean(list: readonly number[]): number
It returns the mean value of list input.
R.mean([ 2, 7 ])
// => 4.5
Try this R.mean example in Rambda REPL
mean(list: readonly number[]): number;
import { mean } from './mean'
test('happy', () => {
expect(mean([ 2, 7 ])).toBe(4.5)
})
test('with NaN', () => {
expect(mean([])).toBeNaN()
})
median(list: readonly number[]): number
It returns the median value of list input.
R.median([ 7, 2, 10, 9 ]) // => 8
Try this R.median example in Rambda REPL
median(list: readonly number[]): number;
import { median } from './median'
test('happy', () => {
expect(median([ 2 ])).toEqual(2)
expect(median([ 7, 2, 10, 9 ])).toEqual(8)
})
test('with empty array', () => {
expect(median([])).toBeNaN()
})
memoize<T, K extends any[]>(fn: (...inputs: K) => T): (...inputs: K) => T
When fn is called for a second time with the same input, then the cache result is returned instead of calling again fn.
let result = 0
const fn = (a,b) =>{
result++
return a + b
}
const memoized = R.memoize(fn)
memoized(1, 2)
memoized(1, 2)
// => `result` is equal to `1`
Try this R.memoize example in Rambda REPL
memoize<T, K extends any[]>(fn: (...inputs: K) => T): (...inputs: K) => T;
import { memoize } from './memoize'
test('memoize function without input arguments', () => {
const fn = () => 4
const memoized = memoize(fn)
expect(typeof memoized()).toBe('function')
})
test('happy', () => {
let counter = 0
const fn = ({ a, b, c }) => {
counter++
return a + b - c
}
const memoized = memoize(fn)
expect(memoized({
a : 1,
c : 3,
b : 2,
})).toBe(0)
expect(counter).toBe(1)
expect(memoized({
c : 3,
a : 1,
b : 2,
})).toBe(0)
expect(counter).toBe(1)
})
test('normal function', () => {
let counter = 0
const fn = (a, b) => {
counter++
return a + b
}
const memoized = memoize(fn)
expect(memoized(1, 2)).toBe(3)
expect(memoized(1, 2)).toBe(3)
expect(memoized(1, 2)).toBe(3)
expect(counter).toBe(1)
expect(memoized(2, 2)).toBe(4)
expect(counter).toBe(2)
expect(memoized(1, 2)).toBe(3)
expect(counter).toBe(2)
})
test('async function', async () => {
let counter = 0
const delay = ms =>
new Promise(resolve => {
setTimeout(resolve, ms)
})
const fn = async (ms, a, b) => {
await delay(ms)
counter++
return a + b
}
const memoized = memoize(fn)
expect(await memoized(
100, 1, 2
)).toBe(3)
expect(await memoized(
100, 1, 2
)).toBe(3)
expect(await memoized(
100, 1, 2
)).toBe(3)
expect(counter).toBe(1)
expect(await memoized(
100, 2, 2
)).toBe(4)
expect(counter).toBe(2)
expect(await memoized(
100, 1, 2
)).toBe(3)
expect(counter).toBe(2)
})
test('string as argument', () => {
let count = 0
const foo = 'foo'
const tester = memoize(n => {
count++
return `${ n }bar`
})
tester(foo)
tester(foo)
tester(foo)
expect(tester(foo)).toEqual('foobar')
expect(count).toEqual(1)
tester('baz')
expect(tester('baz')).toEqual('bazbar')
expect(count).toEqual(2)
})
merge<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>
It creates a copy of target object with overidden newProps properties.
const target = { 'foo': 0, 'bar': 1 }
const newProps = { 'foo': 7 }
const result = R.merge(target, newProps)
// => { 'foo': 7, 'bar': 1 }
Try this R.merge example in Rambda REPL
merge<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>;
merge<O1 extends object>(target: O1): <O2 extends object>(newProps: O2) => Merge<O2, O1, 'flat'>;
import { merge } from './merge'
const obj = {
foo : 1,
bar : 2,
}
test('happy', () => {
expect(merge(obj, { bar : 20 })).toEqual({
foo : 1,
bar : 20,
})
})
test('curry', () => {
expect(merge(obj)({ baz : 3 })).toEqual({
foo : 1,
bar : 2,
baz : 3,
})
})
/**
* https://github.com/selfrefactor/rambda/issues/77
*/
test('when undefined or null instead of object', () => {
expect(merge(null, undefined)).toEqual({})
expect(merge(obj, null)).toEqual(obj)
expect(merge(obj, undefined)).toEqual(obj)
expect(merge(undefined, obj)).toEqual(obj)
})
mergeAll<T>(list: object[]): T
It merges all objects of list array sequentially and returns the result.
const list = [
{a: 1},
{b: 2},
{c: 3}
]
const result = R.mergeAll(list)
const expected = {
a: 1,
b: 2,
c: 3
}
// => `result` is equal to `expected`
Try this R.mergeAll example in Rambda REPL
mergeAll<T>(list: object[]): T;
mergeAll(list: object[]): object;
import { mergeAll } from './mergeAll'
test('case 1', () => {
const arr = [ { a : 1 }, { b : 2 }, { c : 3 } ]
const expectedResult = {
a : 1,
b : 2,
c : 3,
}
expect(mergeAll(arr)).toEqual(expectedResult)
})
test('case 2', () => {
expect(mergeAll([ { foo : 1 }, { bar : 2 }, { baz : 3 } ])).toEqual({
foo : 1,
bar : 2,
baz : 3,
})
})
mergeDeepRight<O1 extends object, O2 extends object>(x: O1, y: O2): Merge<O2, O1, 'deep'>
Creates a new object with the own properties of the first object merged with the own properties of the second object. If a key exists in both objects:
mergeDeepRight<O1 extends object, O2 extends object>(x: O1, y: O2): Merge<O2, O1, 'deep'>;
mergeDeepRight<O1 extends object>(x: O1): <O2 extends object>(y: O2) => Merge<O2, O1, 'deep'>;
// import { mergeDeepRight } from 'ramda'
import { mergeDeepRight } from './mergeDeepRight'
const slave = {
name : 'evilMe',
age : 10,
contact : {
a : 1,
email : 'foo@example.com',
},
}
const master = {
age : 40,
contact : { email : 'baz@example.com' },
songs : { title : 'Remains the same' },
}
test('happy', () => {
const result = mergeDeepRight(slave, master)
const curryResult = mergeDeepRight(slave)(master)
const expected = {
age : 40,
name : 'evilMe',
contact : {
a : 1,
email : 'baz@example.com',
},
songs : { title : 'Remains the same' },
}
expect(result).toEqual(expected)
expect(curryResult).toEqual(expected)
})
test('ramda compatible test 1', () => {
const a = {
w : 1,
x : 2,
y : { z : 3 },
}
const b = {
a : 4,
b : 5,
c : { d : 6 },
}
const result = mergeDeepRight(a, b)
const expected = {
w : 1,
x : 2,
y : { z : 3 },
a : 4,
b : 5,
c : { d : 6 },
}
expect(result).toEqual(expected)
})
test('ramda compatible test 2', () => {
const a = {
a : {
b : 1,
c : 2,
},
y : 0,
}
const b = {
a : {
b : 3,
d : 4,
},
z : 0,
}
const result = mergeDeepRight(a, b)
const expected = {
a : {
b : 3,
c : 2,
d : 4,
},
y : 0,
z : 0,
}
expect(result).toEqual(expected)
})
test('ramda compatible test 3', () => {
const a = {
w : 1,
x : { y : 2 },
}
const result = mergeDeepRight(a, { x : { y : 3 } })
const expected = {
w : 1,
x : { y : 3 },
}
expect(result).toEqual(expected)
})
mergeLeft<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>
Same as R.merge, but in opposite direction.
const result = R.mergeLeft(
{a: 10},
{a: 1, b: 2}
)
// => {a:10, b: 2}
Try this R.mergeLeft example in Rambda REPL
mergeLeft<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>;
mergeLeft<O1 extends object>(target: O1): <O2 extends object>(newProps: O2) => Merge<O2, O1, 'flat'>;
import { mergeLeft } from './mergeLeft'
const obj = {
foo : 1,
bar : 2,
}
test('happy', () => {
expect(mergeLeft({ bar : 20 }, obj)).toEqual({
foo : 1,
bar : 20,
})
})
test('curry', () => {
expect(mergeLeft({ baz : 3 })(obj)).toEqual({
foo : 1,
bar : 2,
baz : 3,
})
})
test('when undefined or null instead of object', () => {
expect(mergeLeft(null, undefined)).toEqual({})
expect(mergeLeft(obj, null)).toEqual(obj)
expect(mergeLeft(obj, undefined)).toEqual(obj)
expect(mergeLeft(undefined, obj)).toEqual(obj)
})
min<T extends Ord>(x: T, y: T): T
It returns the lesser value between x and y.
const result = [
R.min(5, 7),
R.min('bar', 'foo'),
]
// => [5, 'bar']
Try this R.min example in Rambda REPL
min<T extends Ord>(x: T, y: T): T;
min<T extends Ord>(x: T): (y: T) => T;
import { min } from './min'
test('happy', () => {
expect(min(2, 1)).toBe(1)
expect(min(2)(1)).toBe(1)
})
minBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T
It returns the lesser value between x and y according to compareFn function.
const compareFn = Math.abs
R.minBy(compareFn, -5, 2) // => -5
Try this R.minBy example in Rambda REPL
minBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T;
minBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;
minBy<T>(compareFn: (input: T) => Ord): FunctionToolbelt.Curry<(x: T, y: T) => T>;
import { minBy } from './minBy'
test('happy', () => {
expect(minBy(
Math.abs, -5, 2
)).toEqual(2)
})
test('curried', () => {
expect(minBy(Math.abs)(2, -5)).toEqual(2)
expect(minBy(Math.abs)(2)(-5)).toEqual(2)
})
modulo(x: number, y: number): number
Curried version of x%y.
R.modulo(17, 3) // => 2
Try this R.modulo example in Rambda REPL
modulo(x: number, y: number): number;
modulo(x: number): (y: number) => number;
import { modulo } from './modulo'
test('happy', () => {
expect(modulo(17, 3)).toEqual(2)
expect(modulo(15)(6)).toEqual(3)
})
move<T>(fromIndex: number, toIndex: number, list: readonly T[]): T[]
It returns a copy of list with exchanged fromIndex and toIndex elements.
:boom: Rambda.move doesn't support negative indexes - it throws an error.
const list = [1, 2, 3]
const result = R.move(0, 1, list)
// => [2, 1, 3]
Try this R.move example in Rambda REPL
move<T>(fromIndex: number, toIndex: number, list: readonly T[]): T[];
move(fromIndex: number, toIndex: number): <T>(list: readonly T[]) => T[];
move(fromIndex: number): {
<T>(toIndex: number, list: readonly T[]): T[];
(toIndex: number): <T>(list: readonly T[]) => T[];
};
import { move } from './move'
const list = [ 1, 2, 3, 4 ]
test('happy', () => {
const result = move(
0, 1, list
)
expect(result).toEqual([ 2, 1, 3, 4 ])
})
test('with negative index', () => {
const errorMessage = 'Rambda.move does not support negative indexes'
expect(() => move(
0, -1, list
)).toThrowWithMessage(Error, errorMessage)
expect(() => move(
-1, 0, list
)).toThrowWithMessage(Error, errorMessage)
})
test('when indexes are outside the list outbounds', () => {
const result1 = move(
10, 1, list
)
const result2 = move(
1, 10, list
)
expect(result1).toEqual(list)
expect(result2).toEqual(list)
})
multiply(x: number, y: number): number
Curried version of x*y.
R.multiply(2, 4) // => 8
Try this R.multiply example in Rambda REPL
multiply(x: number, y: number): number;
multiply(x: number): (y: number) => number;
import { multiply } from './multiply'
test('happy', () => {
expect(multiply(2, 4)).toEqual(8)
expect(multiply(2)(4)).toEqual(8)
})
negate(x: number): number
R.negate(420)// => -420
Try this R.negate example in Rambda REPL
negate(x: number): number;
import { negate } from './negate'
test('negate', () => {
expect(negate(420)).toEqual(-420)
expect(negate(-13)).toEqual(13)
})
nextIndex(index: number, list: readonly any[]): number
It returns the next index of the list.
If we have reached the end of the list, then it will return 0.
const list = [1, 2, 3]
const result = [
R.nextIndex(0, list),
R.nextIndex(1, list),
R.nextIndex(2, list),
R.nextIndex(10, list)
]
// => [1, 2, 0, 0]
Try this R.nextIndex example in Rambda REPL
nextIndex(index: number, list: readonly any[]): number;
import { nextIndex } from './nextIndex'
const list = [ 1, 2, 3, 4 ]
test('happy path', () => {
expect(nextIndex(2, list)).toEqual(3)
})
test('go back to the start', () => {
expect(nextIndex(3, list)).toEqual(0)
})
test('current index is too big', () => {
expect(nextIndex(32, list)).toEqual(0)
})
none<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean
It returns true, if all members of array list returns false, when applied as argument to predicate function.
const list = [ 0, 1, 2, 3, 4 ]
const predicate = x => x > 6
const result = R.none(predicate, arr)
// => true
Try this R.none example in Rambda REPL
none<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean;
none<T>(predicate: (x: T) => boolean): (list: readonly T[]) => boolean;
import { none } from './none'
const isEven = n => n % 2 === 0
const isOdd = n => n % 2 === 1
const arr = [ 1, 3, 5, 7, 9, 11 ]
test('when true', () => {
expect(none(isEven, arr)).toBeTrue()
})
test('when false curried', () => {
expect(none(isOdd)(arr)).toBeFalse()
})
not(input: any): boolean
It returns a boolean negated version of input.
R.not(false) // true
Try this R.not example in Rambda REPL
not(input: any): boolean;
import { not } from './not'
test('not', () => {
expect(not(false)).toEqual(true)
expect(not(true)).toEqual(false)
expect(not(0)).toEqual(true)
expect(not(1)).toEqual(false)
})
nth<T>(index: number, list: readonly T[]): T | undefined
Curried version of list[index].
const list = [1, 2, 3]
const str = 'foo'
const result = [
R.nth(2, list),
R.nth(6, list),
R.nth(0, str),
]
// => [3, undefined, 'f']
Try this R.nth example in Rambda REPL
nth<T>(index: number, list: readonly T[]): T | undefined;
nth(index: number): <T>(list: readonly T[]) => T | undefined;
import { nth } from './nth'
test('happy', () => {
expect(nth(2, [ 1, 2, 3, 4 ])).toEqual(3)
})
test('with curry', () => {
expect(nth(2)([ 1, 2, 3, 4 ])).toEqual(3)
})
test('with string', () => {
expect(nth(2)('foo')).toEqual('o')
})
test('with negative index', () => {
expect(nth(-3)([ 1, 2, 3, 4 ])).toEqual(2)
})
of<T>(x: T): T[]
R.of(null); //=> [null]
R.of([42]); //=> [[42]]
Try this R.of example in Rambda REPL
of<T>(x: T): T[];
import { of } from './of'
test('happy', () => {
expect(of(3)).toEqual([ 3 ])
expect(of(null)).toEqual([ null ])
})
ok(...inputs: any[]): (...schemas: any[]) => void | never
It checks if inputs are following schemas specifications according to R.isValid.
If validation fails, it throws.
:boom: It is same as
R.passbut instead of returningfalse, it throws an error.
const result = R.ok(
1,
['foo', 'bar']
)(
Number,
[String]
)
// => undefined
Try this R.ok example in Rambda REPL
ok(...inputs: any[]): (...schemas: any[]) => void | never;
import { ok, schemaToString } from './ok'
test('happy', () => {
expect(() => {
ok(
1, 'foo', {}
)(
'number', 'string', 'object'
)
}).not.toThrow()
})
test('when validation fails', () => {
const errorMessage = `Failed R.ok -
reason: {"input":{},"schema":"string"}
all inputs: [1,"foo",{}]
all schemas: ["number","string","string"]`
expect(() =>
ok(
1, 'foo', {}
)(
'number', 'string', 'string'
)).toThrowWithMessage(Error, errorMessage)
})
/*
TODO
What about
{a: Function}
*/
test('schema in error message', () => {
const result = schemaToString({
_a : [ Number ],
a : Number,
b : x => x > 2,
c : [ 'foo', 'bar' ],
d : [ { a : String } ],
e : 'boolean',
f : Array,
h : Object,
})
expect(JSON.stringify(result)).toMatchInlineSnapshot('"{\\"_a\\":\\"Array\\",\\"a\\":\\"number\\",\\"b\\":\\"Function\\",\\"c\\":\\"Array\\",\\"d\\":\\"Array\\",\\"e\\":\\"String\\",\\"f\\":\\"array\\",\\"h\\":\\"object\\"}"')
})
test('error contains schema', () => {
try {
ok(
1, 'foo', {}
)(
{ a : Number }, String, String
)
expect(false).toBeTrue()
} catch (e){
expect(e.message.startsWith('Failed R.ok -')).toBeTruthy()
expect(e).toBeInstanceOf(Error)
}
})
test('when not throws with single schema', () => {
expect(() => ok(
1, 2, 3
)('number')).not.toThrow()
})
test('when throws with single schema', () => {
expect(() => ok(
1, 2, '3'
)('number')).toThrow()
})
test('when throws with single input', () => {
expect(() => ok('3')('number')).toThrow()
})
omit<T, K extends string>(propsToOmit: readonly K[], obj: T): Omit<T, K>
It returns a partial copy of an obj without propsToOmit properties.
:boom: When using this method with
TypeScript, it is much easier to passpropsToOmitas an array. If passing a string, you will need to explicitly declare the output type.
const obj = {a: 1, b: 2, c: 3}
const propsToOmit = 'a,c,d'
const propsToOmitList = ['a', 'c', 'd']
const result = [
R.omit(propsToOmit, obj),
R.omit(propsToOmitList, obj)
]
// => [{b: 2}, {b: 2}]
Try this R.omit example in Rambda REPL
omit<T, K extends string>(propsToOmit: readonly K[], obj: T): Omit<T, K>;
omit<K extends string>(propsToOmit: readonly K[]): <T>(obj: T) => Omit<T, K>;
omit<T, U>(propsToOmit: string, obj: T): U;
omit<T, U>(propsToOmit: string): (obj: T) => U;
omit<T>(propsToOmit: string, obj: object): T;
omit<T>(propsToOmit: string): (obj: object) => T;
import { omit } from './omit'
test('with string as condition', () => {
const obj = {
a : 1,
b : 2,
c : 3,
}
const result = omit('a,c', obj)
const resultCurry = omit('a,c')(obj)
const expectedResult = { b : 2 }
expect(result).toEqual(expectedResult)
expect(resultCurry).toEqual(expectedResult)
})
test('with null', () => {
expect(omit('a,b', null)).toEqual(undefined)
})
test('doesn\'t work with number as property', () => {
expect(omit([ 42 ], {
a : 1,
42 : 2,
})).toEqual({
42 : 2,
a : 1,
})
})
test('happy', () => {
expect(omit([ 'a', 'c' ])({
a : 'foo',
b : 'bar',
c : 'baz',
})).toEqual({ b : 'bar' })
})
once<T extends (...args: any[]) => any>(func: T): T
It returns a function, which invokes only once fn function.
let result = 0
const addOnce = R.once((x) => result = result + x)
addOnce(1)
addOnce(1)
// => 1
Try this R.once example in Rambda REPL
once<T extends (...args: any[]) => any>(func: T): T;
import { once } from './once'
test('with counter', () => {
let counter = 0
const runOnce = once(x => {
counter++
return x + 2
})
expect(runOnce(1)).toEqual(3)
runOnce(1)
runOnce(1)
runOnce(1)
expect(counter).toEqual(1)
})
test('happy path', () => {
const addOneOnce = once((
a, b, c
) => a + b + c, 1)
expect(addOneOnce(
10, 20, 30
)).toBe(60)
expect(addOneOnce(40)).toEqual(60)
})
or<T, U>(a: T, b: U): T | U
Logical OR
R.or(false, true); // => true
R.or(false, false); // => false
R.or(false, 'foo'); // => 'foo'
Try this R.or example in Rambda REPL
or<T, U>(a: T, b: U): T | U;
or<T>(a: T): <U>(b: U) => T | U;
import { or } from './or'
test('happy', () => {
expect(or(0, 'foo')).toBe('foo')
expect(or(true, true)).toBeTrue()
expect(or(false)(true)).toBeTrue()
expect(or(false, false)).toBeFalse()
})
over<T>(lens: Lens, fn: Arity1Fn, value: T): T
It returns a copied Object or Array with modified value received by applying function fn to lens focus.
const headLens = R.lensIndex(0)
R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']) //=> ['FOO', 'bar', 'baz']
Try this R.over example in Rambda REPL
over<T>(lens: Lens, fn: Arity1Fn, value: T): T;
over<T>(lens: Lens, fn: Arity1Fn, value: readonly T[]): T[];
over(lens: Lens, fn: Arity1Fn): <T>(value: T) => T;
over(lens: Lens, fn: Arity1Fn): <T>(value: readonly T[]) => T[];
over(lens: Lens): <T>(fn: Arity1Fn, value: T) => T;
over(lens: Lens): <T>(fn: Arity1Fn, value: readonly T[]) => T[];
import { assoc } from './assoc'
import { lens } from './lens'
import { lensIndex } from './lensIndex'
import { lensPath } from './lensPath'
import { over } from './over'
import { prop } from './prop'
import { toUpper } from './toUpper'
const testObject = {
foo : 'bar',
baz : {
a : 'x',
b : 'y',
},
}
test('assoc lens', () => {
const assocLens = lens(prop('foo'), assoc('foo'))
const result = over(
assocLens, toUpper, testObject
)
const expected = {
...testObject,
foo : 'BAR',
}
expect(result).toEqual(expected)
})
test('path lens', () => {
const pathLens = lensPath('baz.a')
const result = over(
pathLens, toUpper, testObject
)
const expected = {
...testObject,
baz : {
a : 'X',
b : 'y',
},
}
expect(result).toEqual(expected)
})
test('index lens', () => {
const indexLens = lensIndex(0)
const result = over(indexLens, toUpper)(['foo', 'bar'])
expect(result).toEqual([ 'FOO', 'bar' ])
})
partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T
It is very similar to R.curry, but you can pass initial arguments when you create the curried function.
R.partial will keep returning a function until all the arguments that the function fn expects are passed.
The name comes from the fact that you partially inject the inputs.
:boom: Rambda's partial doesn't need the input arguments to be wrapped as array.
const fn = (title, firstName, lastName) => {
return title + ' ' + firstName + ' ' + lastName + '!'
}
const canPassAnyNumberOfArguments = R.partial(fn, 'Hello')
const ramdaStyle = R.partial(fn, ['Hello'])
const finalFn = canPassAnyNumberOfArguments('Foo')
finalFn('Bar') // => 'Hello, Foo Bar!'
Try this R.partial example in Rambda REPL
partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T;
partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0, V1]): (x2: V2) => T;
partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0]): (x1: V1, x2: V2) => T;
partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1, V2]): (x2: V3) => T;
partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1]): (x2: V2, x3: V3) => T;
partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0]): (x1: V1, x2: V2, x3: V3) => T;
partial<T>(fn: (...a: any[]) => T, args: any[]): (...x: any[]) => T;
import { partial } from './partial'
import { type } from './type'
const greet = (
salutation, title, firstName, lastName
) =>
salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'
test('happy', () => {
const canPassAnyNumberOfArguments = partial(
greet, 'Hello', 'Ms.'
)
const fn = canPassAnyNumberOfArguments('foo')
const sayHello = partial(greet, [ 'Hello' ])
const sayHelloRamda = partial(sayHello, [ 'Ms.' ])
expect(type(fn)).toBe('Function')
expect(fn('bar')).toBe('Hello, Ms. foo bar!')
expect(sayHelloRamda('foo', 'bar')).toBe('Hello, Ms. foo bar!')
})
test('extra arguments are ignored', () => {
const canPassAnyNumberOfArguments = partial(
greet, 'Hello', 'Ms.'
)
const fn = canPassAnyNumberOfArguments('foo')
expect(type(fn)).toBe('Function')
expect(fn(
'bar', 1, 2
)).toBe('Hello, Ms. foo bar!')
})
test('when array is input', () => {
const fooFn = (
a, b, c, d
) => ({
a,
b,
c,
d,
})
const barFn = partial(
fooFn, [ 1, 2 ], []
)
expect(barFn(1, 2)).toEqual({
a : [ 1, 2 ],
b : [],
c : 1,
d : 2,
})
})
test('ramda spec', () => {
const sayHello = partial(greet, 'Hello')
const sayHelloToMs = partial(sayHello, 'Ms.')
expect(sayHelloToMs('Jane', 'Jones')).toBe('Hello, Ms. Jane Jones!')
})
partialCurry<Input, PartialInput, Output>(
fn: (input: Input) => Output,
partialInput: PartialInput,
): (input: Pick<Input, Exclude<keyof Input, keyof PartialInput>>) => Output
R.partialCurry is a curry helper designed specifically for functions accepting object as a single argument.
Initially the function knows only a part from the whole input object and then R.partialCurry helps in preparing the function for the second part, when it receives the rest of the input.
:boom: Curried function can be asynchronous
const fn = ({ a, b, c }) => a + b + c
const curried = partialCurry(fn, { a : 1 })
const result = curried({
b : 2,
c : 3,
})
// => 6
Try this R.partialCurry example in Rambda REPL
partialCurry<Input, PartialInput, Output>(
fn: (input: Input) => Output,
partialInput: PartialInput,
): (input: Pick<Input, Exclude<keyof Input, keyof PartialInput>>) => Output;
import { delay } from './delay'
import { partialCurry } from './partialCurry'
import { type } from './type'
test('with plain function', () => {
const fn = ({ a, b, c }) => a + b + c
const curried = partialCurry(fn, { a : 1 })
expect(type(curried)).toEqual('Function')
expect(curried({
b : 2,
c : 3,
})).toEqual(6)
})
test('with function that throws an error', () => {
const fn = ({ a, b, c }) => {
throw new Error('foo')
}
const curried = partialCurry(fn, { a : 1 })
expect(type(curried)).toEqual('Function')
expect(() =>
curried({
b : 2,
c : 3,
})).toThrowWithMessage(Error, 'foo')
})
test('with async', async () => {
const fn = async ({ a, b, c }) => {
await delay(100)
return a + b + c
}
const curried = partialCurry(fn, { a : 1 })
const result = await curried({
b : 2,
c : 3,
})
expect(result).toEqual(6)
})
test('async function throwing an error', async () => {
const fn = async ({ a, b, c }) => {
await delay(100)
throw new Error('foo')
}
const curried = partialCurry(fn, { a : 1 })
try {
await curried({
b : 2,
c : 3,
})
expect(true).toBeFalsy()
} catch (e){
expect(e.message).toBe('foo')
}
})
partition<T>(
predicate: Predicate<T>,
input: readonly T[]
): [T[], T[]]
It will return array of two objects/arrays according to predicate function. The first member holds all instanses of input that pass the predicate function, while the second member - those who doesn't.
const list = [1, 2, 3]
const obj = {a: 1, b: 2, c: 3}
const predicate = x => x > 2
const result = [
R.partition(predicate, list),
R.partition(predicate, obj)
]
const expected = [
[[3], [1, 2]],
[{c: 3}, {a: 1, b: 2}],
]
// `result` is equal to `expected`
Try this R.partition example in Rambda REPL
partition<T>(
predicate: Predicate<T>,
input: readonly T[]
): [T[], T[]];
partition<T>(
predicate: Predicate<T>
): (input: readonly T[]) => [T[], T[]];
partition<T>(
predicate: (x: T, prop?: string) => boolean,
input: { [key: string]: T}
): [{ [key: string]: T}, { [key: string]: T}];
partition<T>(
predicate: (x: T, prop?: string) => boolean
): (input: { [key: string]: T}) => [{ [key: string]: T}, { [key: string]: T}];
import { partition } from './partition'
test('with array', () => {
const predicate = (x) => {
return x > 2
}
const list = [ 1, 2, 3, 4 ]
const result = partition(predicate, list)
const expectedResult = [
[ 3, 4 ],
[ 1, 2 ],
]
expect(result).toEqual(expectedResult)
})
test('with object', () => {
const predicate = (value, prop) => {
expect(typeof prop).toBe('string')
return value > 2
}
const hash = {
a : 1,
b : 2,
c : 3,
d : 4,
}
const result = partition(predicate)(hash)
const expectedResult = [
{
c : 3,
d : 4,
},
{
a : 1,
b : 2,
},
]
expect(result).toEqual(expectedResult)
})
test('readme example', () => {
const list = [ 1, 2, 3 ]
const obj = {
a : 1,
b : 2,
c : 3,
}
const predicate = x => x > 2
const result = [ partition(predicate, list), partition(predicate, obj) ]
const expected = [
[ [ 3 ], [ 1, 2 ] ],
[
{ c : 3 },
{
a : 1,
b : 2,
},
],
]
expect(result).toEqual(expected)
})
pass(...inputs: any[]): (...rules: any[]) => boolean
It checks if inputs are following schemas specifications according to R.isValid.
const result = R.pass(
1,
['foo','bar']
)(
Number,
[String]
)
// => true
Try this R.pass example in Rambda REPL
pass(...inputs: any[]): (...rules: any[]) => boolean;
import { pass } from './pass'
test('true on success', () => {
const result = pass(
1, 'foo', {}
)(
'number', 'string', 'object'
)
expect(result).toBeTrue()
})
test('false on failure', () => {
expect(pass(
1, 'foo', {}
)(
'number', 'string', 'string'
)).toBeFalse()
})
test('true when single schema', () => {
expect(pass(
1, 2, 3
)('number')).toBeTrue()
})
test('false when single schema', () => {
expect(pass(
1, 'foo', {}
)('number')).toBeFalse()
})
test('array of schemas', () => {
const result = pass([ { a : 1 }, { a : 2 }, { a : 3 } ])([ { a : Number } ])
expect(result).toBeTruthy()
})
test('reame example', () => {
const result = pass(1, [ 'foo', 'bar' ])(Number, [ String ])
expect(result).toBeTruthy()
})
path<Input, T>(pathToSearch: Path, obj: Input): T | undefined
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.
:boom: String anotation of
pathToSearchis one of the differences betweenRambdaandRamda.
const obj = {a: {b: 1}}
const pathToSearch = 'a.b'
const pathToSearchList = ['a', 'b']
const result = [
R.path(pathToSearch, obj),
R.path(pathToSearchList, obj),
R.path('a.b.c.d', obj)
]
// => [1, 1, undefined]
Try this R.path example in Rambda REPL
path<Input, T>(pathToSearch: Path, obj: Input): T | undefined;
path<T>(pathToSearch: Path, obj: any): T | undefined;
path<T>(pathToSearch: Path): (obj: any) => T | undefined;
path<Input, T>(pathToSearch: Path): (obj: Input) => T | undefined;
import { path } from './path'
test('with array inside object', () => {
const obj = { a : { b : [ 1, { c : 1 } ] } }
expect(path('a.b.1.c', obj)).toBe(1)
})
test('works with undefined', () => {
const obj = { a : { b : { c : 1 } } }
expect(path('a.b.c.d.f', obj)).toBeUndefined()
expect(path('foo.babaz', undefined)).toBeUndefined()
expect(path('foo.babaz')(undefined)).toBeUndefined()
})
test('works with string instead of array', () => {
expect(path('foo.bar.baz')({ foo : { bar : { baz : 'yes' } } })).toEqual('yes')
})
test('path', () => {
expect(path([ 'foo', 'bar', 'baz' ])({ foo : { bar : { baz : 'yes' } } })).toEqual('yes')
expect(path([ 'foo', 'bar', 'baz' ])(null)).toBeUndefined()
expect(path([ 'foo', 'bar', 'baz' ])({ foo : { bar : 'baz' } })).toBeUndefined()
})
pathEq(pathToSearch: Path, target: any, input: any): boolean
It returns true if pathToSearch of input object is equal to target value.
pathToSearch is passed to R.path, which means that it can be either a string or an array. Also equality between target and the found value is determined by R.equals.
const path = 'a.b'
const target = {c: 1}
const input = {a: {b: {c: 1}}}
const result = R.pathEq(
path,
target,
input
)
// => true
Try this R.pathEq example in Rambda REPL
pathEq(pathToSearch: Path, target: any, input: any): boolean;
pathEq(pathToSearch: Path, target: any): (input: any) => boolean;
pathEq(pathToSearch: Path): FunctionToolbelt.Curry<(a: any, b: any) => boolean>;
import { pathEq } from './pathEq'
test('when true', () => {
const path = 'a.b'
const obj = { a : { b : { c : 1 } } }
const target = { c : 1 }
expect(pathEq(
path, target, obj
)).toBeTrue()
})
test('when false', () => {
const path = 'a.b'
const obj = { a : { b : 1 } }
const target = 2
expect(pathEq(path, target)(obj)).toBeFalse()
})
test('when wrong path', () => {
const path = 'foo.bar'
const obj = { a : { b : 1 } }
const target = 2
expect(pathEq(
path, target, obj
)).toBeFalse()
})
pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T
It reads obj input and returns either R.path(pathToSearch, obj) result or defaultValue input.
const defaultValue = 'DEFAULT_VALUE'
const pathToSearch = 'a.b'
const pathToSearchList = ['a', 'b']
const obj = {
a : {
b : 1
}
}
const result = [
R.pathOr(DEFAULT_VALUE, pathToSearch, obj)
R.pathOr(DEFAULT_VALUE, pathToSearchList, obj)
R.pathOr(DEFAULT_VALUE, 'a.b.c', obj)
]
// => [1, 1, 'DEFAULT_VALUE']
Try this R.pathOr example in Rambda REPL
pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T;
pathOr<T>(defaultValue: T, pathToSearch: Path): (obj: any) => T;
pathOr<T>(defaultValue: T): FunctionToolbelt.Curry<(a: Path, b: any) => T>;
import { pathOr } from './pathOr'
test('with undefined', () => {
const result = pathOr(
'foo', 'x.y', { x : { y : 1 } }
)
expect(result).toEqual(1)
})
test('with null', () => {
const result = pathOr(
'foo', 'x.y', null
)
expect(result).toEqual('foo')
})
test('with NaN', () => {
const result = pathOr(
'foo', 'x.y', NaN
)
expect(result).toEqual('foo')
})
test('curry case (x)(y)(z)', () => {
const result = pathOr('foo')('x.y.z')({ x : { y : { a : 1 } } })
expect(result).toEqual('foo')
})
test('curry case (x)(y,z)', () => {
const result = pathOr('foo', 'x.y.z')({ x : { y : { a : 1 } } })
expect(result).toEqual('foo')
})
test('curry case (x,y)(z)', () => {
const result = pathOr('foo')('x.y.z', { x : { y : { a : 1 } } })
expect(result).toEqual('foo')
})
paths<Input, T>(pathsToSearch: Path[], obj: Input): (T | undefined)[]
It loops over members of pathsToSearch as singlePath and returns the array produced by R.path(singlePath, obj).
Because it calls R.path, then singlePath can be either string or a list.
const obj = {
a : {
b : {
c : 1,
d : 2
}
}
}
const result = R.paths([
'a.b.c',
'a.b.c.d',
'a.b.c.d.e',
], obj)
// => [1, 2, undefined]
Try this R.paths example in Rambda REPL
paths<Input, T>(pathsToSearch: Path[], obj: Input): (T | undefined)[];
paths<Input, T>(pathsToSearch: Path[]): (obj: Input) => (T | undefined)[];
paths<T>(pathsToSearch: Path[], obj: any): (T | undefined)[];
paths<T>(pathsToSearch: Path[]): (obj: any) => (T | undefined)[];
import { paths } from './paths'
const obj = {
a : {
b : {
c : 1,
d : 2,
},
},
p : [ { q : 3 } ],
x : {
y : 'FOO',
z : [ [ {} ] ],
},
}
test('with string path + curry', () => {
const pathsInput = [ 'a.b.d', 'p.q' ]
const expected = [ 2, undefined ]
const result = paths(pathsInput, obj)
const curriedResult = paths(pathsInput)(obj)
expect(result).toEqual(expected)
expect(curriedResult).toEqual(expected)
})
test('with array path', () => {
const result = paths([
[ 'a', 'b', 'c' ],
[ 'x', 'y' ],
],
obj)
expect(result).toEqual([ 1, 'FOO' ])
})
test('takes a paths that contains indices into arrays', () => {
expect(paths([
[ 'p', 0, 'q' ],
[ 'x', 'z', 0, 0 ],
],
obj)).toEqual([ 3, {} ])
expect(paths([
[ 'p', 0, 'q' ],
[ 'x', 'z', 2, 1 ],
],
obj)).toEqual([ 3, undefined ])
})
test('gets a deep property\'s value from objects', () => {
expect(paths([ [ 'a', 'b' ] ], obj)).toEqual([ obj.a.b ])
expect(paths([ [ 'p', 0 ] ], obj)).toEqual([ obj.p[ 0 ] ])
})
test('returns undefined for items not found', () => {
expect(paths([ [ 'a', 'x', 'y' ] ], obj)).toEqual([ undefined ])
expect(paths([ [ 'p', 2 ] ], obj)).toEqual([ undefined ])
})
pick<T, K extends string | number | symbol>(propsToPick: readonly K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>
It returns a partial copy of an input containing only propsToPick properties.
input can be either an object or an array.
String anotation of propsToPick is one of the differences between Rambda and Ramda.
:boom: When using this method with
TypeScript, it is much easier to passpropsToPickas an array. If passing a string, you will need to explicitly declare the output type.
const obj = {
a : 1,
b : false,
foo: 'cherry'
}
const list = [1, 2, 3, 4]
const propsToPick = 'a,foo'
const propsToPickList = ['a', 'foo']
const result = [
R.pick(propsToPick, obj),
R.pick(propsToPickList, obj),
R.pick('a,bar', obj),
R.pick('bar', obj),
R.pick([0, 3], list),
R.pick('0,3', list),
]
const expected = [
{a:1, foo: 'cherry'},
{a:1, foo: 'cherry'},
{a:1},
{},
[1,4],
[1,4]
]
// => `result` is equal to `expected`
Try this R.pick example in Rambda REPL
pick<T, K extends string | number | symbol>(propsToPick: readonly K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;
pick<K extends string | number | symbol>(propsToPick: readonly K[]): <T>(input: T) => Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;
pick<T, U>(propsToPick: string, input: T): U;
pick<T, U>(propsToPick: string): (input: T) => U;
pick<T>(propsToPick: string, input: object): T;
pick<T>(propsToPick: string): (input: object) => T;
import { pick } from './pick'
const obj = {
a : 1,
b : 2,
c : 3,
}
test('props to pick is a string', () => {
const result = pick('a,c', obj)
const resultCurry = pick('a,c')(obj)
const expectedResult = {
a : 1,
c : 3,
}
expect(result).toEqual(expectedResult)
expect(resultCurry).toEqual(expectedResult)
})
test('when prop is missing', () => {
const result = pick('a,d,f', obj)
expect(result).toEqual({ a : 1 })
})
test('props to pick is an array', () => {
expect(pick([ 'a', 'c' ])({
a : 'foo',
b : 'bar',
c : 'baz',
})).toEqual({
a : 'foo',
c : 'baz',
})
expect(pick([ 'a', 'd', 'e', 'f' ])({
a : 'foo',
b : 'bar',
c : 'baz',
})).toEqual({ a : 'foo' })
expect(pick('a,d,e,f')(null)).toEqual(undefined)
})
test('works with list as input and number as props - props to pick is an array', () => {
const result = pick([ 1, 2 ], [ 'a', 'b', 'c', 'd' ])
expect(result).toEqual({
1 : 'b',
2 : 'c',
})
})
test('works with list as input and number as props - props to pick is a string', () => {
const result = pick('1,2', [ 'a', 'b', 'c', 'd' ])
expect(result).toEqual({
1 : 'b',
2 : 'c',
})
})
test('with symbol', () => {
const symbolProp = Symbol('s')
expect(pick([ symbolProp ], { [ symbolProp ] : 'a' })).toMatchInlineSnapshot(`
Object {
Symbol(s): "a",
}
`)
})
pickAll<T, U>(propsToPick: readonly string[], input: T): U
Same as R.pick but it won't skip the missing props, i.e. it will assign them to undefined.
:boom: When using this method with
TypeScript, it is much easier to passpropsToPickas an array. If passing a string, you will need to explicitly declare the output type.
const obj = {
a : 1,
b : false,
foo: 'cherry'
}
const propsToPick = 'a,foo,bar'
const propsToPickList = ['a', 'foo', 'bar']
const result = [
R.pickAll(propsToPick, obj),
R.pickAll(propsToPickList, obj),
R.pickAll('a,bar', obj),
R.pickAll('bar', obj),
]
const expected = [
{a:1, foo: 'cherry', bar: undefined},
{a:1, foo: 'cherry', bar: undefined},
{a:1, bar: undefined},
{bar: undefined}
]
// => `result` is equal to `expected`
Try this R.pickAll example in Rambda REPL
pickAll<T, U>(propsToPick: readonly string[], input: T): U;
pickAll<T, U>(propsToPick: readonly string[]): (input: T) => U;
pickAll<T, U>(propsToPick: string, input: T): U;
pickAll<T, U>(propsToPick: string): (input: T) => U;
import { pickAll } from './pickAll'
test('when input is undefined or null', () => {
expect(pickAll('a', null)).toBe(undefined)
expect(pickAll('a', undefined)).toBe(undefined)
})
test('with string as condition', () => {
const obj = {
a : 1,
b : 2,
c : 3,
}
const result = pickAll('a,c', obj)
const resultCurry = pickAll('a,c')(obj)
const expectedResult = {
a : 1,
b : undefined,
c : 3,
}
expect(result).toEqual(expectedResult)
expect(resultCurry).toEqual(expectedResult)
})
test('with array as condition', () => {
expect(pickAll([ 'a', 'b', 'c' ], {
a : 'foo',
c : 'baz',
})).toEqual({
a : 'foo',
b : undefined,
c : 'baz',
})
})
pipe<T1>(fn0: () => T1): () => T1
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]
Try this R.pipe example in Rambda REPL
pipe<T1>(fn0: () => T1): () => T1;
pipe<V0, T1>(fn0: (x0: V0) => T1): (x0: V0) => T1;
pipe<V0, V1, T1>(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1;
pipe<V0, V1, V2, T1>(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1;
pipe<T1, T2>(fn0: () => T1, fn1: (x: T1) => T2): () => T2;
pipe<V0, T1, T2>(fn0: (x0: V0) => T1, fn1: (x: T1) => T2): (x0: V0) => T2;
pipe<V0, V1, T1, T2>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1) => T2;
pipe<V0, V1, V2, T1, T2>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1, x2: V2) => T2;
pipe<T1, T2, T3>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): () => T3;
pipe<V0, T1, T2, T3>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x: V0) => T3;
pipe<V0, V1, T1, T2, T3>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1) => T3;
pipe<V0, V1, V2, T1, T2, T3>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1, x2: V2) => T3;
pipe<T1, T2, T3, T4>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): () => T4;
pipe<V0, T1, T2, T3, T4>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x: V0) => T4;
pipe<V0, V1, T1, T2, T3, T4>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1) => T4;
pipe<V0, V1, V2, T1, T2, T3, T4>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1, x2: V2) => T4;
pipe<T1, T2, T3, T4, T5>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): () => T5;
pipe<V0, T1, T2, T3, T4, T5>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x: V0) => T5;
pipe<V0, V1, T1, T2, T3, T4, T5>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1) => T5;
pipe<V0, V1, V2, T1, T2, T3, T4, T5>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1, x2: V2) => T5;
pipe<T1, T2, T3, T4, T5, T6>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): () => T6;
pipe<V0, T1, T2, T3, T4, T5, T6>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x: V0) => T6;
pipe<V0, V1, T1, T2, T3, T4, T5, T6>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x0: V0, x1: V1) => T6;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6): (x0: V0, x1: V1, x2: V2) => T6;
pipe<T1, T2, T3, T4, T5, T6, T7>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn: (x: T6) => T7): () => T7;
pipe<V0, T1, T2, T3, T4, T5, T6, T7>(
fn0: (x: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn: (x: T6) => T7): (x: V0) => T7;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7): (x0: V0, x1: V1) => T7;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7): (x0: V0, x1: V1, x2: V2) => T7;
pipe<T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn: (x: T7) => T8): () => T8;
pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: (x: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn: (x: T7) => T8): (x: V0) => T8;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8): (x0: V0, x1: V1) => T8;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8): (x0: V0, x1: V1, x2: V2) => T8;
pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): () => T9;
pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: (x0: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): (x0: V0) => T9;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): (x0: V0, x1: V1) => T9;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): (x0: V0, x1: V1, x2: V2) => T9;
pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): () => T10;
pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: (x0: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): (x0: V0) => T10;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): (x0: V0, x1: V1) => T10;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): (x0: V0, x1: V1, x2: V2) => T10;
import { add, last, map } from '../rambda'
import { pipe } from './pipe'
test('happy', () => {
const list = [ 1, 2, 3 ]
const result = pipe(
map(add(1)), map(add(10)), last
)(list)
expect(result).toEqual(14)
})
test('with bad input', () => {
expect(() => pipe()).toThrowWithMessage(Error,
'pipe requires at least one argument')
})
pipeAsync<Out>(
...fns: (Async<any> | Func<any>)[]
): (input: any) => Promise<Out>
Asynchronous version of R.pipe
:boom: It doesn't work with promises or function returning promises such as
const foo = input => new Promise(...).
const add = async x => {
await R.delay(100)
return x + 1
}
const multiply = async x => {
await R.delay(100)
return x * 2
}
const result = await R.pipeAsync(
add,
multiply
)(1)
// `result` resolves to `4`
Try this R.pipeAsync example in Rambda REPL
pipeAsync<Out>(
...fns: (Async<any> | Func<any>)[]
): (input: any) => Promise<Out>;
pipeAsync<Out>(
...fns: (Async<any> | Func<any>)[]
): (input: any) => Promise<Out>;
import { delay } from './delay'
import { equals } from './equals'
import { map } from './map'
import { pipeAsync } from './pipeAsync'
async function identity(x){
await delay(100)
return x
}
test('happy', async () => {
const fn1 = async x => {
await delay(100)
return x.map(xx => xx + 1)
}
const fn2 = async x => {
await delay(100)
return x.map(xx => xx * 2)
}
const result = await pipeAsync(fn1,
fn2)(await Promise.all([ identity(1), identity(2), identity(3) ]))
expect(result).toEqual([ 4, 6, 8 ])
})
const delayFn = ms =>
new Promise(resolve => {
resolve(ms + 1)
})
test('with function returning promise', async () => {
const result = await pipeAsync(
x => x,
x => x + 1,
delayFn,
x => x
)(1)
expect(result).toEqual(3)
})
test('throw error', async () => {
const fn = async () => {
await delay(1)
JSON.parse('{foo')
}
let didThrow = false
try {
await pipeAsync(x => x, fn)(20)
} catch (e){
didThrow = true
}
expect(didThrow).toBeTrue()
})
piped<T>(input: any, ...fnList: Func<any>[]): T
It is basically R.pipe, but instead of passing input argument as R.pipe(...)(input), you pass it as the first argument.
:boom: Independently, similar method is implemented in
Ramadalibrary, but there the name of the method ispipe- Remeda.pipe
const result = piped(
[1, 2, 3],
R.filter(x => x > 1),
R.map(x => x*10),
)
// => [20, 30]
Try this R.piped example in Rambda REPL
piped<T>(input: any, ...fnList: Func<any>[]): T;
import { add } from './add'
import { filter } from './filter'
import { map } from './map'
import { piped } from './piped'
test('happy', () => {
const result = piped(
[ 1, 2, 3 ],
filter(x => x > 1),
map(x => x * 10),
map(add(1))
)
const expectedResult = [ 21, 31 ]
expect(result).toEqual(expectedResult)
})
pipedAsync<T>(
input: any,
...fns: (Func<any> | Async<any>)[]
): Promise<T>
It accepts input as first argument and series of functions as next arguments. It is same as R.pipe but with support for asynchronous functions.
:boom: Functions that return
Promisewill be handled as regular function not asynchronous. Such example isconst foo = input => new Promise(...).
const result = R.pipedAsync(
100,
async x => {
await R.delay(100)
return x + 2
},
R.add(2),
async x => {
const delayed = await R.delay(100)
return delayed + x
}
)
const expected = 'RAMBDAX_DELAY104'
// `result` resolves to `expected`
Try this R.pipedAsync example in Rambda REPL
pipedAsync<T>(
input: any,
...fns: (Func<any> | Async<any>)[]
): Promise<T>;
import { add } from './add'
import { delay } from './delay'
import { pipedAsync } from './pipedAsync'
const fn1 = async x => {
await delay(100)
return x + 2
}
const fn2 = async x => {
await delay(100)
return x + 3
}
test('happy', async () => {
const result = await pipedAsync(
1, fn1, add(2), fn2
)
expect(result).toBe(8)
})
pluck<K extends keyof T, T>(property: K, list: readonly T[]): Array<T[K]>
It returns list of the values of property taken from the all objects inside list.
const list = [{a: 1}, {a: 2}, {b: 3}]
const property = 'a'
R.pluck(list, property)
// => [1, 2]
Try this R.pluck example in Rambda REPL
pluck<K extends keyof T, T>(property: K, list: readonly T[]): Array<T[K]>;
pluck<T>(property: number, list: ReadonlyArray<{ [k: number]: T }>): T[];
pluck<P extends string>(property: P): <T>(list: ReadonlyArray<Record<P, T>>) => T[];
pluck(property: number): <T>(list: ReadonlyArray<{ [k: number]: T }>) => T[];
import { pluck } from './pluck'
test('happy', () => {
expect(pluck('a')([ { a : 1 }, { a : 2 }, { b : 1 } ])).toEqual([ 1, 2 ])
})
test('with number', () => {
const input = [
[ 1, 2 ],
[ 3, 4 ],
]
expect(pluck(0, input)).toEqual([ 1, 3 ])
})
prepend<T>(x: T, input: T[]): T[]
It adds element x at the beginning of list.
const result = R.prepend('foo', ['bar', 'baz'])
// => ['foo', 'bar', 'baz']
Try this R.prepend example in Rambda REPL
prepend<T>(x: T, input: T[]): T[];
prepend<T>(x: T): (input: T[]) => T[];
import { prepend } from './prepend'
test('happy', () => {
expect(prepend('yes', [ 'foo', 'bar', 'baz' ])).toEqual([
'yes',
'foo',
'bar',
'baz',
])
})
test('with empty list', () => {
expect(prepend('foo')([])).toEqual([ 'foo' ])
})
test('with string instead of array', () => {
expect(prepend('foo')('bar')).toEqual([ 'foo', 'b', 'a', 'r' ])
})
prevIndex(index: number, list: readonly any[]): number
It returns the next index of the list when the order is descending.
If we have reached the beginning of the list, then it will return the last index of the list.
:boom: Unlike
R.nextIndex, which safeguards against index out of bounds, this method does not.
const list = [1, 2, 3]
const result = [
R.prevIndex(0, list),
R.prevIndex(1, list),
R.prevIndex(2, list),
]
// => [2, 0, 1]
Try this R.prevIndex example in Rambda REPL
prevIndex(index: number, list: readonly any[]): number;
import { prevIndex } from './prevIndex'
const list = [ 1, 2, 3, 4 ]
test('happy path 1', () => {
expect(prevIndex(2, list)).toEqual(1)
})
test('happy path 2', () => {
expect(prevIndex(0, list)).toEqual(3)
})
produce<Input, Output>(
rules: ProduceRules<Input>,
input: Input
): Promise<Output>
It returns an object created by applying each value of rules to input argument
rules input is an object with synchronous or asynchronous functions as values.
The return value is wrapped in a promise, even if all rules are synchronous functions.
:boom: It is very similar to
R.applySpec.
const rules = {
foo: async x => {
await R.delay(100)
return x > 1
},
bar: x => ({baz: x})
}
const input = 2
const result = await R.produce(rules, input)
const expected = {
foo: true,
bar: {baz: 2}
}
// => `result` is equal to `expected`
Try this R.produce example in Rambda REPL
produce<Input, Output>(
rules: ProduceRules<Input>,
input: Input
): Promise<Output>;
produce<Input, Output>(
rules: ProduceRules<Input>
): (
input: Input
) => Promise<Output>;
import { delay } from './delay'
import { produce } from './produce'
test('async', async () => {
const fn = produce({
foo : async x => {
await delay(100)
return `${ x }_ZEPPELIN`
},
bar : inputArgument => inputArgument === 5,
})
const expected = {
foo : 'LED_ZEPPELIN',
bar : false,
}
const result = await fn('LED')
expect(result).toEqual(expected)
})
test('async with error', async () => {
const fn = produce({
foo : async x => {
await delay(100)
throw new Error(`${ x }_ZEPPELIN`)
},
bar : inputArgument => inputArgument === 5,
})
try {
await fn('LED')
expect(1).toBe(2)
} catch (e){
expect(e.message).toBe('LED_ZEPPELIN')
}
})
product(list: readonly number[]): number
R.product([ 2, 3, 4 ])
// => 24)
Try this R.product example in Rambda REPL
product(list: readonly number[]): number;
import { product } from './product'
test('happy', () => {
expect(product([ 2, 3, 4 ])).toEqual(24)
})
test('bad input', () => {
expect(product([ null ])).toEqual(0)
expect(product([])).toEqual(1)
})
prop<P extends keyof T, T>(propToFind: P, obj: T): T[P]
It returns the value of property propToFind in obj.
If there is no such property, it returns undefined.
const result = [
R.prop('x', {x: 100}),
R.prop('x', {a: 1})
]
// => [100, undefined]
Try this R.prop example in Rambda REPL
prop<P extends keyof T, T>(propToFind: P, obj: T): T[P];
prop<P extends string>(p: P): <T>(propToFind: Record<P, T>) => T;
prop<P extends string, T>(p: P): (propToFind: Record<P, T>) => T;
import { prop } from './prop'
test('prop', () => {
expect(prop('foo')({ foo : 'baz' })).toEqual('baz')
expect(prop('bar')({ foo : 'baz' })).toEqual(undefined)
expect(prop('bar')(null)).toEqual(undefined)
})
propEq<T, K extends keyof T>(propToFind: K, valueToMatch: T[K], obj: T): boolean
It returns true if obj has property propToFind and its value is equal to valueToMatch.
const obj = { foo: 'bar' }
const secondObj = { foo: 1 }
const propToFind = 'foo'
const valueToMatch = 'bar'
const result = [
R.propEq(propToFind, valueToMatch, obj),
R.propEq(propToFind, valueToMatch, secondObj)
]
// => [true, false]
Try this R.propEq example in Rambda REPL
propEq<T, K extends keyof T>(propToFind: K, valueToMatch: T[K], obj: T): boolean;
propEq<T, K extends keyof T>(propToFind: K, valueToMatch: T[K]): (obj: T) => boolean;
propEq<T, K extends keyof T>(propToFind: K): {
(valueToMatch: T[K], obj: T): boolean;
(valueToMatch: T[K]): (obj: T) => boolean;
};
import { propEq } from './propEq'
test('happy', () => {
expect(propEq('foo', 'bar')({ foo : 'bar' })).toBeTrue()
expect(propEq('foo', 'bar')({ foo : 'baz' })).toBeFalse()
expect(propEq('foo')('bar')({ foo : 'baz' })).toBeFalse()
expect(propEq(
'foo', 'bar', null
)).toBeFalse()
})
propIs(type: any, name: string, obj: any): boolean
It returns true if property of obj is from target type.
const obj = {a:1, b: 'foo'}
const property = 'foo'
const result = [
R.propIs(String, property, obj),
R.propIs(Number, property, obj)
]
// => [true, false]
Try this R.propIs example in Rambda REPL
propIs(type: any, name: string, obj: any): boolean;
propIs(type: any, name: string): (obj: any) => boolean;
propIs(type: any): {
(name: string, obj: any): boolean;
(name: string): (obj: any) => boolean;
};
import { propIs } from './propIs'
const obj = { value : 1 }
const property = 'value'
test('when true', () => {
expect(propIs(
Number, property, obj
)).toBeTrue()
})
test('when false', () => {
expect(propIs(
String, property, obj
)).toBeFalse()
expect(propIs(
String, property, {}
)).toBeFalse()
})
propOr<T>(defaultValue: T, property: string, obj: { [key: string]: T}): T
It returns either defaultValue or the value of property in obj.
const obj = {a: 1}
const defaultValue = 'DEFAULT_VALUE'
const property = 'a'
const result = [
R.propOr(defaultValue, property, obj),
R.propOr(defaultValue, 'foo', obj)
]
// => [1, 'DEFAULT_VALUE']
Try this R.propOr example in Rambda REPL
propOr<T>(defaultValue: T, property: string, obj: { [key: string]: T}): T;
propOr<T>(defaultValue: T, property: string): (obj: { [key: string]: T}) => T;
propOr<T>(defaultValue: T): FunctionToolbelt.Curry<(property: string, obj: { [key: string]: T}) => T>;
import { propOr } from './propOr'
test('propOr (result)', () => {
const obj = { a : 1 }
expect(propOr(
'default', 'a', obj
)).toEqual(1)
expect(propOr(
'default', 'notExist', obj
)).toEqual('default')
expect(propOr(
'default', 'notExist', null
)).toEqual('default')
})
test('propOr (currying)', () => {
const obj = { a : 1 }
expect(propOr('default')('a', obj)).toEqual(1)
expect(propOr('default', 'a')(obj)).toEqual(1)
expect(propOr('default')('notExist', obj)).toEqual('default')
expect(propOr('default', 'notExist')(obj)).toEqual('default')
})
props<P extends string, T>(propsToPick: P[], obj: Record<P, T>): T[]
It takes list with properties propsToPick and returns a list with property values in obj.
const result = R.props(['a', 'b'], {a:1, c:3})
// => [1, undefined]
Try this R.props example in Rambda REPL
props<P extends string, T>(propsToPick: P[], obj: Record<P, T>): T[];
props<P extends string>(propsToPick: P[]): <T>(obj: Record<P, T>) => T[];
props<P extends string, T>(propsToPick: P[]): (obj: Record<P, T>) => T[];
import { props } from './props'
const obj = {a: 1, b: 2}
test('happy', () => {
const result = props(['a', 'c'], obj)
console.log(result)
expect(result).toEqual([1,undefined])
})
random(minInclusive: number, maxInclusive: number): number
It returns a random number between min inclusive and max inclusive.
random(minInclusive: number, maxInclusive: number): number;
import { random } from './random'
import { range } from './range'
test('when returns true', () => {
range(0, 100).map(() => {
const randomResult = random(1, 10)
expect(randomResult).toBeLessThanOrEqual(10)
expect(randomResult).toBeGreaterThanOrEqual(1)
})
})
range(startInclusive: number, endExclusive: number): number[]
It returns list of numbers between startInclusive to endExclusive markers.
R.range(0, 5)
// => [0, 1, 2, 3, 4]
Try this R.range example in Rambda REPL
range(startInclusive: number, endExclusive: number): number[];
range(startInclusive: number): (endExclusive: number) => number[];
import { range } from './range'
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 ])
})
reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: T[]): TResult
:boom: It passes index of the list as third argument to
reducerfunction.
const list = [1, 2, 3]
const initialValue = 10
const reducer = (prev, current) => prev * current
const result = R.reduce(reducer, initialValue, list)
// => 60
Try this R.reduce example in Rambda REPL
reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: T[]): TResult;
reduce<T, TResult>(reducer: (prev: TResult, current: T) => TResult, initialValue: TResult, list: T[]): TResult;
reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult): (initialValue: TResult, list: T[]) => TResult;
reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult, initialValue: TResult): (list: T[]) => TResult;
import { reduce } from './reduce'
const reducer = (
prev, current, i
) => {
expect(i).toBeNumber()
return prev + current
}
const initialValue = 1
const list = [ 1, 2, 3 ]
test('happy', () => {
expect(reduce(
reducer, initialValue, list
)).toEqual(7)
})
test('with object as iterable', () => {
expect(() =>
reduce(
reducer, initialValue, {
a : 1,
b : 2,
}
)).toThrowWithMessage(TypeError, 'reduce: list must be array or iterable')
})
test('with undefined as iterable', () => {
expect(() => reduce(
reducer, initialValue, undefined
)).toThrowWithMessage(TypeError,
'reduce: list must be array or iterable')
})
reject<T>(predicate: FilterFunctionArray<T>, list: readonly T[]): T[]
It has the opposite effect of R.filter.
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, obj)
]
// => [[1, 2], {a: 1}]
Try this R.reject example in Rambda REPL
reject<T>(predicate: FilterFunctionArray<T>, list: readonly T[]): T[];
reject<T>(predicate: FilterFunctionArray<T>): (list: readonly T[]) => T[];
reject<T>(predicate: FilterFunctionArray<T>, obj: Dictionary<T>): Dictionary<T>;
reject<T, U>(predicate: FilterFunctionArray<T>): (obj: Dictionary<T>) => Dictionary<T>;
import { reject } from './reject'
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,
}
const fn = (
a, b, c
) => console.log({
a,
b,
c,
})
reject(fn, obj)
expect(reject(isOdd, obj)).toEqual({
b : 2,
d : 4,
})
})
remove(
toRemove: string | RegExp | (string | RegExp)[],
text: string
): string
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
removemethod. IfRambda.removeis introduced, then this method will be renamed.
const result = remove(
['foo','bar'],
'foo bar baz foo'
)
// => 'baz foo'
Try this R.remove example in Rambda REPL
remove(
toRemove: string | RegExp | (string | RegExp)[],
text: string
): string;
remove(
toRemove: string | RegExp | (string | RegExp)[]
): (text: string) => string;
import { remove } from './remove'
test('happy', () => {
const inputs = [ /foo/, /not\shere/, /also/, 'bar' ]
const text = 'foo bar baz foo'
const result = remove(inputs)(text)
const expectedResult = 'baz foo'
expect(result).toEqual(expectedResult)
})
test('with strings + curry', () => {
const inputs = [ 'foo', 'bar' ]
const text = 'foo bar baz foo'
const result = remove(inputs)(text)
const expectedResult = 'baz foo'
expect(result).toEqual(expectedResult)
})
test('with strings and regex', () => {
const inputs = [ /foo/g, 'bar' ]
const text = 'foo bar baz foo'
const result = remove(inputs, text)
const expectedResult = 'baz'
expect(result).toEqual(expectedResult)
})
test('text is not string', () => {
const inputs = [ /foo/g, 'bar' ]
const text = null
expect(() => remove(inputs, text)).toThrowWithMessage(Error,
'R.remove requires string not Null')
})
test('with regexes', () => {
const inputs = [ /foo/g, /bar/ ]
const text = 'foo bar baz foo'
const result = remove(inputs, text)
const expectedResult = 'baz'
expect(result).toEqual(expectedResult)
})
test('with single rule', () => {
const inputs = /foo/g
const text = 'foo bar baz foo'
const result = remove(inputs, text)
const expectedResult = ' bar baz '
expect(result).toEqual(expectedResult)
})
removeIndex<T>(index: number, list: readonly T[]): T[]
It returns a copy of list input with removed index.
const list = [1, 2, 3, 4]
const result = R.removeIndex(1, list)
// => [1, 3, 4]
Try this R.removeIndex example in Rambda REPL
removeIndex<T>(index: number, list: readonly T[]): T[];
removeIndex(index: number): <T>(list: readonly T[]) => T[];
import { removeIndex } from './removeIndex'
const list = [ 1, 2, 3, 4 ]
test('first or before first index', () => {
expect(removeIndex(list, 0)).toEqual([ 2, 3, 4 ])
expect(removeIndex(list)(-2)).toEqual([ 2, 3, 4 ])
})
test('last or after last index', () => {
expect(removeIndex(list, 4)).toEqual([ 1, 2, 3 ])
expect(removeIndex(list, 10)).toEqual([ 1, 2, 3 ])
})
test('middle index', () => {
expect(removeIndex(list, 1)).toEqual([ 1, 3, 4 ])
expect(removeIndex(list, 2)).toEqual([ 1, 2, 4 ])
})
renameProps(rules: object, input: object): object
If property prop of rules is also a property in input, then rename input property to rules[prop].
renameProps(rules: object, input: object): object;
renameProps(rules: object): (input: object) => object;
renameProps<Output>(rules: object, input: object): Output;
renameProps<Output>(rules: object): (input: object) => Output;
import { renameProps } from './renameProps'
test('renameProps', () => {
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)
})
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)
})
repeat<T>(x: T): (timesToRepeat: number) => T[]
R.repeat('foo', 3)
// => ['foo', 'foo', 'foo']
Try this R.repeat example in Rambda REPL
repeat<T>(x: T): (timesToRepeat: number) => T[];
repeat<T>(x: T, timesToRepeat: number): T[];
import { repeat } from './repeat'
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()
})
replace(strOrRegex: RegExp | string, replacer: string, str: string): string
It replaces strOrRegex found in str with replacer.
const strOrRegex = /o/g
const result = R.replace(strOrRegex, '|0|', 'foo')
// => 'f|0||0|'
Try this R.replace example in Rambda REPL
replace(strOrRegex: RegExp | string, replacer: string, str: string): string;
replace(strOrRegex: RegExp | string, replacer: string): (str: string) => string;
replace(strOrRegex: RegExp | string): (replacer: string) => (str: string) => string;
import { replace } from './replace'
test('happy', () => {
expect(replace(
'foo', 'yes', 'foo bar baz'
)).toEqual('yes bar baz')
})
test('1', () => {
expect(replace(/\s/g)('|')('foo bar baz')).toEqual('foo|bar|baz')
})
test('2', () => {
expect(replace(/\s/g)('|', 'foo bar baz')).toEqual('foo|bar|baz')
})
test('3', () => {
expect(replace(/\s/g, '|')('foo bar baz')).toEqual('foo|bar|baz')
})
replaceAll(patterns: Array<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.
const replacer = '|'
const patterns = [ /foo/g, 'bar' ]
const input = 'foo bar baz foo bar'
const result = replaceAll(patterns, replacer, input)
// => '| | baz | bar'
Try this R.replaceAll example in Rambda REPL
replaceAll(patterns: Array<RegExp | string>, replacer: string, input: string): string;
replaceAll(patterns: Array<RegExp | string>, replacer: string): (input: string) => string;
replaceAll(patterns: Array<RegExp | string>): (replacer: string) => (input: string) => string;
import { replaceAll } from './replaceAll'
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
)).toThrow()
})
test('throws when wrong input', () => {
expect(() => replaceAll(
patterns, replacer, []
)).toThrow()
})
test('throws when wrong replacer', () => {
expect(() => replaceAll(
patterns, null, input
)).toThrow()
})
reset(): void
:boom:
R.gettermethod contains explanations, tests and source information ofR.reset,R.setterandR.gettermethods.
reset(): void;
reverse<T>(input: readonly T[]): T[]
It returns a reversed copy of list or string input.
const result = [
R.reverse('foo'),
R.reverse([1, 2, 3])
]
// => ['oof', [3, 2, 1]
Try this R.reverse example in Rambda REPL
reverse<T>(input: readonly T[]): T[];
reverse(input: string): string;
import { reverse } from './reverse'
test('happy', () => {
expect(reverse([ 1, 2, 3 ])).toEqual([ 3, 2, 1 ])
})
test('with string', () => {
expect(reverse('baz')).toEqual('zab')
})
test('it doesn\'t mutate', () => {
const arr = [ 1, 2, 3 ]
expect(reverse(arr)).toEqual([ 3, 2, 1 ])
expect(arr).toEqual([ 1, 2, 3 ])
})
set<T, U>(lens: Lens, replacer: U, obj: T): T
It returns a copied Object or Array with modified lens focus set to replacer value.
const input = {x: 1, y: 2}
const xLens = R.lensProp('x')
R.set(xLens, 4, input) //=> {x: 4, y: 2}
R.set(xLens, 8, input) //=> {x: 8, y: 2}
Try this R.set example in Rambda REPL
set<T, U>(lens: Lens, replacer: U, obj: T): T;
set<U>(lens: Lens, replacer: U): <T>(obj: T) => T;
set(lens: Lens): <T, U>(replacer: U, obj: T) => T;
import { assoc } from './assoc'
import { lens } from './lens'
import { lensIndex } from './lensIndex'
import { lensPath } from './lensPath'
import { prop } from './prop'
import { set } from './set'
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 ])
})
setter(keyOrObject: string | object, value?: any): void
:boom:
R.gettermethod contains explanations, tests and source information ofR.reset,R.setterandR.gettermethods.
setter(keyOrObject: string | object, value?: any): void;
shuffle<T>(list: readonly T[]): T[]
It returns a randomized copy of array.
shuffle<T>(list: readonly T[]): T[];
import { range } from './range'
import { shuffle } from './shuffle'
import { uniq } from './uniq'
test('happy', () => {
const list = range(0, 7)
const result = range(0, 300).map(() => shuffle(list))
const allUniq = uniq(result)
expect(allUniq.length > 150).toBeTrue()
})
slice(from: number, to: number, input: string): string
const list = [0, 1, 2, 3, 4, 5]
const str = 'FOO_BAR'
const from = 1
const to = 4
const result = [
R.slice(str, to, list),
R.slice(from, to, list)
]
// => ['OO_', [1, 2, 3]]
Try this R.slice example in Rambda REPL
slice(from: number, to: number, input: string): string;
slice<T>(from: number, to: number, input: readonly T[]): T[];
slice(from: number, to: number): {
(input: string): string;
<T>(input: readonly T[]): T[];
};
slice(from: number): {
(to: number, input: string): string;
<T>(to: number, input: readonly T[]): T[];
};
import { slice } from './slice'
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'
)).toEqual('ram')
})
sort<T>(sortFn: (a: T, b: T) => number, list: readonly T[]): T[]
It returns copy of list sorted by sortFn function.
:boom:
sortFnfunction must return a number.
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
sort<T>(sortFn: (a: T, b: T) => number, list: readonly T[]): T[];
sort<T>(sortFn: (a: T, b: T) => number): (list: readonly T[]) => T[];
import { sort } from './sort'
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')
})
sortBy<T>(sortFn: (a: T) => Ord, list: readonly T[]): T[]
It returns copy of list sorted by sortFn function.
:boom:
sortFnfunction must return a value to compare.
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
sortBy<T>(sortFn: (a: T) => Ord, list: readonly T[]): T[];
sortBy(sortFn: (a: any) => Ord): <T>(list: readonly T[]) => T[];
import { compose } from './compose'
import { prop } from './prop'
import { sortBy } from './sortBy'
import { toLower } from './toLower'
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 ])
})
sortByPath<T>(sortPath: Path, list: readonly 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.
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
sortByPath<T>(sortPath: Path, list: readonly T[]): T[];
sortByPath(sortPath: Path): <T>(list: readonly T[]) => T[];
import { sortByPath } from './sortByPath'
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)
})
sortByProps<T>(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.
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.sortByProps example in Rambda REPL
sortByProps<T>(sortPaths: string[], list: T[]): T[];
sortByProps(sortPaths: string[]): <T>(list: T[]) => T[];
import { sortByProps } from './sortByProps'
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)
})
sortObject<T>(predicate: SortObjectPredicate<T>, input: { [key: string]: T }): { [keyOutput: string]: T }
It returns a sorted version of input object.
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
sortObject<T>(predicate: SortObjectPredicate<T>, input: { [key: string]: T }): { [keyOutput: string]: T };
sortObject<T>(predicate: SortObjectPredicate<T>): (input: { [key: string]: T }) => { [keyOutput: string]: T };
import { runTests } from 'helpers-fn'
import { allTrue } from './allTrue'
import { equals } from './equals'
import { sortObject } from './sortObject'
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)
split(separator: string | RegExp): (str: string) => string[]
Curried version of String.prototype.split
const str = 'foo|bar|baz'
const separator = |'
const result = R.split(separator, str))
// => [ 'foo', 'bar', 'baz' ]
Try this R.split example in Rambda REPL
split(separator: string | RegExp): (str: string) => string[];
split(separator: string | RegExp, str: string): string[];
import { split } from './split'
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)
})
splitAt<T>(index: number, input: T[]): [T[], T[]]
It splits string or array at a given index.
const list = [ 1, 2, 3 ]
const result = splitAt(2, list)
// => [[ 1, 2 ], [ 3 ]]
Try this R.splitAt example in Rambda REPL
splitAt<T>(index: number, input: T[]): [T[], T[]];
splitAt(index: number, input: string): [string, string];
splitAt(index: number): {
<T>(input: T[]): [T[], T[]];
(input: string): [string, string];
};
import { splitAt as splitAtRamda } from 'ramda'
import { splitAt } from './splitAt'
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)
console.log(result)
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 property 'slice' of ${ badInput }`)
})
badInputs.forEach(badInput => {
const result = splitAt(1, badInput)
const ramdaResult = splitAtRamda(1, badInput)
console.log({
result,
ramdaResult,
})
expect(result).toEqual(ramdaResult)
})
})
splitEvery<T>(sliceLength: number, input: readonly T[]): T[][]
It splits input into slices of sliceLength.
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
splitEvery<T>(sliceLength: number, input: readonly T[]): T[][];
splitEvery(sliceLength: number, input: string): string[];
splitEvery(sliceLength: number): {
(input: string): string[];
<T>(input: readonly T[]): T[][];
};
import { splitEvery } from './splitEvery'
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' ])).toThrowWithMessage(Error,
'First argument to splitEvery must be a positive integer')
})
splitWhen<T, U>(predicate: Predicate<T>, 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.
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
splitWhen<T, U>(predicate: Predicate<T>, list: U[]): U[][];
splitWhen<T>(predicate: Predicate<T>): <U>(list: U[]) => U[][];
// RAMBDAX_MARKER_START
import { splitWhen as splitWhenRamda } from 'ramda'
import { equals } from './equals'
import { splitWhen } from './splitWhen'
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 property 'length' of ${ badInput }`)
})
badInputs.forEach(badInput => {
const result = splitWhen(equals(2), badInput)
const ramdaResult = splitWhenRamda(equals(2), badInput)
expect(result).toEqual(ramdaResult)
})
})
startsWith(target: string, str: string): boolean
Curried version of String.prototype.startsWith
:boom: It doesn't work with arrays unlike its corresponding Ramda method.
const str = 'foo-bar'
const result = [
R.startsWith('foo', str),
R.startsWith('bar', str)
]
// => [true, false]
Try this R.startsWith example in Rambda REPL
startsWith(target: string, str: string): boolean;
startsWith(target: string): (str: string) => boolean;
import { startsWith } from './startsWith'
test('true', () => {
const result = startsWith('foo', 'foo-bar')
expect(result).toBeTrue()
})
test('false', () => {
const result = startsWith('baz')('foo-bar')
expect(result).toBeFalse()
})
subtract(x: number, y: number): number
Curried version of x - y
const x = 3
const y = 1
R.subtract(x, y)
// => 2
Try this R.subtract example in Rambda REPL
subtract(x: number, y: number): number;
subtract(x: number): (y: number) => number;
import { subtract } from './subtract'
test('happy', () => {
expect(subtract(2, 1)).toEqual(1)
expect(subtract(2)(1)).toEqual(1)
})
sum(list: readonly number[]): number
R.sum([1, 2, 3, 4, 5])
// => 15
Try this R.sum example in Rambda REPL
sum(list: readonly number[]): number;
import { sum } from './sum'
test('happy', () => {
expect(sum([ 1, 2, 3, 4, 5 ])).toBe(15)
})
switcher<T>(valueToMatch: any): Switchem<T>
Edited fork of 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.
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
switcher<T>(valueToMatch: any): Switchem<T>;
import { add } from './add'
import { switcher } from './switcher'
import { tap } from './tap'
import { trim } from './trim'
test('with undefined', () => {
const result = switcher(undefined)
.is(x => x === 0, '0')
.is(x => x === undefined, 'UNDEFINED')
.default('3')
expect(result).toEqual('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).toEqual('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).toEqual('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)).toEqual(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)).toEqual(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 ])).toEqual('has length of 7')
})
test('works with string as condition', () => {
expect(switchFn('baz')).toEqual('it is baz')
})
test('fallback to default input when no matches', () => {
expect(switchFn(1)).toEqual('it is default')
})
symmetricDifference<T>(x: readonly T[], y: readonly T[]): T[]
It returns a merged list of x and y with all equal elements removed.
:boom:
R.equalsis used to determine equality, i.e. it can be safely used with list of objects.
const x = [ 1, 2, 3, 4 ]
const y = [ 3, 4, 5, 6 ]
const result = symmetricDifference(x, y)
// => [ 1, 2, 5, 6 ]
Try this R.symmetricDifference example in Rambda REPL
symmetricDifference<T>(x: readonly T[], y: readonly T[]): T[];
symmetricDifference<T>(x: readonly T[]): <T>(y: readonly T[]) => T[];
import { symmetricDifference } from './symmetricDifference'
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 },
])
})
T(): boolean
R.T()
// => true
Try this R.T example in Rambda REPL
T(): boolean;
tail<T>(input: readonly T[]): T[]
It returns all but the first element of input.
const result = [
R.tail([1, 2, 3]),
R.tail('foo')
]
// => [[2, 3], 'oo']
Try this R.tail example in Rambda REPL
tail<T>(input: readonly T[]): T[];
tail(input: string): string;
import { tail } from './tail'
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')).toEqual('bc')
expect(tail('ab')).toEqual('b')
expect(tail('a')).toEqual('')
expect(tail('')).toEqual('')
})
take<T>(howMany: number, input: readonly T[]): T[]
It returns the first howMany elements of input.
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
take<T>(howMany: number, input: readonly T[]): T[];
take(howMany: number, input: string): string;
take<T>(howMany: number): {
<T>(input: readonly T[]): T[];
(input: string): string;
};
import { take } from './take'
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')).toEqual('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([])
})
takeLast<T>(howMany: number, input: readonly T[]): T[]
It returns the last howMany elements of input.
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
takeLast<T>(howMany: number, input: readonly T[]): T[];
takeLast(howMany: number, input: string): string;
takeLast<T>(howMany: number): {
<T>(input: readonly T[]): T[];
(input: string): string;
};
import { takeLast } from './takeLast'
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')).toEqual('bda')
expect(takeLast(7, 'rambda')).toEqual('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 ])
})
takeUntil<T>(predicate: (x: T) => boolean, list: readonly T[]): T[]
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
takeUntil<T>(predicate: (x: T) => boolean, list: readonly T[]): T[];
takeUntil<T>(predicate: (x: T) => boolean): (list: readonly T[]) => T[];
import { takeUntil } from './takeUntil'
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)
})
takeWhile<T>(predicate: (x: T) => boolean, list: readonly T[]): T[]
const list = [1, 2, 3, 4, 5]
const predicate = x => x < 3
const result = takeWhile(predicate, list)
// => [1, 2, 3]
Try this R.takeWhile example in Rambda REPL
takeWhile<T>(predicate: (x: T) => boolean, list: readonly T[]): T[];
takeWhile<T>(predicate: (x: T) => boolean): (list: readonly T[]) => T[];
import { takeWhile } from './takeWhile'
const list = [ 1, 2, 3, 4, 5, 6 ]
test('happy', () => {
const result = takeWhile(x => x < 4, list)
expect(result).toEqual([ 1, 2, 3 ])
})
test('predicate always returns true', () => {
const result = takeWhile(x => x < 10, list)
expect(result).toEqual(list)
})
test('predicate alwats returns false', () => {
const result = takeWhile(x => x > 10, list)
expect(result).toEqual([])
})
tap<T>(fn: (x: T) => void, input: T): T
It applies function fn to input x and returns x.
One use case is debuging in the middle of R.compose.
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
tap<T>(fn: (x: T) => void, input: T): T;
tap<T>(fn: (x: T) => void): (input: T) => T;
import { tap } from './tap'
test('tap', () => {
let a = 1
const sayX = x => a = x
expect(tap(sayX, 100)).toEqual(100)
expect(tap(sayX)(100)).toEqual(100)
expect(a).toEqual(100)
})
tapAsync<T>(fn: Func<any> | Promise<any>, input: T): T
Asynchronous version of R.tap.
tapAsync<T>(fn: Func<any> | Promise<any>, input: T): T;
tapAsync<T>(fn: Func<any> | Promise<any>): (input: T) => T;
import { delay } from './delay'
import { tapAsync } from './tapAsync'
test('', async () => {
const result = await tapAsync(delay)(1)
expect(result).toEqual(1)
})
test(regExpression: RegExp): (str: string) => boolean
It determines whether str matches regExpression.
R.test(/^f/, 'foo')
// => true
Try this R.test example in Rambda REPL
test(regExpression: RegExp): (str: string) => boolean;
test(regExpression: RegExp, str: string): boolean;
import { test as testMethod } from './test'
test('happy', () => {
expect(testMethod(/^x/, 'xyz')).toBeTrue()
expect(testMethod(/^y/)('xyz')).toBeFalse()
})
test('throws if first argument is not regex', () => {
expect(() => testMethod('foo', 'bar')).toThrowWithMessage(TypeError,
'‘test’ requires a value of type RegExp as its first argument; received "foo"')
})
throttle<T, U>(fn: (input: T) => U, ms: number): (input: T) => U
It creates a throttled function that invokes fn maximum once for a period of milliseconds.
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
throttle<T, U>(fn: (input: T) => U, ms: number): (input: T) => U;
throttle<T, Q, U>(fn: (input1: T, input2: Q) => U, ms: number): (input1: T, input2: Q) => U;
throttle<T, Q, Z, U>(fn: (input1: T, input2: Q, input3: Z) => U, ms: number): (input1: T, input2: Q, input3: Z) => U;
import { delay } from './delay'
import { throttle } from './throttle'
test('', async () => {
let counter = 0
let aHolder
let bHolder
const inc = (a, b) => {
aHolder = a
bHolder = b
counter++
}
const incWrapped = throttle(inc, 1000)
incWrapped(1, 2)
await delay(500)
incWrapped(2, 3)
incWrapped(3, 4)
expect(counter).toBe(1)
expect(aHolder).toBe(1)
expect(bHolder).toBe(2)
await delay(1000)
incWrapped(5, 6)
expect(counter).toBe(2)
expect(aHolder).toBe(5)
expect(bHolder).toBe(6)
})
times<T>(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).
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
times<T>(fn: (i: number) => T, howMany: number): T[];
times<T>(fn: (i: number) => T): (howMany: number) => T[];
import assert from 'assert'
import { identity } from './identity'
import { times } from './times'
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 ])
})
toDecimal(num: number, charsAfterDecimalPoint?: number): number
R.toDecimal(2.45464,2) // => 2.45
Try this R.toDecimal example in Rambda REPL
toDecimal(num: number, charsAfterDecimalPoint?: number): number;
import { toDecimal } from './toDecimal'
test('', () => {
expect(toDecimal(2.2789, 1)).toBe(2.3)
expect(toDecimal(2.2789, 3)).toBe(2.279)
expect(toDecimal(2.2789)).toBe(2.28)
expect(toDecimal(2.45464)).toBe(2.45)
})
toLower(str: string): string
R.toLower('FOO')
// => 'foo'
Try this R.toLower example in Rambda REPL
toLower(str: string): string;
import { toLower } from './toLower'
test('toLower', () => {
expect(toLower('FOO|BAR|BAZ')).toEqual('foo|bar|baz')
})
toPairs<S>(obj: { [k: string]: S } | { [k: number]: S }): [string, S][]
It transforms an object to a list.
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
toPairs<S>(obj: { [k: string]: S } | { [k: number]: S }): [string, S][];
import { toPairs } from './toPairs'
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)
})
toString<T>(x: T): string
R.toString([1, 2])
// => '1,2'
Try this R.toString example in Rambda REPL
toString<T>(x: T): string;
import { toString } from './toString'
test('happy', () => {
expect(toString([ 1, 2, 3 ])).toEqual('1,2,3')
})
toUpper(str: string): string
R.toUpper('foo')
// => 'FOO'
Try this R.toUpper example in Rambda REPL
toUpper(str: string): string;
import { toUpper } from './toUpper'
test('toUpper', () => {
expect(toUpper('foo|bar|baz')).toEqual('FOO|BAR|BAZ')
})
transpose<T>(list: readonly T[][]): T[][]
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
transpose<T>(list: readonly T[][]): T[][];
import { transpose } from './transpose'
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)
})
trim(str: string): string
R.trim(' foo ')
// => 'foo'
Try this R.trim example in Rambda REPL
trim(str: string): string;
import { trim } from './trim'
test('trim', () => {
expect(trim(' foo ')).toEqual('foo')
})
tryCatch<T, U>(
fn: (input: T) => U,
fallback: U
): (input: T) => U
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.tryCatchto fully understand how this method works.
const fn = x => x.foo
const result = [
R.tryCatch(fn, false)(null),
R.tryCatch(fn, false)({foo: 'bar'})
]
// => [false, 'bar']
Try this R.tryCatch example in Rambda REPL
tryCatch<T, U>(
fn: (input: T) => U,
fallback: U
): (input: T) => U;
tryCatch<T, U>(
fn: (input: T) => U,
fallback: (input: T) => U
): (input: T) => U;
tryCatch<T>(
fn: (input: any) => Promise<any>,
fallback: T
): (input: any) => Promise<T>;
tryCatch<T>(
fn: (input: any) => Promise<any>,
fallback: (input: any) => Promise<any>,
): (input: any) => Promise<T>;
import { delay } from './delay'
import { prop } from './prop'
import { tryCatch } from './tryCatch'
test('throws when fn is not function', () => {
const fn = 'foo'
expect(() => tryCatch(fn, false)(null)).toThrowWithMessage(Error,
'R.tryCatch | fn \'foo\'')
})
test('when fallback is used', () => {
const fn = x => x.x
expect(tryCatch(fn, false)(null)).toBeFalse()
})
test('with json parse', () => {
const good = () => JSON.parse(JSON.stringify({ a : 1 }))
const bad = () => JSON.parse('a{a')
expect(tryCatch(good, 1)(null)).toEqual({ a : 1 })
expect(tryCatch(bad, 1)(null)).toBe(1)
})
test('when fallback is function', () => {
const fn = x => x.x
expect(tryCatch(fn, () => 1)(null)).toBe(1)
})
test('when fn is used', () => {
const fn = prop('x')
expect(tryCatch(fn, false)({})).toBe(undefined)
expect(tryCatch(fn, false)({ x : 1 })).toBe(1)
})
test('fallback receives error object and all initial inputs', () => {
function thrower(
a, b, c
){
void c
throw new Error('throwerError')
}
function catchFn(
e, a, b, c
){
return [ e.message, a, b, c ].join('|')
}
const willThrow = tryCatch(thrower, catchFn)
const result = willThrow(
'A', 'B', 'C'
)
expect(result).toBe('throwerError|A|B|C')
})
test('fallback receives error object', () => {
function throwFn(){
throw new Error(10)
}
function eCatcher(
e, a, b
){
return e.message
}
const willThrow = tryCatch(throwFn, eCatcher)
expect(willThrow([])).toBe('10')
expect(willThrow([ {}, {}, {} ])).toBe('10')
})
test('when async + fallback', async () => {
let called = false
const fn = async input => {
await delay(input)
called = true
return JSON.parse('{a:')
}
expect(await tryCatch(fn, 'fallback')(100)).toBe('fallback')
expect(called).toBeTrue()
})
test('when async + fallback is function', async () => {
let called = false
const fn = async input => {
await delay(input)
called = true
return JSON.parse('{a:')
}
expect(await tryCatch(fn, x => x + 1)(100)).toBe(101)
expect(called).toBeTrue()
})
test('when async + fallback is async', async () => {
let called = false
const fn = async input => {
await delay(input)
called = true
return JSON.parse('{a:')
}
const fallback = async input => {
await delay(10)
return input + 1
}
expect(await tryCatch(fn, fallback)(100)).toBe(101)
expect(called).toBeTrue()
})
test('when async + fn', async () => {
let called = false
const fn = async input => {
await delay(input)
called = true
return input + 1
}
expect(await tryCatch(fn, 'fallback')(100)).toBe(101)
expect(called).toBeTrue()
})
type(x: any): "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "Function" | "Undefined" | "Async" | "Promise" | "RegExp" | "NaN"
It accepts any input and it returns its type.
:boom:
NaN,PromiseandAsyncare types specific for Rambda.
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'
R.type('foo'*1) // => 'NaN'
const delay = ms => new Promise(resolve => {
setTimeout(function () {
resolve()
}, ms)
})
R.type(delay) // => 'Promise'
Try this R.type example in Rambda REPL
type(x: any): "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "Function" | "Undefined" | "Async" | "Promise" | "RegExp" | "NaN";
import { type as ramdaType } from 'ramda'
import { type } from './type'
test('with simple promise', () => {
expect(type(Promise.resolve(1))).toBe('Promise')
})
test('with new Boolean', () => {
expect(type(new Boolean(true))).toBe('Boolean')
})
test('with new String', () => {
expect(type(new String('I am a String object'))).toEqual('String')
})
test('with new Number', () => {
expect(type(new Number(1))).toBe('Number')
})
test('with new promise', () => {
const delay = ms =>
new Promise(resolve => {
setTimeout(() => {
resolve(ms + 110)
}, ms)
})
expect(type(delay(10))).toEqual('Promise')
})
test('async function', () => {
expect(type(async () => {})).toEqual('Async')
})
test('async arrow', () => {
const asyncArrow = async () => {}
expect(type(asyncArrow)).toBe('Async')
})
test('function', () => {
const fn1 = () => {}
const fn2 = function (){}
function fn3(){}
;[ () => {}, fn1, fn2, fn3 ].map(val => {
expect(type(val)).toEqual('Function')
})
})
test('object', () => {
expect(type({})).toEqual('Object')
})
test('number', () => {
expect(type(1)).toEqual('Number')
})
test('boolean', () => {
expect(type(false)).toEqual('Boolean')
})
test('string', () => {
expect(type('foo')).toEqual('String')
})
test('null', () => {
expect(type(null)).toEqual('Null')
})
test('array', () => {
expect(type([])).toEqual('Array')
expect(type([ 1, 2, 3 ])).toEqual('Array')
})
test('regex', () => {
expect(type(/\s/g)).toEqual('RegExp')
})
test('undefined', () => {
expect(type(undefined)).toEqual('Undefined')
})
test('not a number', () => {
expect(type(Number('s'))).toBe('NaN')
})
test('function inside object 1', () => {
const obj = {
f(){
return 4
},
}
expect(type(obj.f)).toBe('Function')
expect(ramdaType(obj.f)).toBe('Function')
})
test('function inside object 2', () => {
const name = 'f'
const obj = {
[ name ](){
return 4
},
}
expect(type(obj.f)).toBe('Function')
expect(ramdaType(obj.f)).toBe('Function')
})
union<T>(x: readonly T[], y: readonly 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, which means that it can be safely used with array of objects.
const result = R.union([1,2,3], [3,4,5]);
//=> [1, 2, 3, 4, 5]
Try this R.union example in Rambda REPL
union<T>(x: readonly T[], y: readonly T[]): T[];
union<T>(x: readonly T[]): (y: readonly T[]) => T[];
import { union } from './union'
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)
})
uniq<T>(list: readonly T[]): T[]
It returns a new array containing only one copy of each element of list.
:boom:
R.equalsis used to determine equality
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
uniq<T>(list: readonly T[]): T[];
import { uniq } from './uniq'
test('uniq', () => {
expect(uniq([ 1, 2, 3, 3, 3, 1, 2, 0 ])).toEqual([ 1, 2, 3, 0 ])
expect(uniq([ 1, 1, 2, 1 ])).toEqual([ 1, 2 ])
expect([ 1, '1' ]).toEqual([ 1, '1' ])
expect(uniq([ [ 42 ], [ 42 ] ])).toEqual([ [ 42 ] ])
})
uniqWith<T, U>(uniqFn: (x: T, y: T) => boolean, list: readonly T[]): T[]
It returns a new array containing only one copy of each element in list according to boolean returning function uniqFn.
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 uniqFn = (x,y) => x.title === y.title
const result = R.uniqWith(uniqFn, list)
// => `result` is equal to `expected`
Try this R.uniqWith example in Rambda REPL
uniqWith<T, U>(uniqFn: (x: T, y: T) => boolean, list: readonly T[]): T[];
uniqWith<T, U>(uniqFn: (x: T, y: T) => boolean): (list: readonly T[]) => T[];
import { uniqWith } from './uniqWith'
test('happy', () => {
const input = [
{
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 = uniqWith(fn, input)
const curriedResult = uniqWith(fn)(input)
expect(result).toEqual(expectedResult)
expect(curriedResult).toEqual(expectedResult)
})
test('uniqWith', () => {
const input = [
{
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 = uniqWith(fn, input)
//const result = uniqWith(Ramda.eqBy(Ramda.prop('title')), input)
expect(result).toEqual(expectedResult)
})
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, obj: 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.
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
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, obj: T): U;
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U): (obj: T) => U;
import { inc } from './inc'
import { isNil } from './isNil'
import { unless } from './unless'
const safeInc = unless(isNil, inc)
test('happy', () => {
expect(safeInc(null)).toBeNull()
expect(safeInc(1)).toBe(2)
})
test('curried', () => {
const safeIncCurried = unless(isNil)(inc)
expect(safeIncCurried(null)).toBeNull()
expect(safeIncCurried(1)).toBe(2)
})
update<T>(index: number, newValue: T, list: readonly T[]): T[]
It returns a copy of list with updated element at index with newValue.
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
update<T>(index: number, newValue: T, list: readonly T[]): T[];
update<T>(index: number, newValue: T): (list: readonly T[]) => T[];
import { update } from './update'
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)
})
updateObject<Output>(rules: [string, any][], input: object): Output
Very similar to R.assocPath but it applies list of updates instead of only a single update.
It return a copy of obj input with changed properties according to rules input.
Each instance of rules is a tuple of object path and the new value for this path. If such object path does not exist, then such object path is created.
As it uses R.path underneath, object path can be either string or array of strings(in Typescript object path can be only a string).
const obj = {
a: {b: 1},
foo: {bar: 10},
}
const rules = [
['a.b', 2],
['foo.bar', 20],
['q.z', 300],
]
const result = R.updateObject(rules, obj)
const expected = {
a: {b: 2},
foo: {bar: 20},
q: {z: 300},
}
// => `result` is equal to `expected`
Try this R.updateObject example in Rambda REPL
updateObject<Output>(rules: [string, any][], input: object): Output;
updateObject<Output>(rules: [string, any][]): (input: object) => Output;
import { updateObject } from './updateObject'
const obj = {
a : { b : 1 },
foo : { bar : 10 },
}
const rules = [
[ 'a.b', 2 ],
[ 'foo.bar', 20 ],
[ 'q.z', 300 ],
]
const expected = {
a : { b : 2 },
foo : { bar : 20 },
q : { z : 300 },
}
test('happy', () => {
const result = updateObject(rules, obj)
console.log(result)
// expect(result).toEqual(expected)
})
values<T extends object, K extends keyof T>(obj: T): T[K][]
With correct input, this is nothing more than Object.values(obj). If obj is not an object, then it returns an empty array.
const obj = {a:1, b:2}
R.values(obj)
// => [1, 2]
Try this R.values example in Rambda REPL
values<T extends object, K extends keyof T>(obj: T): T[K][];
import { values } from './values'
test('happy', () => {
expect(values({
a : 1,
b : 2,
c : 3,
})).toEqual([ 1, 2, 3 ])
})
test('with bad input', () => {
expect(values(null)).toEqual([])
expect(values(undefined)).toEqual([])
expect(values(55)).toEqual([])
expect(values('foo')).toEqual([])
expect(values(true)).toEqual([])
expect(values(false)).toEqual([])
expect(values(NaN)).toEqual([])
expect(values(Infinity)).toEqual([])
expect(values([])).toEqual([])
})
view<T, U>(lens: Lens): (target: T) => U
It returns the value of lens focus over target object.
const lens = R.lensProp('x')
R.view(lens, {x: 1, y: 2}) //=> 1
R.view(lens, {x: 4, y: 2}) //=> 4
Try this R.view example in Rambda REPL
view<T, U>(lens: Lens): (target: T) => U;
view<T, U>(lens: Lens, target: T): U;
import { assoc } from './assoc'
import { lens } from './lens'
import { prop } from './prop'
import { view } from './view'
const testObject = { foo : 'Led Zeppelin' }
const assocLens = lens(prop('foo'), assoc('foo'))
test('happy', () => {
expect(view(assocLens, testObject)).toEqual('Led Zeppelin')
})
viewOr<Input, Output>(fallback: Output, lens: Lens, input: Input): Output
A combination between R.defaultTo and `R.view.
const lens = R.lensProp('a');
const input = {a: 'foo'}
const fallbackInput = {b: 'bar'}
const fallback = 'FALLBACK'
const result = [
R.viewOr(fallback, lens, input),
R.viewOr(fallback, lens, fallbackInput)
]
// => ['foo', 'FALLBACK']
Try this R.viewOr example in Rambda REPL
viewOr<Input, Output>(fallback: Output, lens: Lens, input: Input): Output;
viewOr<Input, Output>(fallback: Output, lens: Lens): (input: Input) => Output;
viewOr<Input, Output>(fallback: Output): FunctionToolbelt.Curry<(lens: Lens, input: Input) => Output>;
import { lensProp } from './lensProp'
import { viewOr } from './viewOr'
const lens = lensProp('a')
const input = { a : 'foo' }
const fallbackInput = { b : 'bar' }
const fallback = 'FALLBACK'
test('happy', () => {
const result = viewOr(
fallback, lens, fallbackInput
)
expect(result).toBe(fallback)
})
test('curried', () => {
const result = viewOr(fallback, lens)(input)
expect(result).toBe('foo')
})
wait<T>(fn: Promise<T>): Promise<[T, Error|undefined]>
It provides Golang-like interface for handling promises.
const [result, err] = await R.wait(R.delay(1000))
// => err is undefined
// => result is `RAMBDAX_DELAY`
Try this R.wait example in Rambda REPL
wait<T>(fn: Promise<T>): Promise<[T, Error|undefined]>;
wait<T>(fn: (x: any) => Promise<T>): Promise<[T, Error|undefined]>;
import { wait } from './wait'
test('happy path', async () => {
const fn = x => Promise.resolve(x + 1)
const [ result, err ] = await wait(fn(1))
expect(result).toBe(2)
expect(err).toBeUndefined()
})
test('when promise is rejected', async () => {
const fn = x => Promise.reject(Error('foo'))
const [ result, err ] = await wait(fn(1))
expect(result).toBeUndefined()
expect(err).toEqual(Error('foo'))
})
waitFor(
waitForTrueCondition: () => boolean,
howLong: number,
loops?: number
): () => Promise<boolean>
It returns true, if condition returns true within howLong milisececonds time period.
The method accepts an optional third argument loops(default to 10), which is the number of times waitForTrueCondition will be evaluated for howLong period. Once this function returns a value different from false, this value will be the final result.
Otherwise, R.waitFor will return false.
const howLong = 1000
let counter = 0
const waitForTrueCondition = async x => {
await R.delay(100)
counter = counter + x
return counter > 10
}
const result = await R.waitFor(waitForTrueCondition, howLong)(2)
// => true
Try this R.waitFor example in Rambda REPL
waitFor(
waitForTrueCondition: () => boolean,
howLong: number,
loops?: number
): () => Promise<boolean>;
waitFor(
waitForTrueCondition: () => Promise<boolean>,
howLong: number,
loops?: number
): () => Promise<boolean>;
waitFor<T>(
waitForTrueCondition: (input: T) => Promise<boolean>,
howLong: number,
loops?: number
): (input: T) => Promise<boolean>;
waitFor<T>(
waitForTrueCondition: (input: T) => boolean,
howLong: number,
loops?: number
): (input: T) => Promise<boolean>;
import { delay } from './delay'
import { waitFor } from './waitFor'
const howLong = 1000
test('true', async () => {
let counter = 0
const condition = x => {
counter++
return counter > x
}
const result = await waitFor(condition, howLong)(6)
expect(result).toEqual(true)
})
test('false', async () => {
let counter = 0
const condition = x => {
counter++
return counter > x
}
const result = await waitFor(condition, howLong)(12)
expect(result).toEqual(false)
})
test('async condition | true', async () => {
let counter = 0
const condition = async x => {
counter++
await delay(10)
return counter > x
}
const result = await waitFor(condition, howLong)(6)
expect(result).toEqual(true)
})
test('async condition | false', async () => {
let counter = 0
const condition = async x => {
counter++
await delay(10)
return counter > x
}
const result = await waitFor(condition, howLong)(12)
expect(result).toEqual(false)
})
test('throws when fn is not function', () => {
const fn = 'foo'
expect(() => waitFor(fn, howLong)()).toThrowWithMessage(Error, 'R.waitFor')
})
when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): U
when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): U;
when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U): (input: T) => U;
when<T, U>(predicate: (x: T) => boolean): FunctionToolbelt.Curry<(whenTrueFn: (a: T) => U, input: T) => U>;
import { add } from './add'
import { when } from './when'
const predicate = x => typeof x === 'number'
test('happy', () => {
const fn = when(predicate, add(11))
expect(fn(11)).toBe(22)
expect(fn('foo')).toBe('foo')
})
where<T, U>(conditions: T, input: U): boolean
It returns true if all each property in conditions returns true when applied to corresponding property in input object.
const condition = R.where({
a : x => typeof x === "string",
b : x => x === 4
})
const input = {
a : "foo",
b : 4,
c : 11,
}
const result = condition(input)
// => true
Try this R.where example in Rambda REPL
where<T, U>(conditions: T, input: U): boolean;
where<T>(conditions: T): <U>(input: U) => boolean;
where<ObjFunc2, U>(conditions: ObjFunc2, input: U): boolean;
where<ObjFunc2>(conditions: ObjFunc2): <U>(input: U) => boolean;
import { equals } from './equals'
import { where } from './where'
test('when true', () => {
const predicate = where({
a : equals('foo'),
b : equals('bar'),
})
expect(predicate({
a : 'foo',
b : 'bar',
x : 11,
y : 19,
})).toEqual(true)
})
test('when false', () => {
const predicate = where({
a : equals('foo'),
b : equals('baz'),
})
expect(predicate({
a : 'foo',
b : 'bar',
x : 11,
y : 19,
})).toEqual(false)
})
whereEq<T, U>(condition: T, input: U): boolean
It will return true if all of input object fully or partially include rule object.
const condition = { a : { b : 1 } }
const input = {
a : { b : 1 },
c : 2
}
const result = whereEq(condition, input)
//=> true
Try this R.whereEq example in Rambda REPL
whereEq<T, U>(condition: T, input: U): boolean;
whereEq<T>(condition: T): <U>(input: U) => boolean;
import { whereEq } from './whereEq'
test('when true', () => {
const condition = { a : 1 }
const input = {
a : 1,
b : 2,
}
const result = whereEq(condition, input)
const expectedResult = true
expect(result).toEqual(expectedResult)
})
test('when false', () => {
const condition = { a : 1 }
const input = { b : 2 }
const result = whereEq(condition, input)
const expectedResult = false
expect(result).toEqual(expectedResult)
})
test('with nested object', () => {
const condition = { a : { b : 1 } }
const input = {
a : { b : 1 },
c : 2,
}
const result = whereEq(condition)(input)
const expectedResult = true
expect(result).toEqual(expectedResult)
})
test('with wrong input', () => {
const condition = { a : { b : 1 } }
expect(() => whereEq(condition, null)).toThrowWithMessage(TypeError,
'Cannot read property \'a\' of null')
})
without<T>(matchAgainst: readonly T[], source: readonly T[]): T[]
It will return a new array, based on all members of source list that are not part of matchAgainst list.
:boom:
R.equalsis used to determine equality
const source = [1, 2, 3, 4]
const matchAgainst = [2, 3]
const result = R.without(matchAgainst, source)
// => [1, 4]
Try this R.without example in Rambda REPL
without<T>(matchAgainst: readonly T[], source: readonly T[]): T[];
without<T>(matchAgainst: readonly T[]): (source: readonly T[]) => T[];
import { without } from './without'
test('should return a new list without values in the first argument ', () => {
const itemsToOmit = [ 'A', 'B', 'C' ]
const collection = [ 'A', 'B', 'C', 'D', 'E', 'F' ]
expect(without(itemsToOmit, collection)).toEqual([ 'D', 'E', 'F' ])
expect(without(itemsToOmit)(collection)).toEqual([ 'D', 'E', 'F' ])
})
test('ramda test', () => {
expect(without([ 1, 2 ])([ 1, 2, 1, 3, 4 ])).toEqual([ 3, 4 ])
})
xor(x: boolean, y: boolean): boolean
const result = [
xor(true, true),
xor(false, false),
xor(false, true),
]
// => [false, false, true]
Try this R.xor example in Rambda REPL
xor(x: boolean, y: boolean): boolean;
xor(y: boolean): (y: boolean) => boolean;
import { xor } from './xor'
test('compares two values with exclusive or', () => {
expect(xor(true, true)).toEqual(false)
expect(xor(true, false)).toEqual(true)
expect(xor(false, true)).toEqual(true)
expect(xor(false, false)).toEqual(false)
})
test('when both values are truthy, it should return false', () => {
expect(xor(true, 'foo')).toEqual(false)
expect(xor(42, true)).toEqual(false)
expect(xor('foo', 42)).toEqual(false)
expect(xor({}, true)).toEqual(false)
expect(xor(true, [])).toEqual(false)
expect(xor([], {})).toEqual(false)
expect(xor(new Date(), true)).toEqual(false)
expect(xor(true, Infinity)).toEqual(false)
expect(xor(Infinity, new Date())).toEqual(false)
})
test('when both values are falsy, it should return false', () => {
expect(xor(null, false)).toEqual(false)
expect(xor(false, undefined)).toEqual(false)
expect(xor(undefined, null)).toEqual(false)
expect(xor(0, false)).toEqual(false)
expect(xor(false, NaN)).toEqual(false)
expect(xor(NaN, 0)).toEqual(false)
expect(xor('', false)).toEqual(false)
})
test('when one argument is truthy and the other is falsy, it should return true', () => {
expect(xor('foo', null)).toEqual(true)
expect(xor(null, 'foo')).toEqual(true)
expect(xor(undefined, 42)).toEqual(true)
expect(xor(42, undefined)).toEqual(true)
expect(xor(Infinity, NaN)).toEqual(true)
expect(xor(NaN, Infinity)).toEqual(true)
expect(xor({}, '')).toEqual(true)
expect(xor('', {})).toEqual(true)
expect(xor(new Date(), 0)).toEqual(true)
expect(xor(0, new Date())).toEqual(true)
expect(xor([], null)).toEqual(true)
expect(xor(undefined, [])).toEqual(true)
})
test.skip('returns a curried function', () => {
expect(xor()(true)(true)).toEqual(false)
expect(xor()(true)(false)).toEqual(true)
expect(xor()(false)(true)).toEqual(true)
expect(xor()(false)(false)).toEqual(false)
})
zip<K, V>(x: readonly K[], y: readonly V[]): KeyValuePair<K, V>[]
It will return a new array containing tuples of equally positions items from both x and y lists.
The returned list will be truncated to match the length of the shortest supplied list.
const x = [1, 2]
const y = ['A', 'B']
R.zip(x, y)
// => [[1, 'A'], [2, 'B']]
// truncates to shortest list
R.zip([...x, 3], ['A', 'B'])
// => [[1, 'A'], [2, 'B']]
Try this R.zip example in Rambda REPL
zip<K, V>(x: readonly K[], y: readonly V[]): KeyValuePair<K, V>[];
zip<K>(x: readonly K[]): <V>(y: readonly V[]) => KeyValuePair<K, V>[];
import { zip } from './zip'
const array1 = [ 1, 2, 3 ]
const array2 = [ 'A', 'B', 'C' ]
test('should return an array', () => {
const actual = zip(array1)(array2)
expect(actual).toBeInstanceOf(Array)
})
test('should return and array or tuples', () => {
const expected = [
[ 1, 'A' ],
[ 2, 'B' ],
[ 3, 'C' ],
]
const actual = zip(array1, array2)
expect(actual).toEqual(expected)
})
test('should truncate result to length of shorted input list', () => {
const expectedA = [
[ 1, 'A' ],
[ 2, 'B' ],
]
const actualA = zip([ 1, 2 ], array2)
expect(actualA).toEqual(expectedA)
const expectedB = [
[ 1, 'A' ],
[ 2, 'B' ],
]
const actualB = zip(array1, [ 'A', 'B' ])
expect(actualB).toEqual(expectedB)
})
zipObj<T>(keys: string[], values: T[]): { [index: string]: T }
It will return a new object with keys of keys array and values of values array.
const keys = ['a', 'b', 'c']
R.zipObj(keys, [1, 2, 3])
//=> {a: 1, b: 2, c: 3}
// truncates to shortest list
R.zipObj(keys, [1, 2])
//=> {a: 1, b: 2}
Try this R.zipObj example in Rambda REPL
zipObj<T>(keys: string[], values: T[]): { [index: string]: T };
zipObj(keys: string[]): <T>(values: T[]) => { [index: string]: T };
import { equals } from './equals'
import { zipObj } from './zipObj'
test('zipObj', () => {
expect(zipObj([ 'a', 'b', 'c' ], [ 1, 2, 3 ])).toEqual({
a : 1,
b : 2,
c : 3,
})
})
test('0', () => {
expect(zipObj([ 'a', 'b' ])([ 1, 2, 3 ])).toEqual({
a : 1,
b : 2,
})
})
test('1', () => {
expect(zipObj([ 'a', 'b', 'c' ])([ 1, 2 ])).toEqual({
a : 1,
b : 2,
})
})
test('ignore extra keys', () => {
const result = zipObj([ 'a', 'b', 'c', 'd', 'e', 'f' ], [ 1, 2, 3 ])
const expected = {
a : 1,
b : 2,
c : 3,
}
expect(equals(result, expected)).toBeTrue()
})
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): TResult[]
const list1 = [ 10, 20, 30, 40 ]
const list2 = [ 100, 200 ]
const result = R.zipWith(
R.add, list1, list2
)
// => [110, 220]
Try this R.zipWith example in Rambda REPL
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): TResult[];
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: readonly T[]): (list2: readonly U[]) => TResult[];
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult): (list1: readonly T[], list2: readonly U[]) => TResult[];
import { add } from './add'
import { zipWith } from './zipWith'
const list1 = [ 1, 2, 3 ]
const list2 = [ 10, 20, 30, 40 ]
const list3 = [ 100, 200 ]
test('when second list is shorter', () => {
const result = zipWith(
add, list1, list3
)
expect(result).toEqual([ 101, 202 ])
})
test('when second list is longer', () => {
const result = zipWith(
add, list1, list2
)
expect(result).toEqual([ 11, 22, 33 ])
})
6.2.0
R.switcher accepts undefined as valid input
Add R.props
Add R.zipWith
Add R.splitAt
Add R.splitWhen
Close Issue #547 - restore readonly declaration in Rambda Typescript definitions.
R.append/R.prepend now work only with arrays just like Ramda. Previous behaviour was for them to work with both arrays and strings.
Sync R.pluck typings with @types/ramda as there was a tiny difference.
6.1.0
Add R.mapIndexed
Add R.filterIndexed
Add R.forEachIndexed
Fix R.and wrong definition, because the function doesn't convert the result to boolean. This introduce another difference with @types/ramda.
Add R.once
Add R.or
6.0.0
Breaking change - R.map/R.filter/R.reject/R.forEach/R.partition doesn't pass index as second argument to the predicate, when looping over arrays. The old behaviour of map, filter and forEach can be found in Rambdax methods R.mapIndexed, R.filterIndexed and R.forEachIndexed(introduced in version 6.1.0).
Breaking change - R.all/R.none/R.any/R.find/R.findLast/R.findIndex/R.findLastIndex doesn't pass index as second argument to the predicate.
Add R.applyDiff method
Change R.assocPath typings so the user can explicitly sets type of the new object
Typings of R.assoc match its @types/ramda counterpart.
Simplify R.forEach typings
Remove ReadonlyArray<T> pattern from Typescript definitions - not enough value for the noise it adds.
Fix typing of R.reject as it wrongly declares that with object, it pass property to predicate.
5.1.0
Add R.takeUntil method
Fix wrong R.takeWhile
5.0.0
Deprecate R.change method - it does too much; partially replaced with R.updateObject.
Deprecate R.compact method - vague use case; R.filter does the same job.
R.produce always returns a promise
Add R.updateObject method
Add R.takeWhile method
Add R.viewOr method
Add R.pipeAsync method
Add R.removeIndex method
Add R.excludes method
R.includes throws on wrong input, i.e. R.includes(1, null)
Close Issue #524 - R.assocPath wrong logic when number is used in array path input.
R.mapToObjectAsync supports currying
R.mapAsyncLimit supports currying
Fix R.mapAsync to pass property to iterator, when input is an object.
Fix currying for several async methods - R.tapAsync, R.produce, R.filterAsync *(extend typings)
4.2.0
Add R.move method
Add R.union method
Add R.lensSatisfies method
Add R.mapKeys method
Add R.sortByPath method
Add R.sortByProps method
Close Issue #519 -
ts-toolbelt needs other type of export with --isolatedModules flag
4.1.0
R.template is renamed to R.interpolate
R.equals now supports negative zero just like Ramda.equals
Add R.replaceAll method
Add R.lensEq method
4.0.1
Forgot to export R.of because of wrong marker in files/index.d.ts
4.0.0
Deprecate the following methods:
R.promiseAllObject - because R.produce serves the same purposeR.composed - because R.piped makes more sense, when we want to pass the input at the start of the functionR.defaultToStrict - confusing logicR.findInObject - overestimated importanceR.headObject - overestimated importanceR.includesType - overestimated importanceR.inject - confusing logicR.isAttach - confusing logicR.mergeRight - overestimated importanceR.opposite - overestimated importanceR.otherwise - overestimated importanceR.pushUniq - overestimated importanceR.resolve - overestimated importanceR.s - overestimated importanceR.toggle - overestimated importanceR.uuid - not suitableR.whenAsync - overestimated importanceMove the following methods to Rambda and change their logic to match Ramda implementation:
R.hasPathR.unlessR.pathEqR.tryCatchR.whereR.whereEqAlso these changes:
R.flatMap - renamed to R.chain and moved to Rambda
R.ifElseAsync - accept any number of arguments for the returned function
R.produce, R.filterAsync, R.debounce, R.throttle - fix typings
R.mapAsyncLimit - drop support for curring and therefore for usage with R.composeAsync
Improve R.ok throwed error message
R.ok returns undefined instead of true when validation passes.
R.mergeDeep is renamed to R.mergeDeepLeft
Add R.pipeAsync
Take R.partialCurry from Rambda as it is deprecated there
3.7.0
Sync with Rambda
Add R.lens
Add R.lensIndex
Add R.lensPath
Add R.lensProp
Add R.over
Add R.set
Add R.view
Add R.paths
Add R.xor
Add R.cond
3.6.0
Add R.mapAsyncLimit
Add R.toggle, match Ramda upcoming method specification
Add R.isValidAsync
Extend R.template without introducing breaking change
3.5.0 Sync with Rambda - add methods descriptions to Typescript definitions
3.4.0 Sync with Rambda and close Issue #42
3.3.0 Fix R.sortObject typing
3.3.0 Add R.filterAsync and R.sortObject methods
3.2.0 R.uuid accept second argument in order to return string only uuid
3.1.0 Dynamic set of exports lead to adding previously ommited Rambda exports such as R.identical
3.0.3 Sync with Rambda - new functionality of R.isEmpty
3.0.2 Add typings for R.mapToObject
3.0.1 Fix typings
3.0.0 Breaking change as Rambda also has breaking changes
Read more about it in Rambda changelog
Also with this versions, typings tests are provided and several definitions are changed.
R.anyTrue, R.anyFalse, R.allTrue, R.allFalse use internal isTruthy and isFalsy methods. Empty array and object with zero length are considered falsy.
Deprecate R.contains
Deprecate R.defaultToWhen
Moved R.runTests to helpers repo
2.17.0 Change in R.runTests logic. It will be removed from Rambdax to helpers repo.
2.16.0 Restore R.runTests but without documentation
getEvaluations, getPositiveEvaluation, getNegativeEvaluation in the context of R.runTests2.15.0 Several changes
Typescript definitions have been updated and typings tests are introduced
R.mapAsync and R.mapFastAsync pass index as second argument
2.14.1 Restore R.contains
2.14.0 Several changes:
R.inject accept before flag as fourth argument
Remove R.includesAny
Improve typing of R.partition
R.nextIndex and R.prevIndex work also with number as second argument
2.13.1 Deprecate R.log and R.runTests
2.12.3 Add 'dist' directory to files
2.12.2 Add R.mapToObject typings
2.12.0 Sync with Rambda
2.11.1 Fix R.waitFor
2.11.0 Add R.toDecimal
2.10.2 Fix issue 32
2.10.0 deprecate R._
2.9.1 R.fromPairs/toPairs typing
2.9.0 npm doesn't update version on their site
2.8.2 R.map typing
2.8.0 Sync with Rambda | no need for create types script
2.7.0 Add R.prevIndex
2.6.2 Sync with Rambda
2.6.0 R.log depends on RAMBDAX_LOG
2.5.0 Rambda's partial
2.4.0 Add R.uuid
2.3.0 R._ parse to constant case
This introduce breaking change for ie11 as noted in issue 31 which is fixed with
2.10.0which deprecates this method
2.2.1 Add R.log, R.logInit and R.logHolder
2.1.0 Add R._
2.0.0 Add R.toggle
1.9.0 Add R.pushUniq
1.8.2 No need for sourcemaps
1.8.1 Fix building with regeneratorRuntime
1.8.0 Upgrade to new major Rollup release
Restore R.headObject
Add R.hasPath method
1.7.2 R.memoize contains dev console.logs
1.7.1 Forgot to build types
1.7.0 Rename R.then to R.resolve because of Ramda issue with R.then(they rename it to R.andThen)
R.isFalsy, R.nextIndex and R.mergeDeep1.6.3 Forgot to export R.unless(credit to @mobily for the PR)
1.6.0 Restore R.compact method
1.5.6 R.maybe accepts also anonymous functions as second and third argument
1.5.5 Add R.maybe method
DeepScan serviceR.then and R.otherwiseR.change increase nesting level to 41.4.1 R.isValid didn't work with Number prototype
1.4.0 Add multiple methods
Add R.defaultToStrict
Add R.defaultToWhen
Add R.whereEq
Add R.partition
Add R.negate is renamed to R.opposite
Add R.then
Add R.otherwise
R.isValid accepts prototypes as rules, i.e. schema = {a: String}
The prevoious point leads to the same change applied to the methods depending on R.isValid, i.e. R.ok, R.pass and R.isAttach
1.3.0 Add R.unless
R.when accepts both function and value for whenTrue argument. The same is valid for R.unless
export R.negate which is the same as R.complement
1.2.0 Export src folder
1.1.0 Restore promiseAllObject and flatMap
1.0.1 Fix typings
1.0.0 Deprecate the following methods:
compact
evolve
flatMap
greater
intersection
less
omitBy
pickBy
promiseAllObject
promiseAllSecure
rangeBy
Also pass deprecation of
addIndexfromRambda@2.0.0
0.24.0 add R.pipedAsync, replace R.multiline with R.glue, remove R.validate
0.23.0 Add R.count
0.22.0 Add R.includesAny
0.21.0 Add R.includesType
0.20.1 R.pass and R.ok work with single schema.
0.20.0 Add R.pathEq
0.19.0 Add R.wait, expose already complete R.waitFor
0.18.0 AddR.anyType and R.allType
0.17.0 Rename R.is to R.pass and restore R.is original functionality.
0.16.0 getter, setter, reset methods
0.15.3 No more prepublish script
0.15.2 curry in remove
Last version with
libfolder exposed
Most influential contributors
@farwayer - improving performance in R.find, R.filter; give the idea how to make benchmarks more reliable;
@thejohnfreeman - add R.assoc, R.chain;
@helmuthdu - add R.clone; help improve code style;
@jpgorman - add R.zip, R.reject, R.without, R.addIndex;
@ku8ar - add R.slice, R.propOr, R.identical, R.propIs and several math related methods; introduce the idea to display missing Ramda methods;
@romgrk - add R.groupBy, R.indexBy, R.findLast, R.findLastIndex;
@squidfunk - add R.assocPath, R.symmetricDifference, R.difference, R.intersperse;
@synthet1c - add all lenses methods; add R.applySpec, R.converge;
@vlad-zhukov - help with configuring Rollup, Babel; change export file to use ES module exports;
Rambda references
Links to Rambda
[https://mailchi.mp/webtoolsweekly/web-tools-280](Web Tools Weekly)
Releases
Rambda's releases are used mostly for testing purposes, so it is not advisable to be used.
Niketa themeCollection of 9 light VSCode themes |
Niketa dark themeCollection of 9 dark VSCode themes |
String-fnString utility library |
Useful Javascript librariesLarge collection of JavaScript,Typescript and Angular related repos links |
Run-fnCLI commands for lint JS/TS files, commit git changes and upgrade of dependencies |
FAQs
Extended version of Rambda - a lightweight, faster alternative to Ramda
The npm package rambdax receives a total of 9,785 weekly downloads. As such, rambdax popularity was classified as popular.
We found that rambdax demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.