Rambda is a lightweight and fast utility library that provides a variety of functions for functional programming in JavaScript. It is a smaller and faster alternative to Ramda, offering a similar API but with a focus on performance and simplicity.
Currying
Currying is a technique of evaluating functions with multiple arguments, one at a time. Rambda's `curry` function allows you to transform a function so that it can be called with fewer arguments than it expects, returning a new function that takes the remaining arguments.
const R = require('rambda');
const add = R.curry((a, b) => a + b);
const add5 = add(5);
console.log(add5(3)); // 8Composition
Function composition is the process of combining two or more functions to produce a new function. Rambda's `compose` function allows you to create a pipeline of functions that are executed from right to left.
const R = require('rambda');
const add = (a, b) => a + b;
const multiply = (a, b) => a * b;
const addAndMultiply = R.compose(R.multiply(2), R.add(3));
console.log(addAndMultiply(4)); // 14Cloning
Cloning is the process of creating a deep copy of an object. Rambda's `clone` function allows you to create a deep copy of an object, ensuring that changes to the new object do not affect the original object.
const R = require('rambda');
const obj = {a: 1, b: 2};
const clonedObj = R.clone(obj);
console.log(clonedObj); // {a: 1, b: 2}Filtering
Filtering is the process of selecting a subset of items from a collection based on a predicate function. Rambda's `filter` function allows you to filter elements in an array or object based on a provided predicate.
const R = require('rambda');
const isEven = n => n % 2 === 0;
const numbers = [1, 2, 3, 4, 5, 6];
const evenNumbers = R.filter(isEven, numbers);
console.log(evenNumbers); // [2, 4, 6]Mapping
Mapping is the process of transforming each item in a collection using a provided function. Rambda's `map` function allows you to apply a function to each element in an array or object, returning a new array or object with the transformed elements.
const R = require('rambda');
const double = n => n * 2;
const numbers = [1, 2, 3, 4, 5];
const doubledNumbers = R.map(double, numbers);
console.log(doubledNumbers); // [2, 4, 6, 8, 10]Lodash is a popular utility library that provides a wide range of functions for common programming tasks. It is more feature-rich compared to Rambda but also larger in size. Lodash focuses on performance and ease of use, offering a comprehensive set of tools for working with arrays, objects, strings, and more.
Underscore is another utility library that provides a variety of functional programming helpers. It is similar to Lodash but with a smaller footprint and fewer features. Underscore offers a core set of functions for working with collections, arrays, objects, and functions, making it a good choice for projects that need a lightweight utility library.
Ramda is a functional programming library for JavaScript that emphasizes immutability and pure functions. It offers a similar API to Rambda but with a larger set of functions and a focus on functional programming principles. Ramda is more feature-rich but also larger in size compared to Rambda.
Rambda is smaller and faster alternative to the popular functional programming library Ramda. - Documentation
import { compose, map, filter } from 'rambda'
const result = compose(
map(x => x * 2),
filter(x => x > 2)
)([1, 2, 3, 4])
// => [6, 8]
You can test this example in Rambda's REPL
Typescript definitions are included in the library, in comparison to Ramda, where you need to additionally install @types/ramda.
Still, you need to be aware that functional programming features in Typescript are in development, which means that using R.compose/R.pipe can be problematic.
Important - Rambda version 7.0.0(or higher) requires Typescript version 4.2.2(or higher).
Alternative TS definitions are available as
rambda/immutable. These are Rambda definitions linted with ESLintfunctional/prefer-readonly-typeplugin.
The size of a library affects not only the build bundle size but also the dev bundle size and build time. This is important advantage, expecially for big projects.
Currently Rambda is more tree-shakable than Ramda - proven in the following repo.
The repo holds two Angular9 applications: one with small example code of Ramda and the other - same code but with Rambda as import library.
The test shows that Rambda bundle size is 2 MB less than its Ramda counterpart.
There is also Webpack/Rollup/Parcel/Esbuild tree-shaking example including several libraries including Ramda, Rambda and Rambdax.
actually tree-shaking is the initial reason for creation of
Rambda
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
Rambda is generally more performant than Ramda as the benchmarks can prove that.
Most of the valid issues are fixed within 2-3 days.
Closing the issue is usually accompanied by publishing a new patch version of Rambda to NPM.
yarn add rambda
For UMD usage either use ./dist/rambda.umd.js or the following CDN link:
https://unpkg.com/rambda@CURRENT_VERSION/dist/rambda.umd.js
import {compose, add} from 'https://raw.githubusercontent.com/selfrefactor/rambda/master/dist/rambda.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.
Ramda's indexOf/lastIndexOf work with strings and lists, while Rambda's method work only with lists as iterable input.
Error handling, when wrong inputs are provided, may not be the same. This difference will be better documented once all brute force tests are completed.
Typescript definitions between rambda and @types/ramda may vary.
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.21) and Ramda(0.27.1).
| method | Rambda | Ramda | Lodash |
|---|---|---|---|
| add | 🚀 Fastest | 21.52% slower | 82.15% slower |
| adjust | 8.48% slower | 🚀 Fastest | 🔳 |
| all | 🚀 Fastest | 1.81% slower | 🔳 |
| allPass | 🚀 Fastest | 91.09% slower | 🔳 |
| allPass | 🚀 Fastest | 98.56% slower | 🔳 |
| and | 🚀 Fastest | 89.09% slower | 🔳 |
| any | 🚀 Fastest | 92.87% slower | 45.82% slower |
| anyPass | 🚀 Fastest | 98.25% slower | 🔳 |
| append | 🚀 Fastest | 2.07% slower | 🔳 |
| applySpec | 🚀 Fastest | 80.43% slower | 🔳 |
| assoc | 72.32% slower | 60.08% slower | 🚀 Fastest |
| clone | 🚀 Fastest | 91.86% slower | 86.48% slower |
| compose | 🚀 Fastest | 32.45% slower | 13.68% slower |
| converge | 78.63% slower | 🚀 Fastest | 🔳 |
| curry | 🚀 Fastest | 28.86% slower | 🔳 |
| curryN | 🚀 Fastest | 41.05% slower | 🔳 |
| defaultTo | 🚀 Fastest | 48.91% slower | 🔳 |
| drop | 🚀 Fastest | 82.35% slower | 🔳 |
| dropLast | 🚀 Fastest | 86.74% slower | 🔳 |
| equals | 58.37% slower | 96.73% slower | 🚀 Fastest |
| filter | 6.7% slower | 72.03% slower | 🚀 Fastest |
| find | 🚀 Fastest | 85.14% slower | 42.65% slower |
| findIndex | 🚀 Fastest | 86.48% slower | 72.27% slower |
| flatten | 🚀 Fastest | 95.26% slower | 10.27% slower |
| ifElse | 🚀 Fastest | 58.56% slower | 🔳 |
| includes | 🚀 Fastest | 84.63% slower | 🔳 |
| indexOf | 🚀 Fastest | 76.63% slower | 🔳 |
| indexOf | 🚀 Fastest | 82.2% slower | 🔳 |
| init | 🚀 Fastest | 92.24% slower | 13.3% slower |
| is | 🚀 Fastest | 57.69% slower | 🔳 |
| isEmpty | 🚀 Fastest | 97.14% slower | 54.99% slower |
| last | 🚀 Fastest | 93.43% slower | 5.28% slower |
| lastIndexOf | 🚀 Fastest | 85.19% slower | 🔳 |
| map | 🚀 Fastest | 86.6% slower | 11.73% slower |
| match | 🚀 Fastest | 44.83% slower | 🔳 |
| merge | 🚀 Fastest | 12.21% slower | 55.76% slower |
| none | 🚀 Fastest | 96.48% slower | 🔳 |
| objOf | 🚀 Fastest | 38.05% slower | 🔳 |
| omit | 🚀 Fastest | 69.95% slower | 97.34% slower |
| over | 🚀 Fastest | 56.23% slower | 🔳 |
| path | 37.81% slower | 77.81% slower | 🚀 Fastest |
| pick | 🚀 Fastest | 19.07% slower | 80.2% slower |
| pipe | 0.87% slower | 🚀 Fastest | 🔳 |
| prop | 🚀 Fastest | 87.95% slower | 🔳 |
| propEq | 🚀 Fastest | 91.92% slower | 🔳 |
| range | 🚀 Fastest | 61.8% slower | 57.44% slower |
| reduce | 60.48% slower | 77.1% slower | 🚀 Fastest |
| repeat | 48.57% slower | 68.98% slower | 🚀 Fastest |
| replace | 33.45% slower | 33.99% slower | 🚀 Fastest |
| set | 🚀 Fastest | 50.35% slower | 🔳 |
| sort | 🚀 Fastest | 40.23% slower | 🔳 |
| sortBy | 🚀 Fastest | 25.29% slower | 56.88% slower |
| split | 🚀 Fastest | 55.37% slower | 17.64% slower |
| splitEvery | 🚀 Fastest | 71.98% slower | 🔳 |
| take | 🚀 Fastest | 91.96% slower | 4.72% slower |
| takeLast | 🚀 Fastest | 93.39% slower | 19.22% slower |
| test | 🚀 Fastest | 82.34% slower | 🔳 |
| type | 🚀 Fastest | 48.6% slower | 🔳 |
| uniq | 🚀 Fastest | 90.24% slower | 🔳 |
| uniqWith | 25.38% slower | 🚀 Fastest | 🔳 |
| uniqWith | 14.23% slower | 🚀 Fastest | 🔳 |
| update | 🚀 Fastest | 52.35% slower | 🔳 |
| view | 🚀 Fastest | 76.15% slower | 🔳 |
Walmart Canada reported by w-b-dev
add(a: number, b: number): number
It adds a and b.
add(a: number, b: number): number;
add(a: number): (b: number) => number;
export function add(a, b) {
if (arguments.length === 1) return _b => add(a, _b)
return Number(a) + Number(b)
}
import {add} from './add'
import {add as addRamda} from 'ramda'
import {compareCombinations} from './_internals/testUtils'
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)
})
const possibleInputs = [
/foo/,
'foo',
true,
3,
NaN,
4,
[],
Promise.resolve(1),
]
describe('brute force', () => {
compareCombinations({
fn: add,
fnRamda: addRamda,
firstInput: possibleInputs,
secondInput: possibleInputs,
callback: errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 0,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 0,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 64,
}
`)
},
})
})
import {add} from 'rambda'
describe('R.add', () => {
it('happy', () => {
const result = add(4, 1)
result // $ExpectType number
})
it('curried', () => {
const result = add(4)(1)
result // $ExpectType number
})
})
const R = require('../../dist/rambda.js')
const add = [
{
label: 'Rambda',
fn: () => {
R.add(1, 1)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.add(1, 1)
},
},
{
label: 'Lodash',
fn: () => {
_.add(1, 1)
},
},
]
adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[]
It replaces index in array list with the result of replaceFn(list[i]).
adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[];
adjust<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[];
import {curry} from './curry'
import {cloneList} from './_internals/cloneList'
function adjustFn(index, replaceFn, list) {
const actualIndex = index < 0 ? list.length + index : index
if (index >= list.length || actualIndex < 0) return list
const clone = cloneList(list)
clone[actualIndex] = replaceFn(clone[actualIndex])
return clone
}
export const adjust = curry(adjustFn)
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)
})
const R = require('../../dist/rambda.js')
const list = [0, 1, 2]
const fn = x => x + 1
const index = 1
const adjust = [
{
label: 'Rambda',
fn: () => {
R.adjust(index, fn, list)
R.adjust(index, fn)(list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.adjust(index, fn, list)
Ramda.adjust(index, fn)(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.
all<T>(predicate: (x: T) => boolean, list: T[]): boolean;
all<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
export function all(predicate, list) {
if (arguments.length === 1) return _list => all(predicate, _list)
for (let i = 0; i < list.length; i++) {
if (!predicate(list[i])) return false
}
return true
}
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()
})
import {all} from 'rambda'
describe('all', () => {
it('happy', () => {
const result = all(
x => {
x // $ExpectType number
return x > 0
},
[1, 2, 3]
)
result // $ExpectType boolean
})
it('curried needs a type', () => {
const result = all<number>(x => {
x // $ExpectType number
return x > 0
})([1, 2, 3])
result // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const {
uniqListOfObjects,
uniqListOfStrings,
rangeOfNumbers,
uniqListOfLists,
} = require('./_utils.js')
const limit = 100
const modes = [
[uniqListOfObjects(limit), x => Object.keys(x).length > 2],
[uniqListOfStrings(limit), x => x.length > 0],
[uniqListOfLists(limit), x => x.length > 0],
[rangeOfNumbers(limit), x => x > -1],
]
const applyBenchmark = (fn, input) => {
return fn(input[1], input[0])
}
const tests = [
{
label: 'Rambda',
fn: R.all,
},
{
label: 'Ramda',
fn: Ramda.all,
},
]
allPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean
It returns true, if all functions of predicates return true, when input is their argument.
allPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
export function allPass(predicates) {
return (...input) => {
let counter = 0
while (counter < predicates.length) {
if (!predicates[counter](...input)) {
return false
}
counter++
}
return true
}
}
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()
})
test('works with multiple inputs', () => {
var fn = function (w, x, y, z) {
return w + x === y + z
}
expect(allPass([fn])(3, 3, 3, 3)).toBeTrue()
})
import {allPass} from 'rambda'
describe('allPass', () => {
it('happy', () => {
const x = allPass<number>([
y => {
y // $ExpectType number
return typeof y === 'number'
},
y => {
return y > 0
},
])(11)
x // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const {random} = require('rambdax')
const limit = 100
const min = 10
const max = 1200
function createListOfFunctions(fn, fnLimit) {
return Array(fnLimit)
.fill(null)
.map(() => fn())
}
const modes = [
[
{foo: 1500},
createListOfFunctions(
() => x => Number(x.foo) > random(min, max),
limit
),
],
[
'1500',
createListOfFunctions(() => x => Number(x) > random(min, max), limit),
],
[
[1, 2, 1500],
createListOfFunctions(() => x => x[2] > random(min, max), limit),
],
[1500, createListOfFunctions(() => x => x > random(min, max), limit)],
]
const applyBenchmark = (fn, input) => {
return fn(input[1])(input[0])
}
const tests = [
{
label: 'Rambda',
fn: R.allPass,
},
{
label: 'Ramda',
fn: Ramda.allPass,
},
]
always<T>(x: T): (...args: unknown[]) => T
It returns function that always returns x.
always<T>(x: T): (...args: unknown[]) => T;
export function always(x) {
return () => x
}
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()
})
import {always} from 'rambda'
describe('R.always', () => {
it('happy', () => {
const fn = always('foo')
fn // $ExpectType (...args: unknown[]) => string
const result = fn()
result // $ExpectType string
})
})
Logical AND
any<T>(predicate: (x: T) => boolean, list: T[]): boolean
It returns true, if at least one member of list returns true, when passed to a predicate function.
any<T>(predicate: (x: T) => boolean, list: T[]): boolean;
any<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
export function any(predicate, list) {
if (arguments.length === 1) return _list => any(predicate, _list)
let counter = 0
while (counter < list.length) {
if (predicate(list[counter], counter)) {
return true
}
counter++
}
return false
}
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()
})
import {any} from 'rambda'
describe('R.any', () => {
it('happy', () => {
const result = any(
x => {
x // $ExpectType number
return x > 2
},
[1, 2, 3]
)
result // $ExpectType boolean
})
it('when curried needs a type', () => {
const result = any<number>(x => {
x // $ExpectType number
return x > 2
})([1, 2, 3])
result // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const input = [1, 2, 3, 4]
const fn = val => val > 2
const any = [
{
label: 'Rambda',
fn: () => {
R.any(fn, input)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.any(fn, input)
},
},
{
label: 'Lodash.some',
fn: () => {
_.some(input, fn)
},
},
]
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.
anyPass<T>(predicates: SafePred<T>[]): SafePred<T>;
export function anyPass(predicates) {
return (...input) => {
let counter = 0
while (counter < predicates.length) {
if (predicates[counter](...input)) {
return true
}
counter++
}
return false
}
}
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('with empty predicates list', () => {
expect(anyPass([])(3)).toEqual(false)
})
test('works with multiple inputs', () => {
var fn = function (w, x, y, z) {
console.log(w, x, y, z)
return w + x === y + z
}
expect(anyPass([fn])(3, 3, 3, 3)).toBeTrue()
})
import {anyPass} from 'rambda'
describe('anyPass', () => {
it('happy', () => {
const x = anyPass<number>([
y => {
y // $ExpectType number
return typeof y === 'number'
},
y => {
return y > 0
},
])(11)
x // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const rules = [x => typeof x === 'boolean', x => x > 20, x => x * 7 < 100]
const anyPass = [
{
label: 'Rambda',
fn: () => {
R.anyPass(rules)(11)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.anyPass(rules)(11)
},
},
]
append<T>(x: T, list: T[]): T[]
It adds element x at the end of list.
append<T>(x: T, list: T[]): T[];
append<T>(x: T): <T>(list: T[]) => T[];
import {cloneList} from './_internals/cloneList'
export function append(x, input) {
if (arguments.length === 1) return _input => append(x, _input)
if (typeof input === 'string') return input.split('').concat(x)
const clone = cloneList(input)
clone.push(x)
return clone
}
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'])
})
import {append} from 'rambda'
const list = [1, 2, 3]
describe('R.append', () => {
it('happy', () => {
const result = append(4, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = append(4)(list)
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const append = [
{
label: 'Rambda',
fn: () => {
R.append(0)([1, 2, 3, 4])
R.append('bar')('foo')
},
},
{
label: 'Ramda',
fn: () => {
Ramda.append(0)([1, 2, 3, 4])
Ramda.append('bar')('foo')
},
},
]
apply<T = any>(fn: (...args: any[]) => T, args: any[]): T
It applies function fn to the list of arguments.
This is useful for creating a fixed-arity function from a variadic function. fn should be a bound function if context is significant.
apply<T = any>(fn: (...args: any[]) => T, args: any[]): T;
apply<T = any>(fn: (...args: any[]) => T): (args: any[]) => T;
export function apply(fn, args) {
if (arguments.length === 1) {
return _args => apply(fn, _args)
}
return fn.apply(this, args)
}
import {apply} from './apply'
import {bind} from './bind'
import {identity} from './identity'
test('happy', () => {
expect(apply(identity, [1, 2, 3])).toEqual(1)
})
test('applies function to argument list', function () {
expect(apply(Math.max, [1, 2, 3, -99, 42, 6, 7])).toEqual(42)
})
test('provides no way to specify context', function () {
const obj = {
method: function () {
return this === obj
},
}
expect(apply(obj.method, [])).toEqual(false)
expect(apply(bind(obj.method, obj), [])).toEqual(true)
})
import {apply, identity} from 'rambda'
describe('R.apply', () => {
it('happy', () => {
const result = apply<number>(identity, [1, 2, 3])
result // $ExpectType number
})
it('curried', () => {
const fn = apply<number>(identity)
const result = fn([1, 2, 3])
result // $ExpectType number
})
})
applySpec<Spec extends Record<string, (...args: any[]) => any>>(
spec: Spec
): (
...args: Parameters<ValueOfRecord<Spec>>
) => { [Key in keyof Spec]: ReturnType<Spec[Key]> }
applySpec<Spec extends Record<string, (...args: any[]) => any>>(
spec: Spec
): (
...args: Parameters<ValueOfRecord<Spec>>
) => { [Key in keyof Spec]: ReturnType<Spec[Key]> };
applySpec<T>(spec: any): (...args: any[]) => T;
import {_isArray} from './_internals/_isArray'
// recursively traverse the given spec object to find the highest arity function
function __findHighestArity(spec, max = 0) {
for (const key in spec) {
if (spec.hasOwnProperty(key) === false || key === 'constructor') continue
if (typeof spec[key] === 'object') {
max = Math.max(max, __findHighestArity(spec[key]))
}
if (typeof spec[key] === 'function') {
max = Math.max(max, spec[key].length)
}
}
return max
}
function __filterUndefined() {
const defined = []
let i = 0
const l = arguments.length
while (i < l) {
if (typeof arguments[i] === 'undefined') break
defined[i] = arguments[i]
i++
}
return defined
}
function __applySpecWithArity(spec, arity, cache) {
const remaining = arity - cache.length
if (remaining === 1)
return x =>
__applySpecWithArity(spec, arity, __filterUndefined(...cache, x))
if (remaining === 2)
return (x, y) =>
__applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y))
if (remaining === 3)
return (x, y, z) =>
__applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y, z))
if (remaining === 4)
return (x, y, z, a) =>
__applySpecWithArity(
spec,
arity,
__filterUndefined(...cache, x, y, z, a)
)
if (remaining > 4)
return (...args) =>
__applySpecWithArity(spec, arity, __filterUndefined(...cache, ...args))
// handle spec as Array
if (_isArray(spec)) {
const ret = []
let i = 0
const l = spec.length
for (; i < l; i++) {
// handle recursive spec inside array
if (typeof spec[i] === 'object' || _isArray(spec[i])) {
ret[i] = __applySpecWithArity(spec[i], arity, cache)
}
// apply spec to the key
if (typeof spec[i] === 'function') {
ret[i] = spec[i](...cache)
}
}
return ret
}
// handle spec as Object
const ret = {}
// apply callbacks to each property in the spec object
for (const key in spec) {
if (spec.hasOwnProperty(key) === false || key === 'constructor') continue
// apply the spec recursively
if (typeof spec[key] === 'object') {
ret[key] = __applySpecWithArity(spec[key], arity, cache)
continue
}
// apply spec to the key
if (typeof spec[key] === 'function') {
ret[key] = spec[key](...cache)
}
}
return ret
}
export function applySpec(spec, ...args) {
// get the highest arity spec function, cache the result and pass to __applySpecWithArity
const arity = __findHighestArity(spec)
if (arity === 0) {
return () => ({})
}
const toReturn = __applySpecWithArity(spec, arity, args)
return toReturn
}
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('cannot retains the highest arity', () => {
const f = applySpec({
f1: nAry(2, T),
f2: nAry(5, T),
})
const fRamda = applySpecRamda({
f1: nAry(2, T),
f2: nAry(5, T),
})
expect(f.length).toBe(0)
expect(fRamda.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',
})
})
import {multiply, applySpec, inc, dec, add} from 'rambda'
describe('applySpec', () => {
it('ramda 1', () => {
const result = applySpec({
v: inc,
u: dec,
})(1)
result // $ExpectType { v: number; u: number; }
})
it('ramda 1', () => {
interface Output {
sum: number
multiplied: number
}
const result = applySpec<Output>({
sum: add,
multiplied: multiply,
})(1, 2)
result // $ExpectType Output
})
})
const R = require('../../dist/rambda.js')
const curryN = [
{
label: 'Rambda',
fn: () => {
const data = {
a: {
b: {c: 1},
d: 2,
},
}
const spec = {
c: R.path(['a', 'b', 'c']),
d: R.path(['a', 'd']),
}
R.applySpec(spec, data)
},
},
{
label: 'Ramda',
fn: () => {
const data = {
a: {
b: {c: 1},
d: 2,
},
}
const spec = {
c: Ramda.path(['a', 'b', 'c']),
d: Ramda.path(['a', 'd']),
}
Ramda.applySpec(spec, data)
},
},
]
assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & Omit<U, K>
It makes a shallow clone of obj with setting or overriding the property prop with newValue.
assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & Omit<U, K>;
assoc<T, K extends string>(prop: K, val: T): <U>(obj: U) => Record<K, T> & Omit<U, K>;
assoc<K extends string>(prop: K): AssocPartialOne<K>;
import {curry} from './curry'
function assocFn(prop, newValue, obj) {
return Object.assign({}, obj, {[prop]: newValue})
}
export const assoc = curry(assocFn)
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}})
})
import {assoc} from 'rambda'
const obj = {a: 1}
const newValue = 2
const newProp = 'b'
describe('R.assoc', () => {
it('happy', () => {
const result = assoc(newProp, newValue, obj)
result.a // $ExpectType number
result.b // $ExpectType number
})
it('curried 1', () => {
const result = assoc(newProp, newValue)(obj)
result.a // $ExpectType number
result.b // $ExpectType number
})
it('curried 2', () => {
const result = assoc(newProp)(newValue)(obj)
result.a // $ExpectType number
result.b // $ExpectType number
})
})
const R = require('../../dist/rambda.js')
const input = {
a: 1,
b: 2,
}
const key = 'c'
const value = 3
const assoc = [
{
label: 'Rambda',
fn: () => {
R.assoc(key, value, input)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.assoc(key, value, input)
},
},
{
label: 'Lodash.set',
fn: () => {
_.set(input, key, value)
},
},
]
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.
assocPath<Output>(path: Path, newValue: any, obj: object): Output;
assocPath<Output>(path: Path, newValue: any): (obj: object) => Output;
assocPath<Output>(path: Path): (newValue: any) => (obj: object) => Output;
import {_isArray} from './_internals/_isArray'
import {_isInteger} from './_internals/_isInteger'
import {assoc} from './assoc'
import {curry} from './curry'
import {cloneList} from './_internals/cloneList'
function assocPathFn(path, newValue, input) {
const pathArrValue =
typeof path === 'string'
? path.split('.').map(x => (_isInteger(Number(x)) ? Number(x) : x))
: path
if (pathArrValue.length === 0) {
return newValue
}
const index = pathArrValue[0]
if (pathArrValue.length > 1) {
const condition =
typeof input !== 'object' ||
input === null ||
!input.hasOwnProperty(index)
const nextinput = condition
? _isInteger(pathArrValue[1])
? []
: {}
: input[index]
newValue = assocPathFn(
Array.prototype.slice.call(pathArrValue, 1),
newValue,
nextinput
)
}
if (_isInteger(index) && _isArray(input)) {
const arr = cloneList(input)
arr[index] = newValue
return arr
}
return assoc(index, newValue, input)
}
export const assocPath = curry(assocPathFn)
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)
})
import {assocPath} from 'rambda'
interface Output {
a: number
foo: {bar: number}
}
describe('R.assocPath - user must explicitly set type of output', () => {
it('with array as path input', () => {
const result = assocPath<Output>(['foo', 'bar'], 2, {a: 1})
result // $ExpectType Output
})
it('with string as path input', () => {
const result = assocPath<Output>('foo.bar', 2, {a: 1})
result // $ExpectType Output
})
})
describe('R.assocPath - curried', () => {
it('with array as path input', () => {
const result = assocPath<Output>(['foo', 'bar'], 2)({a: 1})
result // $ExpectType Output
})
it('with string as path input', () => {
const result = assocPath<Output>('foo.bar', 2)({a: 1})
result // $ExpectType Output
})
})
bind<F extends (...args: any[]) => any, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>
Creates a function that is bound to a context.
bind<F extends (...args: any[]) => any, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>;
bind<F extends (...args: any[]) => any, T>(fn: F): (thisObj: T) => (...args: Parameters<F>) => ReturnType<F>;
import {curryN} from './curryN'
export function bind(fn, thisObj) {
if (arguments.length === 1) {
return _thisObj => bind(fn, _thisObj)
}
return curryN(fn.length, (...args) => fn.apply(thisObj, args))
}
import {bind} from './bind'
function Foo(x) {
this.x = x
}
function add(x) {
return this.x + x
}
function Bar(x, y) {
this.x = x
this.y = y
}
Bar.prototype = new Foo()
Bar.prototype.getX = function () {
return 'prototype getX'
}
test('returns a function', function () {
expect(typeof bind(add)(Foo)).toEqual('function')
})
test('returns a function bound to the specified context object', function () {
const f = new Foo(12)
function isFoo() {
return this instanceof Foo
}
const isFooBound = bind(isFoo, f)
expect(isFoo()).toEqual(false)
expect(isFooBound()).toEqual(true)
})
test('works with built-in types', function () {
const abc = bind(String.prototype.toLowerCase, 'ABCDEFG')
expect(typeof abc).toEqual('function')
expect(abc()).toEqual('abcdefg')
})
test('works with user-defined types', function () {
const f = new Foo(12)
function getX() {
return this.x
}
const getXFooBound = bind(getX, f)
expect(getXFooBound()).toEqual(12)
})
test('works with plain objects', function () {
const pojso = {
x: 100,
}
function incThis() {
return this.x + 1
}
const incPojso = bind(incThis, pojso)
expect(typeof incPojso).toEqual('function')
expect(incPojso()).toEqual(101)
})
test('does not interfere with existing object methods', function () {
const b = new Bar('a', 'b')
function getX() {
return this.x
}
const getXBarBound = bind(getX, b)
expect(b.getX()).toEqual('prototype getX')
expect(getXBarBound()).toEqual('a')
})
test('preserves arity', function () {
const f0 = function () {
return 0
}
const f1 = function (a) {
return a
}
const f2 = function (a, b) {
return a + b
}
const f3 = function (a, b, c) {
return a + b + c
}
expect(bind(f0, {}).length).toEqual(0)
expect(bind(f1, {}).length).toEqual(1)
expect(bind(f2, {}).length).toEqual(2)
expect(bind(f3, {}).length).toEqual(3)
})
import {bind} from 'rambda'
class Foo {}
function isFoo<T = any>(this: T): boolean {
return this instanceof Foo
}
describe('R.bind', () => {
it('happy', () => {
const foo = new Foo()
const result = bind(isFoo, foo)()
result // $ExpectType boolean
})
})
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.
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;
export function both(f, g) {
if (arguments.length === 1) return _g => both(f, _g)
return (...input) => f(...input) && g(...input)
}
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')
})
import {both} from 'rambda'
describe('R.both', () => {
it('with passed type', () => {
const fn = both<number>(
x => x > 1,
x => x % 2 === 0
)
fn // $ExpectType Predicate<number>
const result = fn(2) // $ExpectType boolean
result // $ExpectType boolean
})
it('with passed type - curried', () => {
const fn = both<number>(x => x > 1)(x => x % 2 === 0)
fn // $ExpectType Predicate<number>
const result = fn(2)
result // $ExpectType boolean
})
it('no type passed', () => {
const fn = both(
x => {
x // $ExpectType any
return x > 1
},
x => {
x // $ExpectType any
return x % 2 === 0
}
)
const result = fn(2)
result // $ExpectType boolean
})
it('no type passed - curried', () => {
const fn = both((x: number) => {
x // $ExpectType number
return x > 1
})((x: number) => {
x // $ExpectType number
return x % 2 === 0
})
const result = fn(2)
result // $ExpectType boolean
})
})
chain<T, U>(fn: (n: T) => U[], list: T[]): U[]
The method is also known as flatMap.
chain<T, U>(fn: (n: T) => U[], list: T[]): U[];
chain<T, U>(fn: (n: T) => U[]): (list: T[]) => U[];
export function chain(fn, list) {
if (arguments.length === 1) {
return _list => chain(fn, _list)
}
return [].concat(...list.map(fn))
}
import {chain} from './chain'
import {chain as chainRamda} from 'ramda'
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]])
})
test('can compose', () => {
function dec(x) {
return [x - 1]
}
function times2(x) {
return [x * 2]
}
var mdouble = chain(times2)
var mdec = chain(dec)
expect(mdec(mdouble([10, 20, 30]))).toEqual([19, 39, 59])
})
test('@types/ramda broken test', () => {
const score = {
maths: 90,
physics: 80,
}
const calculateTotal = score => {
const {maths, physics} = score
return maths + physics
}
const assocTotalToScore = (total, score) => ({...score, total})
const calculateAndAssocTotalToScore = chainRamda(
assocTotalToScore,
calculateTotal
)
expect(() => calculateAndAssocTotalToScore(score)).toThrow()
})
import {chain} from 'rambda'
const list = [1, 2, 3]
const fn = (x: number) => [`${x}`, `${x}`]
describe('R.chain', () => {
it('without passing type', () => {
const result = chain(fn, list)
result // $ExpectType string[]
const curriedResult = chain(fn)(list)
curriedResult // $ExpectType string[]
})
})
Restrict a number input to be within 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.
It creates a deep copy of the input, which may contain (nested) Arrays and Objects, Numbers, Strings, Booleans and Dates.
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).
It performs right-to-left function composition.
It returns a new string or array, which is the result of merging x and y.
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.
Accepts a converging function and a list of branching functions and returns a new function. When invoked, this new function is applied to some arguments, each branching function is applied to those same arguments. The results of each branching function are passed as arguments to the converging function to produce the return value.
It expects a function as input and returns its curried version.
It returns a curried equivalent of the provided function, with the specified arity.
It decrements a number.
defaultTo<T>(defaultValue: T, input: 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).
defaultTo<T>(defaultValue: T, input: T | null | undefined): T;
defaultTo<T>(defaultValue: T): (input: T | null | undefined) => T;
function isFalsy(input) {
return (
input === undefined || input === null || Number.isNaN(input) === true
)
}
export function defaultTo(defaultArgument, input) {
if (arguments.length === 1) {
return _input => defaultTo(defaultArgument, _input)
}
return isFalsy(input) ? defaultArgument : input
}
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')
})
import {defaultTo} from 'rambda'
describe('R.defaultTo with Ramda spec', () => {
it('happy', () => {
const result = defaultTo('foo', '')
result // $ExpectType "" | "foo"
})
it('with explicit type', () => {
const result = defaultTo<string>('foo', null)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const input = [null, undefined, 5]
const defaultTo = [
{
label: 'Rambda',
fn: () => {
R.defaultTo(3, input[0])
},
},
{
label: 'Ramda',
fn: () => {
Ramda.defaultTo(3, input[0])
},
},
{
label: 'Rambda with multiple arguments',
fn: () => {
R.defaultTo(3, ...input)
},
},
]
difference<T>(a: T[], b: T[]): T[]
It returns the uniq set of all elements in the first list a not contained in the second list b.
R.equals is used to determine equality.
difference<T>(a: T[], b: T[]): T[];
difference<T>(a: T[]): (b: T[]) => T[];
import {includes} from './includes'
import {uniq} from './uniq'
export function difference(a, b) {
if (arguments.length === 1) return _b => difference(a, _b)
return uniq(a).filter(aInstance => !includes(aInstance, b))
}
import {difference} from './difference'
import {difference as differenceRamda} from 'ramda'
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([1], [1]).length).toEqual(0)
expect(differenceRamda([NaN], [NaN]).length).toEqual(0)
})
import {difference} from 'rambda'
const list1 = [1, 2, 3]
const list2 = [1, 2, 4]
describe('R.difference', () => {
it('happy', () => {
const result = difference(list1, list2)
result // $ExpectType number[]
})
it('curried', () => {
const result = difference(list1)(list2)
result // $ExpectType number[]
})
})
It returns a new object that does not contain property prop.
drop<T>(howMany: number, input: T[]): T[]
It returns howMany items dropped from beginning of list or string input.
drop<T>(howMany: number, input: T[]): T[];
drop(howMany: number, input: string): string;
drop<T>(howMany: number): {
<T>(input: T[]): T[];
(input: string): string;
};
export function drop(howManyToDrop, listOrString) {
if (arguments.length === 1) return _list => drop(howManyToDrop, _list)
return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0)
}
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)
})
import {drop} from 'rambda'
const list = [1, 2, 3, 4]
const str = 'foobar'
const howMany = 2
describe('R.drop - array', () => {
it('happy', () => {
const result = drop(howMany, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = drop(howMany)(list)
result // $ExpectType number[]
})
})
describe('R.drop - string', () => {
it('happy', () => {
const result = drop(howMany, str)
result // $ExpectType string
})
it('curried', () => {
const result = drop(howMany)(str)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const input = [1, 2, 3, 4]
const drop = [
{
label: 'Rambda',
fn: () => {
R.drop(3, input)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.drop(3, input)
},
},
]
dropLast<T>(howMany: number, input: T[]): T[]
It returns howMany items dropped from the end of list or string input.
dropLast<T>(howMany: number, input: T[]): T[];
dropLast(howMany: number, input: string): string;
dropLast<T>(howMany: number): {
<T>(input: T[]): T[];
(input: string): string;
};
export function dropLast(howManyToDrop, listOrString) {
if (arguments.length === 1) {
return _listOrString => dropLast(howManyToDrop, _listOrString)
}
return howManyToDrop > 0
? listOrString.slice(0, -howManyToDrop)
: listOrString.slice()
}
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)
})
import {dropLast} from 'rambda'
const list = [1, 2, 3, 4]
const str = 'foobar'
const howMany = 2
describe('R.dropLast - array', () => {
it('happy', () => {
const result = dropLast(howMany, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = dropLast(howMany)(list)
result // $ExpectType number[]
})
})
describe('R.dropLast - string', () => {
it('happy', () => {
const result = dropLast(howMany, str)
result // $ExpectType string
})
it('curried', () => {
const result = dropLast(howMany)(str)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const input = [1, 2, 3, 4]
const dropLast = [
{
label: 'Rambda',
fn: () => {
R.dropLast(3, input)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.dropLast(3, input)
},
},
]
dropRepeats<T>(list: T[]): T[]
It removes any successive duplicates according to R.equals.
dropRepeats<T>(list: T[]): T[];
import {_isArray} from './_internals/_isArray'
import {equals} from './equals'
export function dropRepeats(list) {
if (!_isArray(list)) {
throw new Error(`${list} is not a list`)
}
const toReturn = []
list.reduce((prev, current) => {
if (!equals(prev, current)) {
toReturn.push(current)
}
return current
}, undefined)
return toReturn
}
import {dropRepeats as dropRepeatsRamda} from 'ramda'
import {compareCombinations} from './_internals/testUtils'
import {add} from './add'
import {dropRepeats} from './dropRepeats'
const list = [1, 2, 2, 2, 3, 4, 4, 5, 5, 3, 2, 2, {a: 1}, {a: 1}]
const listClean = [1, 2, 3, 4, 5, 3, 2, {a: 1}]
test('happy', () => {
const result = dropRepeats(list)
expect(result).toEqual(listClean)
})
const possibleLists = [
[add(1), async () => {}, [1], [1], [2], [2]],
[add(1), add(1), add(2)],
[],
1,
/foo/g,
Promise.resolve(1),
]
describe('brute force', () => {
compareCombinations({
firstInput: possibleLists,
callback: errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 0,
"RESULTS_MISMATCH": 1,
"SHOULD_NOT_THROW": 3,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 6,
}
`)
},
fn: dropRepeats,
fnRamda: dropRepeatsRamda,
})
})
import {dropRepeats} from 'rambda'
describe('R.dropRepeats', () => {
it('happy', () => {
const result = dropRepeats([1, 2, 2, 3])
result // $ExpectType number[]
})
})
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.
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;
export function either(firstPredicate, secondPredicate) {
if (arguments.length === 1) {
return _secondPredicate => either(firstPredicate, _secondPredicate)
}
return (...input) =>
Boolean(firstPredicate(...input) || secondPredicate(...input))
}
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()
})
import {either} from 'rambda'
describe('R.either', () => {
it('with passed type', () => {
const fn = either<number>(
x => x > 1,
x => x % 2 === 0
)
fn // $ExpectType Predicate<number>
const result = fn(2) // $ExpectType boolean
result // $ExpectType boolean
})
it('with passed type - curried', () => {
const fn = either<number>(x => x > 1)(x => x % 2 === 0)
fn // $ExpectType Predicate<number>
const result = fn(2)
result // $ExpectType boolean
})
it('no type passed', () => {
const fn = either(
x => {
x // $ExpectType any
return x > 1
},
x => {
x // $ExpectType any
return x % 2 === 0
}
)
const result = fn(2)
result // $ExpectType boolean
})
it('no type passed - curried', () => {
const fn = either((x: number) => {
x // $ExpectType number
return x > 1
})((x: number) => {
x // $ExpectType number
return x % 2 === 0
})
const result = fn(2)
result // $ExpectType boolean
})
})
endsWith(target: string, iterable: string): boolean
When iterable is a string, then it behaves as String.prototype.endsWith.
When iterable is a list, then it uses R.equals to determine if the target list ends in the same way as the given target.
endsWith(target: string, iterable: string): boolean;
endsWith(target: string): (iterable: string) => boolean;
endsWith<T>(target: T[], list: T[]): boolean;
endsWith<T>(target: T[]): (list: T[]) => boolean;
import {equals} from './equals.js'
import {_isArray} from './_internals/_isArray.js'
export function endsWith(target, iterable) {
if (arguments.length === 1) return _iterable => endsWith(target, _iterable)
if (typeof iterable === 'string') {
return iterable.endsWith(target)
}
if (!_isArray(target)) return false
const diff = iterable.length - target.length
let correct = true
const filtered = target.filter((x, index) => {
if (!correct) return false
const result = equals(x, iterable[index + diff])
if (!result) correct = false
return result
})
return filtered.length === target.length
}
import {endsWith} from './endsWith'
import {endsWith as endsWithRamda} from 'ramda'
import {compareCombinations} from './_internals/testUtils'
test('with string', () => {
expect(endsWith('bar', 'foo-bar')).toBeTrue()
expect(endsWith('baz')('foo-bar')).toBeFalse()
})
test('use R.equals with array', () => {
const list = [{a: 1}, {a: 2}, {a: 3}]
expect(endsWith({a: 3}, list)).toBeFalse(),
expect(endsWith([{a: 3}], list)).toBeTrue()
expect(endsWith([{a: 2}, {a: 3}], list)).toBeTrue()
expect(endsWith(list, list)).toBeTrue()
expect(endsWith([{a: 1}], list)).toBeFalse()
})
export const possibleTargets = [
NaN,
[NaN],
/foo/,
[/foo/],
Promise.resolve(1),
[Promise.resolve(1)],
Error('foo'),
[Error('foo')],
]
export const possibleIterables = [
[Promise.resolve(1), Promise.resolve(2)],
[/foo/, /bar/],
[NaN],
[Error('foo'), Error('bar')],
]
describe('brute force', () => {
compareCombinations({
fn: endsWith,
fnRamda: endsWithRamda,
firstInput: possibleTargets,
secondInput: possibleIterables,
callback: errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 0,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 0,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 32,
}
`)
},
})
})
import {endsWith} from 'rambda'
describe('R.endsWith - array as iterable', () => {
const target = [{a: 2}]
const iterable = [{a: 1}, {a: 2}]
it('happy', () => {
const result = endsWith(target, iterable)
result // $ExpectType boolean
})
it('curried', () => {
const result = endsWith(target)(iterable)
result // $ExpectType boolean
})
})
describe('R.endsWith - string as iterable', () => {
const target = 'bar'
const iterable = 'foo bar'
it('happy', () => {
const result = endsWith(target, iterable)
result // $ExpectType boolean
})
it('curried', () => {
const result = endsWith(target)(iterable)
result // $ExpectType boolean
})
})
It returns true if property prop in obj1 is equal to property prop in obj2 according to R.equals.
equals<T>(x: T, y: T): boolean
It deeply compares x and y and returns true if they are equal.
equals<T>(x: T, y: T): boolean;
equals<T>(x: T): (y: T) => boolean;
import {type} from './type'
import {_isArray} from './_internals/_isArray'
export function _lastIndexOf(valueToFind, list) {
if (!_isArray(list)) {
throw new Error(`Cannot read property 'indexOf' of ${list}`)
}
const typeOfValue = type(valueToFind)
if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue))
return list.lastIndexOf(valueToFind)
const {length} = list
let index = length
let foundIndex = -1
while (--index > -1 && foundIndex === -1) {
if (equals(list[index], valueToFind)) {
foundIndex = index
}
}
return foundIndex
}
export function _indexOf(valueToFind, list) {
if (!_isArray(list)) {
throw new Error(`Cannot read property 'indexOf' of ${list}`)
}
const typeOfValue = type(valueToFind)
if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue))
return list.indexOf(valueToFind)
let index = -1
let foundIndex = -1
const {length} = list
while (++index < length && foundIndex === -1) {
if (equals(list[index], valueToFind)) {
foundIndex = index
}
}
return foundIndex
}
function _arrayFromIterator(iter) {
const list = []
let next
while (!(next = iter.next()).done) {
list.push(next.value)
}
return list
}
function _equalsSets(a, b) {
if (a.size !== b.size) {
return false
}
const aList = _arrayFromIterator(a.values())
const bList = _arrayFromIterator(b.values())
const filtered = aList.filter(
aInstance => _indexOf(aInstance, bList) === -1
)
return filtered.length === 0
}
function parseError(maybeError) {
const typeofError = maybeError.__proto__.toString()
if (!['Error', 'TypeError'].includes(typeofError)) return []
return [typeofError, maybeError.message]
}
function parseDate(maybeDate) {
if (!maybeDate.toDateString) return [false]
return [true, maybeDate.getTime()]
}
function parseRegex(maybeRegex) {
if (maybeRegex.constructor !== RegExp) return [false]
return [true, maybeRegex.toString()]
}
function equalsSets(a, b) {
if (a.size !== b.size) {
return false
}
const aList = _arrayFromIterator(a.values())
const bList = _arrayFromIterator(b.values())
const filtered = aList.filter(
aInstance => _indexOf(aInstance, bList) === -1
)
return filtered.length === 0
}
export function equals(a, b) {
if (arguments.length === 1) return _b => equals(a, _b)
const aType = type(a)
if (aType !== type(b)) return false
if (aType === 'Function') {
return a.name === undefined ? false : a.name === b.name
}
if (['NaN', 'Undefined', 'Null'].includes(aType)) return true
if (aType === 'Number') {
if (Object.is(-0, a) !== Object.is(-0, b)) return false
return a.toString() === b.toString()
}
if (['String', 'Boolean'].includes(aType)) {
return a.toString() === b.toString()
}
if (aType === 'Array') {
const aClone = Array.from(a)
const bClone = Array.from(b)
if (aClone.toString() !== bClone.toString()) {
return false
}
let loopArrayFlag = true
aClone.forEach((aCloneInstance, aCloneIndex) => {
if (loopArrayFlag) {
if (
aCloneInstance !== bClone[aCloneIndex] &&
!equals(aCloneInstance, bClone[aCloneIndex])
) {
loopArrayFlag = false
}
}
})
return loopArrayFlag
}
const aRegex = parseRegex(a)
const bRegex = parseRegex(b)
if (aRegex[0]) {
return bRegex[0] ? aRegex[1] === bRegex[1] : false
} else if (bRegex[0]) return false
const aDate = parseDate(a)
const bDate = parseDate(b)
if (aDate[0]) {
return bDate[0] ? aDate[1] === bDate[1] : false
} else if (bDate[0]) return false
const aError = parseError(a)
const bError = parseError(b)
if (aError[0]) {
return bError[0]
? aError[0] === bError[0] && aError[1] === bError[1]
: false
}
if (aType === 'Set') {
return _equalsSets(a, b)
}
if (aType === 'Object') {
const aKeys = Object.keys(a)
if (aKeys.length !== Object.keys(b).length) {
return false
}
let loopObjectFlag = true
aKeys.forEach(aKeyInstance => {
if (loopObjectFlag) {
const aValue = a[aKeyInstance]
const bValue = b[aKeyInstance]
if (aValue !== bValue && !equals(aValue, bValue)) {
loopObjectFlag = false
}
}
})
return loopObjectFlag
}
return false
}
import {equals} from './equals'
import {equals as equalsRamda} from 'ramda'
import {compareCombinations} from './_internals/testUtils'
import {variousTypes} from './benchmarks/_utils'
test('compare functions', () => {
function foo() {}
function bar() {}
const baz = () => {}
const expectTrue = equals(foo, foo)
const expectFalseFirst = equals(foo, bar)
const expectFalseSecond = equals(foo, baz)
expect(expectTrue).toBeTrue()
expect(expectFalseFirst).toBeFalse()
expect(expectFalseSecond).toBeFalse()
})
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('compare sets', () => {
const toCompareDifferent = new Set([{a: 1}, {a: 2}])
const toCompareSame = new Set([{a: 1}, {a: 2}, {a: 1}])
const testSet = new Set([{a: 1}, {a: 2}, {a: 1}])
expect(equals(toCompareSame, testSet)).toBeTruthy()
expect(equals(toCompareDifferent, testSet)).toBeFalsy()
expect(equalsRamda(toCompareSame, testSet)).toBeTruthy()
expect(equalsRamda(toCompareDifferent, testSet)).toBeFalsy()
})
test('compare simple sets', () => {
const testSet = new Set(['2', '3', '3', '2', '1'])
expect(equals(new Set(['3', '2', '1']), testSet)).toBeTruthy()
expect(equals(new Set(['3', '2', '0']), testSet)).toBeFalsy()
})
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).toBeTrue()
})
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()
})
const possibleInputs = variousTypes
describe('brute force', () => {
compareCombinations({
fn: equals,
fnRamda: equalsRamda,
firstInput: possibleInputs,
secondInput: possibleInputs,
callback: errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 0,
"RESULTS_MISMATCH": 5,
"SHOULD_NOT_THROW": 4,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 289,
}
`)
},
})
})
import {equals} from 'rambda'
describe('R.equals', () => {
it('happy', () => {
const result = equals(4, 1)
result // $ExpectType boolean
})
it('with object', () => {
const foo = {a: 1}
const bar = {a: 2}
const result = equals(foo, bar)
result // $ExpectType boolean
})
it('curried', () => {
const result = equals(4)(1)
result // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const limit = 10000
const strings = Array(limit)
.fill(null)
.map(() => Math.floor(Math.random() * 1000))
const equals = [
{
label: 'Rambda',
fn: () => {
strings.forEach(x => R.equals(x, 'ss'))
},
},
{
label: 'Ramda',
fn: () => {
strings.forEach(x => Ramda.equals(x, 'ss'))
},
},
{
label: 'Lodash',
fn: () => {
strings.forEach(x => _.isEqual(x, 'ss'))
},
},
]
evolve<T, U>(rules: ((x: T) => U)[], list: T[]): U[]
It takes object or array of functions as set of rules. These rules are applied to the iterable input to produce the result.
evolve<T, U>(rules: ((x: T) => U)[], list: T[]): U[];
evolve<T, U>(rules: ((x: T) => U)[]) : (list: T[]) => U[];
evolve<E extends Evolver, V extends Evolvable<E>>(rules: E, obj: V): Evolve<V, E>;
evolve<E extends Evolver>(rules: E): <V extends Evolvable<E>>(obj: V) => Evolve<V, E>;
import {_isArray} from './_internals/_isArray'
import {mapArray, mapObject} from './map'
import {type} from './type'
export function evolveArray(rules, list) {
return mapArray(
(x, i) => {
if (type(rules[i]) === 'Function') {
return rules[i](x)
}
return x
},
list,
true
)
}
export function evolveObject(rules, iterable) {
return mapObject((x, prop) => {
if (type(x) === 'Object') {
const typeRule = type(rules[prop])
if (typeRule === 'Function') {
return rules[prop](x)
}
if (typeRule === 'Object') {
return evolve(rules[prop], x)
}
return x
}
if (type(rules[prop]) === 'Function') {
return rules[prop](x)
}
return x
}, iterable)
}
export function evolve(rules, iterable) {
if (arguments.length === 1) {
return _iterable => evolve(rules, _iterable)
}
const rulesType = type(rules)
const iterableType = type(iterable)
if (iterableType !== rulesType) {
throw new Error('iterableType !== rulesType')
}
if (!['Object', 'Array'].includes(rulesType)) {
throw new Error(
`'iterable' and 'rules' are from wrong type ${rulesType}`
)
}
if (iterableType === 'Object') {
return evolveObject(rules, iterable)
}
return evolveArray(rules, iterable)
}
import {evolve as evolveRamda} from 'ramda'
import {add} from '../rambda'
import {compareCombinations, compareToRamda} from './_internals/testUtils'
import {evolve} from './evolve'
test('happy', () => {
const rules = {
foo: add(1),
nested: {bar: x => Object.keys(x).length},
}
const input = {
a: 1,
foo: 2,
nested: {bar: {z: 3}},
}
const result = evolve(rules, input)
expect(result).toEqual({
a: 1,
foo: 3,
nested: {bar: 1},
})
})
test('nested rule is wrong', () => {
const rules = {
foo: add(1),
nested: {bar: 10},
}
const input = {
a: 1,
foo: 2,
nested: {bar: {z: 3}},
}
const result = evolve(rules)(input)
expect(result).toEqual({
a: 1,
foo: 3,
nested: {bar: {z: 3}},
})
})
test('is recursive', () => {
const rules = {
nested: {
second: add(-1),
third: add(1),
},
}
const object = {
first: 1,
nested: {
second: 2,
third: 3,
},
}
const expected = {
first: 1,
nested: {
second: 1,
third: 4,
},
}
const result = evolve(rules, object)
expect(result).toEqual(expected)
})
test('ignores primitive values', () => {
const rules = {
n: 2,
m: 'foo',
}
const object = {
n: 0,
m: 1,
}
const expected = {
n: 0,
m: 1,
}
const result = evolve(rules, object)
expect(result).toEqual(expected)
})
test('with array', () => {
const rules = [add(1), add(-1)]
const list = [100, 1400]
const expected = [101, 1399]
const result = evolve(rules, list)
expect(result).toEqual(expected)
})
const rulesObject = {a: add(1)}
const rulesList = [add(1)]
const possibleIterables = [null, undefined, '', 42, [], [1], {a: 1}]
const possibleRules = [...possibleIterables, rulesList, rulesObject]
describe('brute force', () => {
compareCombinations({
firstInput: possibleRules,
callback: errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 4,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 51,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 63,
}
`)
},
secondInput: possibleIterables,
fn: evolve,
fnRamda: evolveRamda,
})
})
import {evolve, add} from 'rambda'
describe('R.evolve', () => {
it('happy', () => {
const input = {
foo: 2,
nested: {
a: 1,
bar: 3,
},
}
const rules = {
foo: add(1),
nested: {
a: add(-1),
bar: add(1),
},
}
const result = evolve(rules, input)
const curriedResult = evolve(rules)(input)
result.nested.a // $ExpectType number
curriedResult.nested.a // $ExpectType number
result.nested.bar // $ExpectType number
result.foo // $ExpectType number
})
it('with array', () => {
const rules = [String, String]
const input = [100, 1400]
const result = evolve(rules, input)
const curriedResult = evolve(rules)(input)
result // $ExpectType string[]
curriedResult // $ExpectType string[]
})
})
F(): boolean
F(): boolean;
export function F() {
return false
}
filter<T>(predicate: Predicate<T>): (input: T[]) => T[]
It filters list or object input using a predicate function.
filter<T>(predicate: Predicate<T>): (input: T[]) => T[];
filter<T>(predicate: Predicate<T>, input: T[]): T[];
filter<T, U>(predicate: ObjectPredicate<T>): (x: Dictionary<T>) => Dictionary<T>;
filter<T>(predicate: ObjectPredicate<T>, x: Dictionary<T>): Dictionary<T>;
import {_isArray} from './_internals/_isArray'
export function filterObject(predicate, obj) {
const willReturn = {}
for (const prop in obj) {
if (predicate(obj[prop], prop, obj)) {
willReturn[prop] = obj[prop]
}
}
return willReturn
}
export function filterArray(predicate, list, indexed = false) {
let index = 0
const len = list.length
const willReturn = []
while (index < len) {
const predicateResult = indexed
? predicate(list[index], index)
: predicate(list[index])
if (predicateResult) {
willReturn.push(list[index])
}
index++
}
return willReturn
}
export function filter(predicate, iterable) {
if (arguments.length === 1)
return _iterable => filter(predicate, _iterable)
if (!iterable) {
throw new Error('Incorrect iterable input')
}
if (_isArray(iterable)) return filterArray(predicate, iterable, false)
return filterObject(predicate, iterable)
}
import {T} from './T'
import {filter} from './filter'
import {filter as filterRamda} from 'ramda'
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('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)
})
test('bad inputs difference between Ramda and Rambda', () => {
expect(() => filter(T, null)).toThrowWithMessage(
Error,
`Incorrect iterable input`
)
expect(() => filter(T)(undefined)).toThrowWithMessage(
Error,
`Incorrect iterable input`
)
expect(() => filterRamda(T, null)).toThrowWithMessage(
TypeError,
`Cannot read properties of null (reading 'filter')`
)
expect(() => filterRamda(T, undefined)).toThrowWithMessage(
TypeError,
`Cannot read properties of undefined (reading 'filter')`
)
})
import {filter} from 'rambda'
const list = [1, 2, 3]
const obj = {a: 1, b: 2}
describe('R.filter with array', () => {
it('happy', () => {
const result = filter<number>(x => {
x // $ExpectType number
return x > 1
}, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = filter<number>(x => {
x // $ExpectType number
return x > 1
})(list)
result // $ExpectType number[]
})
})
describe('R.filter with objects', () => {
it('happy', () => {
const result = filter<number>((val, prop, origin) => {
val // $ExpectType number
prop // $ExpectType string
origin // $ExpectType Dictionary<number>
return val > 1
}, obj)
result // $ExpectType Dictionary<number>
})
it('curried version requires second dummy type', () => {
const result = filter<number, any>((val, prop, origin) => {
val // $ExpectType number
prop // $ExpectType string
origin // $ExpectType Dictionary<number>
return val > 1
})(obj)
result // $ExpectType Dictionary<number>
})
})
const R = require('../../dist/rambda.js')
const arr = [1, 2, 3, 4]
const fn = x => x > 2
const filter = [
{
label: 'Rambda',
fn: () => {
R.filter(fn, arr)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.filter(fn, arr)
},
},
{
label: 'Lodash',
fn: () => {
_.filter(arr, fn)
},
},
]
find<T>(predicate: (x: T) => boolean, list: T[]): T | undefined
It returns the first element of list that satisfy the predicate.
If there is no such element, it returns undefined.
find<T>(predicate: (x: T) => boolean, list: T[]): T | undefined;
find<T>(predicate: (x: T) => boolean): (list: T[]) => T | undefined;
export function find(predicate, list) {
if (arguments.length === 1) return _list => find(predicate, _list)
let index = 0
const len = list.length
while (index < len) {
const x = list[index]
if (predicate(x)) {
return x
}
index++
}
}
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()
})
import {find} from 'rambda'
const list = [1, 2, 3]
describe('R.find', () => {
it('happy', () => {
const predicate = (x: number) => x > 2
const result = find(predicate, list)
result // $ExpectType number | undefined
})
it('curried', () => {
const predicate = (x: number) => x > 2
const result = find(predicate)(list)
result // $ExpectType number | undefined
})
})
const R = require('../../dist/rambda.js')
const fn = x => x > 2
const list = [1, 2, 3, 4]
const find = [
{
label: 'Rambda',
fn: () => {
R.find(fn, list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.find(fn, list)
},
},
{
label: 'Lodash',
fn: () => {
_.find(list, fn)
},
},
]
findIndex<T>(predicate: (x: T) => boolean, list: 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.
findIndex<T>(predicate: (x: T) => boolean, list: T[]): number;
findIndex<T>(predicate: (x: T) => boolean): (list: T[]) => number;
export function findIndex(predicate, list) {
if (arguments.length === 1) return _list => findIndex(predicate, _list)
const len = list.length
let index = -1
while (++index < len) {
if (predicate(list[index])) {
return index
}
}
return -1
}
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)
})
import {findIndex} from 'rambda'
const list = [1, 2, 3]
describe('R.findIndex', () => {
it('happy', () => {
const predicate = (x: number) => x > 2
const result = findIndex(predicate, list)
result // $ExpectType number
})
it('curried', () => {
const predicate = (x: number) => x > 2
const result = findIndex(predicate)(list)
result // $ExpectType number
})
})
const R = require('../../dist/rambda.js')
const fn = x => x > 2
const list = [1, 2, 3, 4]
const findIndex = [
{
label: 'Rambda',
fn: () => {
R.findIndex(fn, list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.findIndex(fn, list)
},
},
{
label: 'Lodash',
fn: () => {
_.findIndex(list, fn)
},
},
]
findLast<T>(fn: (x: T) => boolean, list: T[]): T | undefined
It returns the last element of list satisfying the predicate function.
If there is no such element, then undefined is returned.
findLast<T>(fn: (x: T) => boolean, list: T[]): T | undefined;
findLast<T>(fn: (x: T) => boolean): (list: T[]) => T | undefined;
export function findLast(predicate, list) {
if (arguments.length === 1) return _list => findLast(predicate, _list)
let index = list.length
while (--index >= 0) {
if (predicate(list[index])) {
return list[index]
}
}
return undefined
}
import {findLast} from './findLast'
test('happy', () => {
const result = findLast(x => 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)
})
import {findLast} from 'rambda'
const list = [1, 2, 3]
describe('R.findLast', () => {
it('happy', () => {
const predicate = (x: number) => x > 2
const result = findLast(predicate, list)
result // $ExpectType number | undefined
})
it('curried', () => {
const predicate = (x: number) => x > 2
const result = findLast(predicate)(list)
result // $ExpectType number | undefined
})
})
findLastIndex<T>(predicate: (x: T) => boolean, list: 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.
findLastIndex<T>(predicate: (x: T) => boolean, list: T[]): number;
findLastIndex<T>(predicate: (x: T) => boolean): (list: T[]) => number;
export function findLastIndex(fn, list) {
if (arguments.length === 1) return _list => findLastIndex(fn, _list)
let index = list.length
while (--index >= 0) {
if (fn(list[index])) {
return index
}
}
return -1
}
import {findLastIndex} from './findLastIndex'
test('happy', () => {
const result = findLastIndex(x => 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)
})
import {findLastIndex} from 'rambda'
const list = [1, 2, 3]
describe('R.findLastIndex', () => {
it('happy', () => {
const predicate = (x: number) => x > 2
const result = findLastIndex(predicate, list)
result // $ExpectType number
})
it('curried', () => {
const predicate = (x: number) => x > 2
const result = findLastIndex(predicate)(list)
result // $ExpectType number
})
})
flatten<T>(list: any[]): T[]
It deeply flattens an array.
flatten<T>(list: any[]): T[];
import {_isArray} from './_internals/_isArray'
export function flatten(list, input) {
const willReturn = input === undefined ? [] : input
for (let i = 0; i < list.length; i++) {
if (_isArray(list[i])) {
flatten(list[i], willReturn)
} else {
willReturn.push(list[i])
}
}
return willReturn
}
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])
})
import {flatten} from 'rambda'
describe('flatten', () => {
it('happy', () => {
const result = flatten<number>([1, 2, [3, [4]]])
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const list = [1, [2, [3, 4, 6]]]
const flatten = [
{
label: 'Rambda',
fn: () => {
R.flatten(list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.flatten(list)
},
},
{
label: 'Lodash',
fn: () => {
_.flatten(list)
},
},
]
It returns function which calls fn with exchanged first and second argument.
forEach<T>(fn: Iterator<T, void>, list: T[]): T[]
It applies iterable function over all members of list and returns list.
forEach<T>(fn: Iterator<T, void>, list: T[]): T[];
forEach<T>(fn: Iterator<T, void>): (list: T[]) => T[];
forEach<T>(fn: ObjectIterator<T, void>, list: Dictionary<T>): Dictionary<T>;
forEach<T, U>(fn: ObjectIterator<T, void>): (list: Dictionary<T>) => Dictionary<T>;
import {_isArray} from './_internals/_isArray'
import {_keys} from './_internals/_keys'
export function forEach(fn, list) {
if (arguments.length === 1) return _list => forEach(fn, _list)
if (list === undefined) {
return
}
if (_isArray(list)) {
let index = 0
const len = list.length
while (index < len) {
fn(list[index])
index++
}
} else {
let index = 0
const keys = _keys(list)
const len = keys.length
while (index < len) {
const key = keys[index]
fn(list[key], key, list)
index++
}
}
return list
}
import {forEach} from './forEach'
import {type} from './type'
test('happy', () => {
const sideEffect = {}
forEach(x => (sideEffect[`foo${x}`] = x + 10))([1, 2])
expect(sideEffect).toEqual({
foo1: 11,
foo2: 12,
})
})
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('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)
})
import {forEach} from 'rambda'
const list = [1, 2, 3]
const obj = {a: 1, b: 2}
describe('R.forEach with arrays', () => {
it('happy', () => {
const result = forEach(a => {
a // $ExpectType number
}, list)
result // $ExpectType number[]
})
it('curried require an explicit typing', () => {
const result = forEach<number>(a => {
a // $ExpectType number
})(list)
result // $ExpectType number[]
})
})
describe('R.forEach with objects', () => {
it('happy', () => {
const result = forEach((a, b, c) => {
a // $ExpectType number
b // $ExpectType string
c // $ExpectType Dictionary<number>
return `${a}`
}, obj)
result // $ExpectType Dictionary<number>
})
it('curried require an input typing and a dummy third typing', () => {
// Required in order all typings to work
const result = forEach<number, any>((a, b, c) => {
a // $ExpectType number
b // $ExpectType string
c // $ExpectType Dictionary<number>
})(obj)
result // $ExpectType Dictionary<number>
})
it('iterator without property', () => {
const result = forEach(a => {
a // $ExpectType number
}, obj)
result // $ExpectType Dictionary<number>
})
})
It transforms a listOfPairs to an object.
It splits list according to a provided groupFn function and returns an object.
It returns separated version of list or string input, where separation is done with equality compareFn function.
has<T>(prop: string, obj: T): boolean
It returns true if obj has property prop.
has<T>(prop: string, obj: T): boolean;
has(prop: string): <T>(obj: T) => boolean;
export function has(prop, obj) {
if (arguments.length === 1) return _obj => has(prop, _obj)
if (!obj) return false
return obj.hasOwnProperty(prop)
}
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)
})
import {has} from 'rambda'
describe('R.has', () => {
it('happy', () => {
const result = has('foo', {a: 1})
const curriedResult = has('bar')({a: 1})
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
})
hasPath<T>(
path: string | string[],
input: object
): boolean
It will return true, if input object has truthy path(calculated with R.path).
hasPath<T>(
path: string | string[],
input: object
): boolean;
hasPath<T>(
path: string | string[]
): (input: object) => boolean;
import {path} from './path'
export function hasPath(pathInput, obj) {
if (arguments.length === 1) {
return objHolder => hasPath(pathInput, objHolder)
}
return path(pathInput, obj) !== undefined
}
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)
})
import {hasPath} from 'rambda'
describe('R.hasPath', () => {
it('string path', () => {
const obj = {a: {b: 1}}
const result = hasPath('a.b', obj)
const curriedResult = hasPath('a.c')(obj)
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
it('array path', () => {
const obj = {a: {b: 1}}
const result = hasPath(['a', 'b'], obj)
const curriedResult = hasPath(['a', 'c'])(obj)
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
})
head(input: string): string
It returns the first element of list or string input.
head(input: string): string;
head(emptyList: []): undefined;
head<T>(input: T[]): T | undefined;
export function head(listOrString) {
if (typeof listOrString === 'string') return listOrString[0] || ''
return listOrString[0]
}
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('')
})
import {head} from 'rambda'
describe('R.head', () => {
it('string', () => {
const result = head('foo')
result // $ExpectType string
})
it('array', () => {
const result = head([1, 2, 3])
result // $ExpectType number | undefined
})
it('empty array - case 1', () => {
const result = head([])
result // $ExpectType undefined
})
it('empty array - case 2', () => {
const list = ['foo', 'bar'].filter(x => x.startsWith('a'))
const result = head(list)
result // $ExpectType string | undefined
})
})
It returns true if its arguments a and b are identical.
Otherwise, it returns false.
identity<T>(input: T): T
It just passes back the supplied input argument.
identity<T>(input: T): T;
export function identity(x) {
return x
}
import {identity} from './identity'
test('happy', () => {
expect(identity(7)).toEqual(7)
expect(identity(true)).toEqual(true)
expect(identity({a: 1})).toEqual({a: 1})
})
import {identity} from 'rambda'
describe('R.identity', () => {
it('happy', () => {
const result = identity(4)
result // $ExpectType 4
})
})
ifElse<TArgs extends any[], TOnTrueResult, TOnFalseResult>(fn: (...args: TArgs) => boolean, onTrue: (...args: TArgs) => TOnTrueResult, onFalse: (...args: TArgs) => TOnFalseResult): (...args: TArgs) => TOnTrueResult | TOnFalseResult
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.
ifElse<TArgs extends any[], TOnTrueResult, TOnFalseResult>(fn: (...args: TArgs) => boolean, onTrue: (...args: TArgs) => TOnTrueResult, onFalse: (...args: TArgs) => TOnFalseResult): (...args: TArgs) => TOnTrueResult | TOnFalseResult;
import {curry} from './curry'
function ifElseFn(condition, onTrue, onFalse) {
return (...input) => {
const conditionResult =
typeof condition === 'boolean' ? condition : condition(...input)
if (conditionResult === true) {
return onTrue(...input)
}
return onFalse(...input)
}
}
export const ifElse = curry(ifElseFn)
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)
})
import {ifElse} from 'rambda'
describe('R.ifElse', () => {
it('happy', () => {
const condition = (x: number) => x > 5
const onTrue = (x: number) => `foo${x}`
const onFalse = (x: number) => `bar${x}`
const fn = ifElse(condition, onTrue, onFalse)
fn // $ExpectType (x: number) => string
const result = fn(3)
result // $ExpectType string
})
it('arity of 2', () => {
const condition = (x: number, y: string) => x + y.length > 5
const onTrue = (x: number, y: string) => `foo${x}-${y}`
const onFalse = (x: number, y: string) => `bar${x}-${y}`
const fn = ifElse(condition, onTrue, onFalse)
fn // $ExpectType (x: number, y: string) => string
const result = fn(3, 'hello')
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const condition = R.has('foo')
const v = function (a) {
return typeof a === 'number'
}
const t = function (a) {
return a + 1
}
const ifFn = x => R.prop('foo', x).length
const elseFn = () => false
const ifElse = [
{
label: 'Rambda',
fn: () => {
const fn = R.ifElse(condition, ifFn)(elseFn)
fn({foo: 'bar'})
fn({fo: 'bar'})
const ifIsNumber = R.ifElse(v)
ifIsNumber(t, R.identity)(15)
ifIsNumber(t, R.identity)('hello')
},
},
{
label: 'Ramda',
fn: () => {
const fn = Ramda.ifElse(condition, ifFn)(elseFn)
fn({foo: 'bar'})
fn({fo: 'bar'})
const ifIsNumber = Ramda.ifElse(v)
ifIsNumber(t, R.identity)(15)
ifIsNumber(t, R.identity)('hello')
},
},
]
It increments a number.
includes(valueToFind: string, input: 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.
includes(valueToFind: string, input: string[] | string): boolean;
includes(valueToFind: string): (input: string[] | string) => boolean;
includes<T>(valueToFind: T, input: T[]): boolean;
includes<T>(valueToFind: T): (input: T[]) => boolean;
import {_isArray} from './_internals/_isArray'
import {_indexOf} from './equals'
export function includes(valueToFind, iterable) {
if (arguments.length === 1)
return _iterable => includes(valueToFind, _iterable)
if (typeof iterable === 'string') {
return iterable.includes(valueToFind)
}
if (!iterable) {
throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
}
if (!_isArray(iterable)) return false
return _indexOf(valueToFind, iterable) > -1
}
import {includes} from './includes'
import {includes as includesRamda} from 'ramda'
test('with string as iterable', () => {
const str = 'foo bar'
expect(includes('bar')(str)).toBeTrue()
expect(includesRamda('bar')(str)).toBeTrue()
expect(includes('never', str)).toBeFalse()
expect(includesRamda('never', str)).toBeFalse()
})
test('with array as iterable', () => {
const arr = [1, 2, 3]
expect(includes(2)(arr)).toBeTrue()
expect(includesRamda(2)(arr)).toBeTrue()
expect(includes(4, arr)).toBeFalse()
expect(includesRamda(4, arr)).toBeFalse()
})
test('with list of objects as iterable', () => {
const arr = [{a: 1}, {b: 2}, {c: 3}]
expect(includes({c: 3}, arr)).toBeTrue()
expect(includesRamda({c: 3}, arr)).toBeTrue()
})
test('with NaN', () => {
const result = includes(NaN, [NaN])
const ramdaResult = includesRamda(NaN, [NaN])
expect(result).toBeTrue()
expect(ramdaResult).toBeTrue()
})
test('with wrong input that does not throw', () => {
const result = includes(1, /foo/g)
const ramdaResult = includesRamda(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(() => includesRamda(2, null)).toThrowWithMessage(
TypeError,
`Cannot read properties of null (reading 'indexOf')`
)
expect(() => includes(2, undefined)).toThrowWithMessage(
TypeError,
"Cannot read property 'indexOf' of undefined"
)
expect(() => includesRamda(2, undefined)).toThrowWithMessage(
TypeError,
`Cannot read properties of undefined (reading 'indexOf')`
)
})
import {includes} from 'rambda'
const list = [{a: {b: '1'}}, {a: {c: '2'}}, {a: {b: '3'}}]
describe('R.includes', () => {
it('happy', () => {
const result = includes({a: {b: '1'}}, list)
result // $ExpectType boolean
})
it('with string', () => {
const result = includes('oo', 'foo')
const curriedResult = includes('oo')('foo')
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const {
uniqListOfStrings,
uniqListOfBooleans,
uniqListOfObjects,
uniqListOfLists,
listOfVariousTypes,
rangeOfNumbers,
} = require('./_utils.js')
const limit = 100
const additionalModes = listOfVariousTypes.map(unknownType => [
unknownType,
uniqListOfLists(limit),
])
const modes = [
[99, rangeOfNumbers(limit)],
[200, rangeOfNumbers(limit)],
...additionalModes,
['zeppelin', uniqListOfStrings(limit)],
[null, uniqListOfBooleans(limit)],
[{foo: true, bar: true}, uniqListOfObjects(limit)],
[1, uniqListOfLists(limit)],
[[1], uniqListOfLists(limit)],
]
function applyBenchmark(fn, input) {
return fn(input[0], input[1])
}
const tests = [
{
label: 'Rambda',
fn: R.includes,
},
{
label: 'Ramda',
fn: Ramda.includes,
},
]
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).
It returns the index of the first element of list equals to valueToFind.
If there is no such element, it returns -1.
init<T>(input: T[]): T[]
It returns all but the last element of list or string input.
init<T>(input: T[]): T[];
init(input: string): string;
import baseSlice from './_internals/baseSlice'
export function init(listOrString) {
if (typeof listOrString === 'string') return listOrString.slice(0, -1)
return listOrString.length ? baseSlice(listOrString, 0, -1) : []
}
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('')
})
import {init} from 'rambda'
describe('R.init', () => {
it('with string', () => {
const result = init('foo')
result // $ExpectType string
})
it('with list', () => {
const result = init([1, 2, 3])
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const list = [1, 2, 3, 4]
const init = [
{
label: 'Rambda',
fn: () => {
R.init(list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.init(list)
},
},
{
label: 'Lodash',
fn: () => {
_.initial(list)
},
},
]
It loops throw listA and listB and returns the intersection of the two according to R.equals.
It adds a separator between members of list.
It returns true if x is instance of targetPrototype.
isEmpty<T>(x: T): boolean
It returns true if x is empty.
isEmpty<T>(x: T): boolean;
import {type} from './type'
export function isEmpty(input) {
const inputType = type(input)
if (['Undefined', 'NaN', 'Number', 'Null'].includes(inputType))
return false
if (!input) return true
if (inputType === 'Object') {
return Object.keys(input).length === 0
}
if (inputType === 'Array') {
return input.length === 0
}
return false
}
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)
})
import {isEmpty} from 'rambda'
describe('R.isEmpty', () => {
it('happy', () => {
const result = isEmpty('foo')
result // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const isEmpty = [
{
label: 'Rambda',
fn: () => {
R.isEmpty(undefined)
R.isEmpty('')
R.isEmpty(null)
R.isEmpty(' ')
R.isEmpty(new RegExp(''))
R.isEmpty([])
R.isEmpty([[]])
R.isEmpty({})
R.isEmpty({x: 0})
R.isEmpty(0)
R.isEmpty(NaN)
R.isEmpty([''])
},
},
{
label: 'Ramda',
fn: () => {
Ramda.isEmpty(undefined)
Ramda.isEmpty('')
Ramda.isEmpty(null)
Ramda.isEmpty(' ')
Ramda.isEmpty(new RegExp(''))
Ramda.isEmpty([])
Ramda.isEmpty([[]])
Ramda.isEmpty({})
Ramda.isEmpty({x: 0})
Ramda.isEmpty(0)
Ramda.isEmpty(NaN)
Ramda.isEmpty([''])
},
},
{
label: 'Lodash',
fn: () => {
_.isEmpty(undefined)
_.isEmpty('')
_.isEmpty(null)
_.isEmpty(' ')
_.isEmpty(new RegExp(''))
_.isEmpty([])
_.isEmpty([[]])
_.isEmpty({})
_.isEmpty({x: 0})
_.isEmpty(0)
_.isEmpty(NaN)
_.isEmpty([''])
},
},
]
isNil(x: any): x is null | undefined
It returns true if x is either null or undefined.
isNil(x: any): x is null | undefined;
export function isNil(x) {
return x === undefined || x === null
}
import {isNil} from './isNil'
test('happy', () => {
expect(isNil(null)).toBeTrue()
expect(isNil(undefined)).toBeTrue()
expect(isNil([])).toBeFalse()
})
join<T>(glue: string, list: T[]): string
It returns a string of all list instances joined with a glue.
join<T>(glue: string, list: T[]): string;
join<T>(glue: string): (list: T[]) => string;
export function join(glue, list) {
if (arguments.length === 1) return _list => join(glue, _list)
return list.join(glue)
}
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')
})
import {join} from 'rambda'
describe('R.join', () => {
it('happy', () => {
const result = join('|', [1, 2, 3])
result // $ExpectType string
})
})
keys<T extends object>(x: T): (keyof T)[]
It applies Object.keys over x and returns its keys.
keys<T extends object>(x: T): (keyof T)[];
keys<T>(x: T): string[];
export function keys(x) {
return Object.keys(x)
}
import {keys} from './keys'
test('happy', () => {
expect(keys({a: 1})).toEqual(['a'])
})
import {keys} from 'rambda'
const obj = {a: 1, b: 2}
describe('R.keys', () => {
it('happy', () => {
const result = keys(obj)
result // $ExpectType ("b" | "a")[]
})
})
last(str: string): string
It returns the last element of input, as the input can be either a string or an array.
last(str: string): string;
last(emptyList: []): undefined;
last<T extends any>(list: T[]): T | undefined;
export function last(listOrString) {
if (typeof listOrString === 'string') {
return listOrString[listOrString.length - 1] || ''
}
return listOrString[listOrString.length - 1]
}
import {last} from './last'
test('with list', () => {
expect(last([1, 2, 3])).toBe(3)
expect(last([])).toBeUndefined()
})
test('with string', () => {
expect(last('abc')).toEqual('c')
expect(last('')).toEqual('')
})
import {last} from 'rambda'
describe('R.last', () => {
it('string', () => {
const result = last('foo')
result // $ExpectType string
})
it('array', () => {
const result = last([1, 2, 3])
result // $ExpectType number | undefined
})
it('empty array - case 1', () => {
const result = last([])
result // $ExpectType undefined
})
it('empty array - case 2', () => {
const list = ['foo', 'bar'].filter(x => x.startsWith('a'))
const result = last(list)
result // $ExpectType string | undefined
})
})
const R = require('../../dist/rambda.js')
const list = [1, 2, 3, 4]
const last = [
{
label: 'Rambda',
fn: () => {
R.last(list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.last(list)
},
},
{
label: 'Lodash',
fn: () => {
_.last(list)
},
},
]
lastIndexOf<T>(target: T, list: 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.
lastIndexOf<T>(target: T, list: T[]): number;
lastIndexOf<T>(target: T): (list: T[]) => number;
import {_lastIndexOf} from './equals'
export function lastIndexOf(valueToFind, list) {
if (arguments.length === 1) {
return _list => _lastIndexOf(valueToFind, _list)
}
return _lastIndexOf(valueToFind, list)
}
import {lastIndexOf} from './lastIndexOf'
import {lastIndexOf as lastIndexOfRamda} from 'ramda'
import {compareCombinations} from './_internals/testUtils'
import {possibleTargets, possibleIterables} from './indexOf.spec.js'
test('with NaN', () => {
expect(lastIndexOf(NaN, [NaN])).toEqual(0)
})
test('will throw with bad input', () => {
expect(lastIndexOfRamda([], true)).toEqual(-1)
expect(() => indexOf([], true)).toThrow()
})
test('without list of objects - no R.equals', () => {
expect(lastIndexOf(3, [1, 2, 3, 4])).toEqual(2)
expect(lastIndexOf(10)([1, 2, 3, 4])).toEqual(-1)
})
test('list of objects uses R.equals', () => {
const listOfObjects = [{a: 1}, {b: 2}, {c: 3}]
expect(lastIndexOf({c: 4}, listOfObjects)).toBe(-1)
expect(lastIndexOf({c: 3}, listOfObjects)).toBe(2)
})
test('list of arrays uses R.equals', () => {
const listOfLists = [[1], [2, 3], [2, 3, 4], [2, 3], [1], []]
expect(lastIndexOf([], listOfLists)).toBe(5)
expect(lastIndexOf([1], listOfLists)).toBe(4)
expect(lastIndexOf([2, 3, 4], listOfLists)).toBe(2)
expect(lastIndexOf([2, 3, 5], listOfLists)).toBe(-1)
})
test('with string as iterable', () => {
expect(() => lastIndexOf('a', 'abc')).toThrowWithMessage(
Error,
`Cannot read property 'indexOf' of abc`
)
expect(lastIndexOfRamda('a', 'abc')).toBe(0)
})
describe('brute force', () => {
compareCombinations({
fn: lastIndexOf,
fnRamda: lastIndexOfRamda,
firstInput: possibleTargets,
secondInput: possibleIterables,
callback: errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 34,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 51,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 170,
}
`)
},
})
})
import {lastIndexOf} from 'rambda'
const list = [1, 2, 3]
describe('R.lastIndexOf', () => {
it('happy', () => {
const result = lastIndexOf(2, list)
result // $ExpectType number
})
it('curried', () => {
const result = lastIndexOf(2)(list)
result // $ExpectType number
})
})
const R = require('../../dist/rambda.js')
const isEven = n => n % 2 === 0
const arr = [1, 3, 5, 7, 9, 11]
const lastIndexOf = [
{
label: 'Rambda',
fn: () => {
R.lastIndexOf(1, [1, 2, 3, 1, 2])
R.lastIndexOf(1)([1, 2, 3, 1, 2])
},
},
{
label: 'Ramda',
fn: () => {
Ramda.lastIndexOf(1, [1, 2, 3, 1, 2])
Ramda.lastIndexOf(1)([1, 2, 3, 1, 2])
},
},
]
length<T>(input: T[]): number
It returns the length property of list or string input.
length<T>(input: T[]): number;
import {_isArray} from './_internals/_isArray'
export function length(x) {
if (_isArray(x)) return x.length
if (typeof x === 'string') return x.length
return NaN
}
import {length} from './length'
import {length as lengthRamda} from 'ramda'
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()
})
test('with length as property', () => {
const input1 = {length: '123'}
const input2 = {length: null}
const input3 = {length: ''}
expect(length(input1)).toBeNaN()
expect(lengthRamda(input1)).toBeNaN()
expect(length(input2)).toBeNaN()
expect(lengthRamda(input2)).toBeNaN()
expect(length(input3)).toBeNaN()
expect(lengthRamda(input3)).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.
lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
export function lens(getter, setter) {
return function (functor) {
return function (target) {
return functor(getter(target)).map(focus => setter(focus, target))
}
}
}
import {lens, assoc} from 'rambda'
interface Input {
foo: string
}
describe('R.lens', () => {
it('happy', () => {
const fn = lens<Input, string, string>((x: Input) => {
x.foo // $ExpectType string
return x.foo
}, assoc('name'))
fn // $ExpectType Lens
})
})
lensIndex(index: number): Lens
It returns a lens that focuses on specified index.
lensIndex(index: number): Lens;
import {lens} from './lens'
import {nth} from './nth'
import {update} from './update'
export function lensIndex(index) {
return lens(nth(index), update(index))
}
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)
})
import {view, lensIndex} from 'rambda'
interface Input {
a: number
}
const testList: Input[] = [{a: 1}, {a: 2}, {a: 3}]
describe('R.lensIndex', () => {
it('happy', () => {
const result = view<Input[], Input>(lensIndex(0), testList)
result // $ExpectType Input
result.a // $ExpectType number
})
})
lensPath(path: RamdaPath): Lens
It returns a lens that focuses on specified path.
lensPath(path: RamdaPath): Lens;
lensPath(path: string): Lens;
import {assocPath} from './assocPath'
import {lens} from './lens'
import {path} from './path'
export function lensPath(key) {
return lens(path(key), assocPath(key))
}
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)
})
import {lensPath, view} from 'rambda'
interface Input {
foo: number[]
bar: {
a: string
b: string
}
}
const testObject: Input = {
foo: [1, 2],
bar: {
a: 'x',
b: 'y',
},
}
const path = lensPath(['bar', 'a'])
const pathAsString = lensPath('bar.a')
describe('R.lensPath', () => {
it('happy', () => {
const result = view<Input, string>(path, testObject)
result // $ExpectType string
})
it('using string as path input', () => {
const result = view<Input, string>(pathAsString, testObject)
result // $ExpectType string
})
})
lensProp(prop: string): {
<T, U>(obj: T): U
It returns a lens that focuses on specified property prop.
lensProp(prop: string): {
<T, U>(obj: T): U;
set<T, U, V>(val: T, obj: U): V;
};
import {assoc} from './assoc'
import {lens} from './lens'
import {prop} from './prop'
export function lensProp(key) {
return lens(prop(key), assoc(key))
}
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)
})
import {lensProp, view} from 'rambda'
interface Input {
foo: string
}
const testObject: Input = {
foo: 'Led Zeppelin',
}
const lens = lensProp('foo')
describe('R.lensProp', () => {
it('happy', () => {
const result = view<Input, string>(lens, testObject)
result // $ExpectType string
})
})
map<T, U>(fn: ObjectIterator<T, U>, iterable: Dictionary<T>): Dictionary<U>
It returns the result of looping through iterable with fn.
It works with both array and object.
map<T, U>(fn: ObjectIterator<T, U>, iterable: Dictionary<T>): Dictionary<U>;
map<T, U>(fn: Iterator<T, U>, iterable: T[]): U[];
map<T, U>(fn: Iterator<T, U>): (iterable: T[]) => U[];
map<T, U, S>(fn: ObjectIterator<T, U>): (iterable: Dictionary<T>) => Dictionary<U>;
map<T>(fn: Iterator<T, T>): (iterable: T[]) => T[];
map<T>(fn: Iterator<T, T>, iterable: T[]): T[];
import {_isArray} from './_internals/_isArray'
import {_keys} from './_internals/_keys'
export function mapArray(fn, list, isIndexed = false) {
let index = 0
const willReturn = Array(list.length)
while (index < list.length) {
willReturn[index] = isIndexed ? fn(list[index], index) : fn(list[index])
index++
}
return willReturn
}
export function mapObject(fn, obj) {
let index = 0
const keys = _keys(obj)
const len = keys.length
const willReturn = {}
while (index < len) {
const key = keys[index]
willReturn[key] = fn(obj[key], key, obj)
index++
}
return willReturn
}
export const mapObjIndexed = mapObject
export function map(fn, iterable) {
if (arguments.length === 1) return _iterable => map(fn, _iterable)
if (!iterable) {
throw new Error('Incorrect iterable input')
}
if (_isArray(iterable)) return mapArray(fn, iterable)
return mapObject(fn, iterable)
}
import {map} from './map'
import {map as mapRamda} from 'ramda'
const double = x => x * 2
describe(`with array`, () => {
test('happy', () => {
expect(map(double, [1, 2, 3])).toEqual([2, 4, 6])
})
test('curried', () => {
expect(map(double)([1, 2, 3])).toEqual([2, 4, 6])
})
})
describe(`with object`, () => {
const obj = {
a: 1,
b: 2,
}
test('happy', () => {
expect(map(double, obj)).toEqual({
a: 2,
b: 4,
})
})
test('property as second and input object as third argument', () => {
const obj = {
a: 1,
b: 2,
}
const iterator = (val, prop, inputObject) => {
expect(prop).toBeString()
expect(inputObject).toEqual(obj)
return val * 2
}
expect(map(iterator)(obj)).toEqual({
a: 2,
b: 4,
})
})
})
test('bad inputs difference between Ramda and Rambda', () => {
expect(() => map(double, null)).toThrowWithMessage(
Error,
`Incorrect iterable input`
)
expect(() => map(double)(undefined)).toThrowWithMessage(
Error,
`Incorrect iterable input`
)
expect(() => mapRamda(double, null)).toThrowWithMessage(
TypeError,
`Cannot read properties of null (reading 'fantasy-land/map')`
)
expect(() => mapRamda(double, undefined)).toThrowWithMessage(
TypeError,
`Cannot read properties of undefined (reading 'fantasy-land/map')`
)
})
import {map} from 'rambda'
describe('R.map with arrays', () => {
it('iterable returns the same type as the input', () => {
const result = map<number>(
(x: number) => {
x // $ExpectType number
return x + 2
},
[1, 2, 3]
)
result // $ExpectType number[]
})
it('iterable returns the same type as the input - curried', () => {
const result = map<number>((x: number) => {
x // $ExpectType number
return x + 2
})([1, 2, 3])
result // $ExpectType number[]
})
it('iterable returns different type as the input', () => {
const result = map<number, string>(
(x: number) => {
x // $ExpectType number
return String(x)
},
[1, 2, 3]
)
result // $ExpectType string[]
})
})
describe('R.map with objects', () => {
it('iterable with all three arguments - curried', () => {
// It requires dummy third typing argument
// in order to identify compared to curry typings for arrays
// ============================================
const result = map<number, string, any>((a, b, c) => {
a // $ExpectType number
b // $ExpectType string
c // $ExpectType Dictionary<number>
return `${a}`
})({a: 1, b: 2})
result // $ExpectType Dictionary<string>
})
it('iterable with all three arguments', () => {
const result = map<number, string>(
(a, b, c) => {
a // $ExpectType number
b // $ExpectType string
c // $ExpectType Dictionary<number>
return `${a}`
},
{a: 1, b: 2}
)
result // $ExpectType Dictionary<string>
})
it('iterable with property argument', () => {
const result = map<number, string>(
(a, b) => {
a // $ExpectType number
b // $ExpectType string
return `${a}`
},
{a: 1, b: 2}
)
result // $ExpectType Dictionary<string>
})
it('iterable with no property argument', () => {
const result = map<number, string>(
a => {
a // $ExpectType number
return `${a}`
},
{a: 1, b: 2}
)
result // $ExpectType Dictionary<string>
})
})
const R = require('../../dist/rambda.js')
const arr = [1, 2, 3, 4]
const fn = x => x * 2
const map = [
{
label: 'Rambda',
fn: () => {
R.map(fn, arr)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.map(fn, arr)
},
},
{
label: 'Lodash',
fn: () => {
_.map(arr, fn)
},
},
]
It works the same way as R.map does for objects. It is added as Ramda also has this method.
match(regExpression: RegExp, str: string): string[]
Curried version of String.prototype.match which returns empty array, when there is no match.
match(regExpression: RegExp, str: string): string[];
match(regExpression: RegExp): (str: string) => string[];
export function match(pattern, input) {
if (arguments.length === 1) return _input => match(pattern, _input)
const willReturn = input.match(pattern)
return willReturn === null ? [] : willReturn
}
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 properties of null (reading 'match')`
)
})
import {match} from 'rambda'
const str = 'foo bar'
describe('R.match', () => {
it('happy', () => {
const result = match(/foo/, str)
result // $ExpectType string[]
})
it('curried', () => {
const result = match(/foo/)(str)
result // $ExpectType string[]
})
})
const R = require('../../dist/rambda.js')
const match = [
{
label: 'Rambda',
fn: () => {
R.match(/a./g)('foo bar baz')
R.match(/a./g, 'foo bar baz')
},
},
{
label: 'Ramda',
fn: () => {
Ramda.match(/a./g)('foo bar baz')
Ramda.match(/a./g, 'foo bar baz')
},
},
]
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.
It returns the greater value between x and y.
It returns the greater value between x and y according to compareFn function.
mean(list: number[]): number
It returns the mean value of list input.
mean(list: number[]): number;
import {sum} from './sum'
export function mean(list) {
return sum(list) / list.length
}
import {mean} from './mean'
test('happy', () => {
expect(mean([2, 7])).toBe(4.5)
})
test('with NaN', () => {
expect(mean([])).toBeNaN()
})
import {mean} from 'rambda'
describe('R.mean', () => {
it('happy', () => {
const result = mean([1, 2, 3])
result // $ExpectType number
})
})
median(list: number[]): number
It returns the median value of list input.
median(list: number[]): number;
import {mean} from './mean'
export function median(list) {
const len = list.length
if (len === 0) return NaN
const width = 2 - (len % 2)
const idx = (len - width) / 2
return mean(
Array.prototype.slice
.call(list, 0)
.sort((a, b) => {
if (a === b) return 0
return a < b ? -1 : 1
})
.slice(idx, idx + width)
)
}
import {median} from './median'
test('happy', () => {
expect(median([2])).toEqual(2)
expect(median([7, 2, 10, 2, 9])).toEqual(7)
})
test('with empty array', () => {
expect(median([])).toBeNaN()
})
import {median} from 'rambda'
describe('R.median', () => {
it('happy', () => {
const result = median([1, 2, 3])
result // $ExpectType number
})
})
merge<A, B>(target: A, newProps: B): A & B
export function merge<Output>(target: any): (newProps: any) => Output
It creates a copy of target object with overidden newProps properties.
merge<A, B>(target: A, newProps: B): A & B
merge<Output>(target: any): (newProps: any) => Output;
export function merge(target, newProps) {
if (arguments.length === 1) return _newProps => merge(target, _newProps)
return Object.assign({}, target || {}, newProps || {})
}
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)
})
import {merge} from 'rambda'
interface Output {
foo: number
bar: number
}
describe('R.merge', () => {
const result = merge({foo: 1}, {bar: 2})
const curriedResult = merge<Output>({foo: 1})({bar: 2})
result.foo // $ExpectType number
result.bar // $ExpectType number
curriedResult.bar // $ExpectType number
})
const R = require('../../dist/rambda.js')
const obj = {bar: 'yes'}
const a = {
foo: 'bar',
bar: 'baz',
}
const merge = [
{
label: 'Rambda',
fn: () => {
R.merge(a, obj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.merge(a, obj)
},
},
{
label: 'Lodash',
fn: () => {
_.merge(a, obj)
},
},
]
mergeAll<T>(list: object[]): T
It merges all objects of list array sequentially and returns the result.
mergeAll<T>(list: object[]): T;
mergeAll(list: object[]): object;
import {map} from './map'
import {merge} from './merge'
export function mergeAll(arr) {
let willReturn = {}
map(val => {
willReturn = merge(willReturn, val)
}, arr)
return willReturn
}
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,
})
})
import {mergeAll} from 'rambda'
describe('R.mergeAll', () => {
it('with passing type', () => {
interface Output {
foo: number
bar: number
}
const result = mergeAll<Output>([{foo: 1}, {bar: 2}])
result.foo // $ExpectType number
result.bar // $ExpectType number
})
it('without passing type', () => {
const result = mergeAll([{foo: 1}, {bar: 2}])
result // $ExpectType unknown
})
})
mergeDeepRight<Output>(target: object, newProps: object): Output
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<Output>(target: object, newProps: object): Output;
mergeDeepRight<Output>(target: object): (newProps: object) => Output;
import {type} from './type'
export function mergeDeepRight(target, source) {
if (arguments.length === 1) {
return sourceHolder => mergeDeepRight(target, sourceHolder)
}
const willReturn = JSON.parse(JSON.stringify(target))
Object.keys(source).forEach(key => {
if (type(source[key]) === 'Object') {
if (type(target[key]) === 'Object') {
willReturn[key] = mergeDeepRight(target[key], source[key])
} else {
willReturn[key] = source[key]
}
} else {
willReturn[key] = source[key]
}
})
return willReturn
}
// 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)
})
import {mergeDeepRight} from 'rambda'
interface Output {
foo: {
bar: number
}
}
describe('R.mergeDeepRight', () => {
const result = mergeDeepRight<Output>({foo: {bar: 1}}, {foo: {bar: 2}})
result.foo.bar // $ExpectType number
})
mergeLeft<Output>(newProps: object, target: object): Output
Same as R.merge, but in opposite direction.
mergeLeft<Output>(newProps: object, target: object): Output;
mergeLeft<Output>(newProps: object): (target: object) => Output;
import {merge} from './merge'
export function mergeLeft(x, y) {
if (arguments.length === 1) return _y => mergeLeft(x, _y)
return merge(y, x)
}
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)
})
import {mergeLeft} from 'rambda'
interface Output {
foo: number
bar: number
}
describe('R.mergeLeft', () => {
const result = mergeLeft<Output>({foo: 1}, {bar: 2})
const curriedResult = mergeLeft<Output>({foo: 1})({bar: 2})
result.foo // $ExpectType number
result.bar // $ExpectType number
curriedResult.bar // $ExpectType number
})
It returns the lesser value between x and y.
It returns the lesser value between x and y according to compareFn function.
Curried version of x%y.
It returns a copy of list with exchanged fromIndex and toIndex elements.
Curried version of x*y.
none<T>(predicate: (x: T) => boolean, list: T[]): boolean
It returns true, if all members of array list returns false, when applied as argument to predicate function.
none<T>(predicate: (x: T) => boolean, list: T[]): boolean;
none<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
export function none(predicate, list) {
if (arguments.length === 1) return _list => none(predicate, _list)
for (let i = 0; i < list.length; i++) {
if (predicate(list[i])) return false
}
return true
}
import {none} from './none'
const isEven = n => n % 2 === 0
test('when true', () => {
expect(none(isEven, [1, 3, 5, 7])).toBeTrue()
})
test('when false curried', () => {
expect(none(isOdd)([1, 3, 5, 8])).toBeFalse()
})
import {none} from 'rambda'
describe('R.none', () => {
it('happy', () => {
const result = none(
x => {
x // $ExpectType number
return x > 0
},
[1, 2, 3]
)
result // $ExpectType boolean
})
it('curried needs a type', () => {
const result = none<number>(x => {
x // $ExpectType number
return x > 0
})([1, 2, 3])
result // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const isEven = n => n % 2 === 0
const arr = [1, 3, 5, 7, 9, 11]
const none = [
{
label: 'Rambda',
fn: () => {
R.none(isEven, arr)
R.none(isEven)(arr)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.none(isEven, arr)
Ramda.none(isEven)(arr)
},
},
]
not(input: any): boolean
It returns a boolean negated version of input.
not(input: any): boolean;
export function not(input) {
return !input
}
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)
})
import {not} from 'rambda'
describe('R.not', () => {
it('happy', () => {
const result = not(4)
result // $ExpectType boolean
})
})
nth<T>(index: number, list: T[]): T | undefined
Curried version of list[index].
nth<T>(index: number, list: T[]): T | undefined;
nth(index: number): <T>(list: T[]) => T | undefined;
export function nth(index, list) {
if (arguments.length === 1) return _list => nth(index, _list)
const idx = index < 0 ? list.length + index : index
return Object.prototype.toString.call(list) === '[object String]'
? list.charAt(idx)
: list[idx]
}
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)
})
import {nth} from 'rambda'
const list = [1, 2, 3]
describe('R.nth', () => {
it('happy', () => {
const result = nth(4, list)
result // $ExpectType number | undefined
})
it('curried', () => {
const result = nth(1)(list)
result // $ExpectType number | undefined
})
})
It creates an object with a single key-value pair.
of<T>(x: T): T[]
of<T>(x: T): T[];
export function of(value) {
return [value]
}
import {of} from './of'
test('happy', () => {
expect(of(3)).toEqual([3])
expect(of(null)).toEqual([null])
})
import {of} from 'ramda'
const list = [1, 2, 3]
describe('R.of', () => {
it('happy', () => {
const result = of(4)
result // $ExpectType number[]
})
it('curried', () => {
const result = of(list)
result // $ExpectType number[][]
})
})
omit<T, K extends string>(propsToOmit: K[], obj: T): Omit<T, K>
It returns a partial copy of an obj without propsToOmit properties.
omit<T, K extends string>(propsToOmit: K[], obj: T): Omit<T, K>;
omit<K extends string>(propsToOmit: 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;
export function omit(propsToOmit, obj) {
if (arguments.length === 1) return _obj => omit(propsToOmit, _obj)
if (obj === null || obj === undefined) {
return undefined
}
const propsToOmitValue =
typeof propsToOmit === 'string' ? propsToOmit.split(',') : propsToOmit
const willReturn = {}
for (const key in obj) {
if (!propsToOmitValue.includes(key)) {
willReturn[key] = obj[key]
}
}
return willReturn
}
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'})
})
import {omit} from 'rambda'
describe('R.omit with array as props input', () => {
it('allow Typescript to infer object type', () => {
const input = {a: 'foo', b: 2, c: 3, d: 4}
const result = omit(['b,c'], input)
result.a // $ExpectType string
result.d // $ExpectType number
const curriedResult = omit(['a,c'], input)
curriedResult.a // $ExpectType string
curriedResult.d // $ExpectType number
})
it('declare type of input object', () => {
interface Input {
a: string
b: number
c: number
d: number
}
const input: Input = {a: 'foo', b: 2, c: 3, d: 4}
const result = omit(['b,c'], input)
result // $ExpectType Omit<Input, "b,c">
result.a // $ExpectType string
result.d // $ExpectType number
const curriedResult = omit(['a,c'], input)
curriedResult.a // $ExpectType string
curriedResult.d // $ExpectType number
})
})
describe('R.omit with string as props input', () => {
interface Output {
b: number
d: number
}
it('explicitly declare output', () => {
const result = omit<Output>('a,c', {a: 1, b: 2, c: 3, d: 4})
result // $ExpectType Output
result.b // $ExpectType number
const curriedResult = omit<Output>('a,c')({a: 1, b: 2, c: 3, d: 4})
curriedResult.b // $ExpectType number
})
it('explicitly declare input and output', () => {
interface Input {
a: number
b: number
c: number
d: number
}
const result = omit<Input, Output>('a,c', {a: 1, b: 2, c: 3, d: 4})
result // $ExpectType Output
result.b // $ExpectType number
const curriedResult = omit<Input, Output>('a,c')({
a: 1,
b: 2,
c: 3,
d: 4,
})
curriedResult.b // $ExpectType number
})
it('without passing type', () => {
const result = omit('a,c', {a: 1, b: 2, c: 3, d: 4})
result // $ExpectType unknown
})
})
const R = require('../../dist/rambda.js')
const obj = {
a: 'foo',
b: 'bar',
c: 'baz',
}
const toOmit = ['a', 'c']
const omit = [
{
label: 'Rambda',
fn: () => {
R.omit(toOmit, obj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.omit(toOmit, obj)
},
},
{
label: 'Lodash',
fn: () => {
_.omit(obj, toOmit)
},
},
]
once<T extends (...args: any[]) => any>(func: T): T
It returns a function, which invokes only once fn function.
once<T extends (...args: any[]) => any>(func: T): T;
import {curry} from './curry'
function onceFn(fn, context) {
let result
return function () {
if (fn) {
result = fn.apply(context || this, arguments)
fn = null
}
return result
}
}
export function once(fn, context) {
if (arguments.length === 1) {
const wrap = onceFn(fn, context)
return curry(wrap)
}
return onceFn(fn, context)
}
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)
})
import {once} from 'rambda'
describe('R.once', () => {
it('happy', () => {
const runOnce = once((x: number) => {
return x + 2
})
const result = runOnce(1)
result // $ExpectType number
})
})
Logical OR
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.
over<T>(lens: Lens, fn: Arity1Fn, value: T): T;
over<T>(lens: Lens, fn: Arity1Fn, value: T[]): T[];
over(lens: Lens, fn: Arity1Fn): <T>(value: T) => T;
over(lens: Lens, fn: Arity1Fn): <T>(value: T[]) => T[];
over(lens: Lens): <T>(fn: Arity1Fn, value: T) => T;
over(lens: Lens): <T>(fn: Arity1Fn, value: T[]) => T[];
import {curry} from './curry'
const Identity = x => ({
x,
map: fn => Identity(fn(x)),
})
function overFn(lens, fn, object) {
return lens(x => Identity(fn(x)))(object).x
}
export const over = curry(overFn)
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'])
})
const R = require('../../dist/rambda.js')
const testObj = {a: 1}
const last = [
{
label: 'Rambda',
fn: () => {
R.over(R.lensProp('a'), R.inc, testObj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.over(Ramda.lensProp('a'), Ramda.inc, testObj)
},
},
]
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.
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;
export function partial(fn, ...args) {
const len = fn.length
return (...rest) => {
if (args.length + rest.length >= len) {
return fn(...args, ...rest)
}
return partial(fn, ...[...args, ...rest])
}
}
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!')
})
import {partial} from 'rambda'
describe('R.partial', () => {
it('happy', () => {
function greet(
salutation: string,
title: string,
firstName: string,
lastName: string
) {
return `${salutation}, ${title} ${firstName} ${lastName}!`
}
const sayHello = partial(greet, ['Hello'])
const sayHelloToMs = partial(sayHello, ['Ms.'])
const result = sayHelloToMs('Jane', 'Jones')
result // $ExpectType string
})
})
partition<T>(
predicate: Predicate<T>,
input: T[]
): [T[], T[]]
It will return array of two objects/arrays according to predicate function. The first member holds all instances of input that pass the predicate function, while the second member - those who doesn't.
partition<T>(
predicate: Predicate<T>,
input: T[]
): [T[], T[]];
partition<T>(
predicate: Predicate<T>
): (input: 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 {_isArray} from './_internals/_isArray'
export function partitionObject(predicate, iterable) {
const yes = {}
const no = {}
Object.entries(iterable).forEach(([prop, value]) => {
if (predicate(value, prop)) {
yes[prop] = value
} else {
no[prop] = value
}
})
return [yes, no]
}
export function partitionArray(predicate, list, indexed = false) {
const yes = []
const no = []
let counter = -1
while (counter++ < list.length - 1) {
if (
indexed ? predicate(list[counter], counter) : predicate(list[counter])
) {
yes.push(list[counter])
} else {
no.push(list[counter])
}
}
return [yes, no]
}
export function partition(predicate, iterable) {
if (arguments.length === 1) {
return listHolder => partition(predicate, listHolder)
}
if (!_isArray(iterable)) return partitionObject(predicate, iterable)
return partitionArray(predicate, iterable)
}
import {partition} from './partition'
test('with array', () => {
const predicate = x => 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)
})
import {partition} from 'rambda'
describe('R.partition', () => {
it('with array', () => {
const predicate = (x: number) => {
return x > 2
}
const list = [1, 2, 3, 4]
const result = partition(predicate, list)
const curriedResult = partition(predicate)(list)
result // $ExpectType [number[], number[]]
curriedResult // $ExpectType [number[], number[]]
})
/*
TODO
revert to old version of `dtslint` and `R.partition` typing
as there is diff between VSCode types(correct) and dtslint(incorrect)
it('with object', () => {
const predicate = (value: number, prop?: string) => {
return value > 2
}
const hash = {
a: 1,
b: 2,
c: 3,
d: 4,
}
const result = partition(predicate, hash)
const curriedResult = partition(predicate)(hash)
result[0] // $xExpectType { [key: string]: number; }
result[1] // $xExpectType { [key: string]: number; }
curriedResult[0] // $xExpectType { [key: string]: number; }
curriedResult[1] // $xExpectType { [key: string]: number; }
})
*/
})
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.
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;
export function path(pathInput, obj) {
if (arguments.length === 1) return _obj => path(pathInput, _obj)
if (obj === null || obj === undefined) {
return undefined
}
let willReturn = obj
let counter = 0
const pathArrValue =
typeof pathInput === 'string' ? pathInput.split('.') : pathInput
while (counter < pathArrValue.length) {
if (willReturn === null || willReturn === undefined) {
return undefined
}
if (willReturn[pathArrValue[counter]] === null) return undefined
willReturn = willReturn[pathArrValue[counter]]
counter++
}
return willReturn
}
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()
})
test('null is not a valid path', () => {
expect(path('audio_tracks', {a: 1, audio_tracks: null})).toBeUndefined()
})
import {path} from 'rambda'
interface Input {
a: number
b: {
c: boolean
}
}
describe('R.path', () => {
it('without specified input type', () => {
const input = {a: 1, b: {c: true}}
const result = path<boolean>('a.b.c', input)
const curriedResult = path<boolean>('a.b.c')(input)
result // $ExpectType boolean | undefined
curriedResult // $ExpectType boolean | undefined
})
it('without specified output type', () => {
const input = {a: 1, b: {c: true}}
const result = path('a.b.c', input)
result // $ExpectType unknown
})
it('with string as path', () => {
const input: Input = {a: 1, b: {c: true}}
const resultA = path<boolean>('a.b.c', input)
const resultB = path<boolean>('a.b.c')(input)
resultA // $ExpectType boolean | undefined
resultB // $ExpectType boolean | undefined
})
it('with array as path', () => {
const input: Input = {a: 1, b: {c: true}}
const resultA = path<boolean>(['a', 'b', 'c'], input)
const resultB = path<boolean>(['a', 'b', 'c'])(input)
resultA // $ExpectType boolean | undefined
resultB // $ExpectType boolean | undefined
})
})
describe('path with specified input', () => {
it('with string as path', () => {
const input: Input = {a: 1, b: {c: true}}
// const wrongInput = { a: 1, b: true }
// const resultA = path<Input, boolean>('a.b.c', wrongInput)
const resultA = path<Input, boolean>('a.b.c', input)
const resultB = path<Input, boolean>('a.b.c')(input)
resultA // $ExpectType boolean | undefined
resultB // $ExpectType boolean | undefined
})
it('with array as path', () => {
const input: Input = {a: 1, b: {c: true}}
const resultA = path<Input, boolean>(['a', 'b', 'c'], input)
const resultB = path<Input, boolean>(['a', 'b', 'c'])(input)
resultA // $ExpectType boolean | undefined
resultB // $ExpectType boolean | undefined
})
})
const R = require('../../dist/rambda.js')
const obj = {a: {b: 2}}
const pathInput = ['a', 'b']
const path = [
{
label: 'Rambda',
fn: () => {
R.path(pathInput, obj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.path(pathInput, obj)
},
},
{
label: 'Lodash',
fn: () => {
_.get(obj, pathInput)
},
},
]
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.
pathEq(pathToSearch: Path, target: any, input: any): boolean;
pathEq(pathToSearch: Path, target: any): (input: any) => boolean;
pathEq(pathToSearch: Path): (target: any) => (input: any) => boolean;
import {curry} from './curry'
import {equals} from './equals'
import {path} from './path'
function pathEqFn(pathToSearch, target, input) {
return equals(path(pathToSearch, input), target)
}
export const pathEq = curry(pathEqFn)
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()
})
import {pathEq} from 'rambda'
describe('R.pathEq', () => {
it('with string path', () => {
const pathToSearch = 'a.b.c'
const input = {a: {b: {c: 1}}}
const target = {c: 1}
const result = pathEq(pathToSearch, input, target)
const curriedResult = pathEq(pathToSearch, input, target)
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
it('with array path', () => {
const pathToSearch = ['a', 'b', 'c']
const input = {a: {b: {c: 1}}}
const target = {c: 1}
const result = pathEq(pathToSearch, input, target)
const curriedResult = pathEq(pathToSearch, input, target)
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
})
describe('with ramda specs', () => {
const testPath = ['x', 0, 'y']
const testObj = {
x: [
{y: 2, z: 3},
{y: 4, z: 5},
],
}
const result1 = pathEq(testPath, 2, testObj)
const result2 = pathEq(testPath, 2)(testObj)
const result3 = pathEq(testPath)(2)(testObj)
result1 // $ExpectType boolean
result2 // $ExpectType boolean
result3 // $ExpectType boolean
})
pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T
It reads obj input and returns either R.path(pathToSearch, obj) result or defaultValue input.
pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T;
pathOr<T>(defaultValue: T, pathToSearch: Path): (obj: any) => T;
pathOr<T>(defaultValue: T): (pathToSearch: Path) => (obj: any) => T;
import {curry} from './curry'
import {defaultTo} from './defaultTo'
import {path} from './path'
function pathOrFn(defaultValue, pathInput, obj) {
return defaultTo(defaultValue, path(pathInput, obj))
}
export const pathOr = curry(pathOrFn)
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')
})
import {pathOr} from 'rambda'
describe('R.pathOr', () => {
it('with string path', () => {
const x = pathOr<string>('foo', 'x.y', {x: {y: 'bar'}})
x // $ExpectType string
})
it('with array path', () => {
const x = pathOr<string>('foo', ['x', 'y'], {x: {y: 'bar'}})
x // $ExpectType string
})
it('without passing type looks bad', () => {
const x = pathOr('foo', 'x.y', {x: {y: 'bar'}})
x // $ExpectType "foo"
})
it('curried', () => {
const x = pathOr<string>('foo', 'x.y')({x: {y: 'bar'}})
x // $ExpectType string
})
})
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.
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 {path} from './path'
export function paths(pathsToSearch, obj) {
if (arguments.length === 1) {
return _obj => paths(pathsToSearch, _obj)
}
return pathsToSearch.map(singlePath => path(singlePath, obj))
}
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])
})
import {paths} from 'rambda'
interface Input {
a: number
b: number
c: number
}
const input: Input = {a: 1, b: 2, c: 3}
describe('R.paths', () => {
it('with dot notation', () => {
const result = paths<number>(['a.b.c', 'foo.bar'], input)
result // $ExpectType (number | undefined)[]
})
it('without type', () => {
const result = paths(['a.b.c', 'foo.bar'], input)
result // $ExpectType unknown[]
})
it('with array as path', () => {
const result = paths<number>([['a', 'b', 'c'], ['foo.bar']], input)
result // $ExpectType (number | undefined)[]
})
it('curried', () => {
const result = paths<number>([['a', 'b', 'c'], ['foo.bar']])(input)
result // $ExpectType (number | undefined)[]
})
})
pick<T, K extends string | number | symbol>(propsToPick: 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.
pick<T, K extends string | number | symbol>(propsToPick: K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;
pick<K extends string | number | symbol>(propsToPick: 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;
export function pick(propsToPick, input) {
if (arguments.length === 1) return _input => pick(propsToPick, _input)
if (input === null || input === undefined) {
return undefined
}
const keys =
typeof propsToPick === 'string' ? propsToPick.split(',') : propsToPick
const willReturn = {}
let counter = 0
while (counter < keys.length) {
if (keys[counter] in input) {
willReturn[keys[counter]] = input[keys[counter]]
}
counter++
}
return willReturn
}
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('with list indexes as props', () => {
const list = [1, 2, 3]
const expected = {0: 1, 2: 3}
expect(pick([0, 2, 3], list)).toEqual(expected)
expect(pick('0,2,3', list)).toEqual(expected)
})
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",
}
`)
})
import {pick} from 'rambda'
const input = {a: 'foo', b: 2, c: 3, d: 4}
describe('R.pick with array as props input', () => {
it('without passing type', () => {
const result = pick(['a', 'c'], input)
result.a // $ExpectType string
result.c // $ExpectType number
})
})
describe('R.pick with string as props input', () => {
interface Input {
a: string
b: number
c: number
d: number
}
interface Output {
a: string
c: number
}
it('explicitly declare output', () => {
const result = pick<Output>('a,c', input)
result // $ExpectType Output
result.a // $ExpectType string
result.c // $ExpectType number
const curriedResult = pick<Output>('a,c')(input)
curriedResult.a // $ExpectType string
})
it('explicitly declare input and output', () => {
const result = pick<Input, Output>('a,c', input)
result // $ExpectType Output
result.a // $ExpectType string
const curriedResult = pick<Input, Output>('a,c')(input)
curriedResult.a // $ExpectType string
})
it('without passing type', () => {
const result = pick('a,c', input)
result // $ExpectType unknown
})
})
const R = require('../../dist/rambda.js')
const obj = {
a: 'foo',
b: 'bar',
c: 'baz',
}
const pickInput = ['a', 'c']
const pick = [
{
label: 'Rambda',
fn: () => {
R.pick(pickInput, obj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.pick(pickInput, obj)
},
},
{
label: 'Lodash',
fn: () => {
_.pick(obj, pickInput)
},
},
]
pickAll<T, U>(propsToPick: string[], input: T): U
Same as R.pick but it won't skip the missing props, i.e. it will assign them to undefined.
pickAll<T, U>(propsToPick: string[], input: T): U;
pickAll<T, U>(propsToPick: string[]): (input: T) => U;
pickAll<T, U>(propsToPick: string, input: T): U;
pickAll<T, U>(propsToPick: string): (input: T) => U;
export function pickAll(propsToPick, obj) {
if (arguments.length === 1) return _obj => pickAll(propsToPick, _obj)
if (obj === null || obj === undefined) {
return undefined
}
const keysValue =
typeof propsToPick === 'string' ? propsToPick.split(',') : propsToPick
const willReturn = {}
let counter = 0
while (counter < keysValue.length) {
if (keysValue[counter] in obj) {
willReturn[keysValue[counter]] = obj[keysValue[counter]]
} else {
willReturn[keysValue[counter]] = undefined
}
counter++
}
return willReturn
}
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',
})
})
import {pickAll} from 'rambda'
interface Input {
a: string
b: number
c: number
d: number
}
interface Output {
a?: string
c?: number
}
const input = {a: 'foo', b: 2, c: 3, d: 4}
describe('R.pickAll with array as props input', () => {
it('without passing type', () => {
const result = pickAll(['a', 'c'], input)
result // $ExpectType unknown
})
it('without passing type + curry', () => {
const result = pickAll(['a', 'c'])(input)
result // $ExpectType unknown
})
it('explicitly passing types', () => {
const result = pickAll<Input, Output>(['a', 'c'], input)
result.a // $ExpectType string | undefined
result.c // $ExpectType number | undefined
})
it('explicitly passing types + curry', () => {
const result = pickAll<Input, Output>(['a', 'c'])(input)
result.a // $ExpectType string | undefined
result.c // $ExpectType number | undefined
})
})
describe('R.pickAll with string as props input', () => {
it('without passing type', () => {
const result = pickAll('a,c', input)
result // $ExpectType unknown
})
it('without passing type + curry', () => {
const result = pickAll('a,c')(input)
result // $ExpectType unknown
})
it('explicitly passing types', () => {
const result = pickAll<Input, Output>('a,c', input)
result.a // $ExpectType string | undefined
result.c // $ExpectType number | undefined
})
it('explicitly passing types + curry', () => {
const result = pickAll<Input, Output>('a,c')(input)
result.a // $ExpectType string | undefined
result.c // $ExpectType number | undefined
})
})
It performs left-to-right function composition.
pluck<K extends keyof T, T>(property: K, list: T[]): T[K][]
It returns list of the values of property taken from the all objects inside list.
pluck<K extends keyof T, T>(property: K, list: T[]): T[K][];
pluck<T>(property: number, list: { [k: number]: T }[]): T[];
pluck<P extends string>(property: P): <T>(list: Record<P, T>[]) => T[];
pluck(property: number): <T>(list: { [k: number]: T }[]) => T[];
import {map} from './map'
export function pluck(property, list) {
if (arguments.length === 1) return _list => pluck(property, _list)
const willReturn = []
map(x => {
if (x[property] !== undefined) {
willReturn.push(x[property])
}
}, list)
return willReturn
}
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])
})
import {pluck} from 'rambda'
describe('R.pluck', () => {
it('with object', () => {
interface ListMember {
a: number
b: string
}
const input: ListMember[] = [
{a: 1, b: 'foo'},
{a: 2, b: 'bar'},
]
const resultA = pluck('a', input)
const resultB = pluck('b')(input)
resultA // $ExpectType number[]
resultB // $ExpectType string[]
})
it('with array', () => {
const input = [
[1, 2],
[3, 4],
[5, 6],
]
const result = pluck(0, input)
const resultCurry = pluck(0)(input)
result // $ExpectType number[]
resultCurry // $ExpectType number[]
})
})
prepend<T>(x: T, input: T[]): T[]
It adds element x at the beginning of list.
prepend<T>(x: T, input: T[]): T[];
prepend<T>(x: T): (input: T[]) => T[];
export function prepend(x, input) {
if (arguments.length === 1) return _input => prepend(x, _input)
if (typeof input === 'string') return [x].concat(input.split(''))
return [x].concat(input)
}
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'])
})
import {prepend} from 'rambda'
const list = [1, 2, 3]
describe('R.prepend', () => {
it('happy', () => {
const result = prepend(4, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = prepend(4)(list)
result // $ExpectType number[]
})
})
product(list: number[]): number
product(list: number[]): number;
import {multiply} from './multiply'
import {reduce} from './reduce'
export const product = reduce(multiply, 1)
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)
})
import {product} from 'rambda'
describe('R.product', () => {
it('happy', () => {
const result = product([1, 2, 3])
result // $ExpectType number
})
})
prop<P extends keyof O, O>(propToFind: P, obj: O): O[P]
It returns the value of property propToFind in obj.
If there is no such property, it returns undefined.
prop<P extends keyof O, O>(propToFind: P, obj: O): O[P];
prop<P extends keyof O, O>(propToFind: P): (obj: O) => O[P];
prop<P extends string | number>(propToFind: P): <T>(obj: Record<P, T>) => T;
prop<P extends string | number, T>(propToFind: P): (obj: Record<P, T>) => T;
export function prop(propToFind, obj) {
if (arguments.length === 1) return _obj => prop(propToFind, _obj)
if (!obj) return undefined
return obj[propToFind]
}
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)
})
import {pipe, prop} from 'rambda'
describe('R.prop', () => {
const obj = {a: 1, b: 'foo'}
type Something = {a?: number, b?: string}
it('issue #553', () => {
const result = prop('e', {e: 'test1', d: 'test2'})
const curriedResult = prop<string>('e')({e: 'test1', d: 'test2'})
result // $ExpectType string
curriedResult // $ExpectType string
})
it('happy', () => {
const result = prop('a', obj)
result // $ExpectType number
})
it('curried', () => {
const result = prop('b')(obj)
result // $ExpectType string
})
it('curried with explicit object type', () => {
const result = prop<'a', Something>('a')(obj)
result // $ExpectType number | undefined
})
it('curried with implicit object type', () => {
const result = pipe((value) => value as Something, prop('b'))(obj)
result // $ExpectType string | undefined
})
it('curried with explicit result type', () => {
const result = prop<'b', string>('b')(obj)
result // $ExpectType string
})
})
describe('with number as prop', () => {
const list = [1, 2, 3]
const index = 1
it('happy', () => {
const result = prop(index, list)
result // $ExpectType number
})
it('curried require explicit type', () => {
const result = prop<number>(index)(list)
result // $ExpectType number
})
})
const R = require('../../dist/rambda.js')
const obj = {
a: {c: 2},
b: 1,
}
const propInput = 'b'
const prop = [
{
label: 'Rambda',
fn: () => {
R.prop(propInput, obj)
R.prop(propInput)(obj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.prop(propInput, obj)
Ramda.prop(propInput)(obj)
},
},
]
propEq<K extends string | number>(propToFind: K, valueToMatch: any, obj: Record<K, any>): boolean
It returns true if obj has property propToFind and its value is equal to valueToMatch.
propEq<K extends string | number>(propToFind: K, valueToMatch: any, obj: Record<K, any>): boolean;
propEq<K extends string | number>(propToFind: K, valueToMatch: any): (obj: Record<K, any>) => boolean;
propEq<K extends string | number>(propToFind: K): {
(valueToMatch: any, obj: Record<K, any>): boolean;
(valueToMatch: any): (obj: Record<K, any>) => boolean;
};
import {curry} from './curry'
function propEqFn(propToFind, valueToMatch, obj) {
if (!obj) return false
return obj[propToFind] === valueToMatch
}
export const propEq = curry(propEqFn)
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()
})
import {propEq} from 'rambda'
const property = 'foo'
const numberProperty = 1
const value = 'bar'
const obj = {[property]: value}
const objWithNumberIndex = {[numberProperty]: value}
describe('R.propEq', () => {
it('happy', () => {
const result = propEq(property, value, obj)
result // $ExpectType boolean
})
it('number is property', () => {
const result = propEq(1, value, objWithNumberIndex)
result // $ExpectType boolean
})
it('with optional property', () => {
interface MyType {
optional?: string | number
}
const myObject: MyType = {}
const valueToFind = '1111'
// $ExpectError
propEq('optional', valueToFind, myObject)
// $ExpectError
propEq('optional', valueToFind, myObject)
})
it('imported from @types/ramda', () => {
interface A {
foo: string | null
}
const obj: A = {
foo: 'bar',
}
const value = ''
const result = propEq('foo', value)(obj)
result // $ExpectType boolean
// $ExpectError
propEq('bar', value)(obj)
})
})
const R = require('../../dist/rambda.js')
const obj = {
a: {c: 2},
b: 1,
}
const propInput = 'b'
const expected = {c: 2}
const propEq = [
{
label: 'Rambda',
fn: () => {
R.propEq('a')(expected)(obj)
R.propEq('a', expected)(obj)
R.propEq('a', expected, obj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.propEq('a')(expected)(obj)
Ramda.propEq('a', expected)(obj)
Ramda.propEq('a', expected, obj)
},
},
]
propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>
It returns true if property of obj is from target type.
propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>;
propIs<C extends new (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, InstanceType<C>>;
propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, ReturnType<C>>;
propIs<C extends new (...args: any[]) => any, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, InstanceType<C>>;
propIs<C extends (...args: any[]) => any>(type: C): {
<K extends keyof any>(name: K, obj: any): obj is Record<K, ReturnType<C>>;
<K extends keyof any>(name: K): (obj: any) => obj is Record<K, ReturnType<C>>;
};
propIs<C extends new (...args: any[]) => any>(type: C): {
<K extends keyof any>(name: K, obj: any): obj is Record<K, InstanceType<C>>;
<K extends keyof any>(name: K): (obj: any) => obj is Record<K, InstanceType<C>>;
};
import {curry} from './curry'
import {is} from './is'
function propIsFn(targetPrototype, property, obj) {
return is(targetPrototype, obj[property])
}
export const propIs = curry(propIsFn)
import {propIs} from './propIs'
const obj = {a: 1, b: 'foo'}
test('when true', () => {
expect(propIs(Number, 'a', obj)).toBeTrue()
expect(propIs(String, 'b', obj)).toBeTrue()
})
test('when false', () => {
expect(propIs(String, 'a', obj)).toBeFalse()
expect(propIs(Number, 'b', obj)).toBeFalse()
})
import {propIs} from 'rambda'
const property = 'a'
const obj = {a: 1}
describe('R.propIs', () => {
it('happy', () => {
const result = propIs(Number, property, obj)
result // $ExpectType boolean
})
it('curried', () => {
const result = propIs(Number, property)(obj)
result // $ExpectType boolean
})
})
propOr<T, P extends string>(defaultValue: T, property: P, obj: Partial<Record<P, T>> | undefined): T
It returns either defaultValue or the value of property in obj.
propOr<T, P extends string>(defaultValue: T, property: P, obj: Partial<Record<P, T>> | undefined): T;
propOr<T, P extends string>(defaultValue: T, property: P): (obj: Partial<Record<P, T>> | undefined) => T;
propOr<T>(defaultValue: T): {
<P extends string>(property: P, obj: Partial<Record<P, T>> | undefined): T;
<P extends string>(property: P): (obj: Partial<Record<P, T>> | undefined) => T;
}
import {curry} from './curry'
import {defaultTo} from './defaultTo'
function propOrFn(defaultValue, property, obj) {
if (!obj) return defaultValue
return defaultTo(defaultValue, obj[property])
}
export const propOr = curry(propOrFn)
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')
})
import {propOr} from 'rambda'
const obj = {foo: 'bar'}
const property = 'foo'
const fallback = 'fallback'
describe('R.propOr', () => {
it('happy', () => {
const result = propOr(fallback, property, obj)
result // $ExpectType string
})
it('curry 1', () => {
const result = propOr(fallback)(property, obj)
result // $ExpectType string
})
it('curry 2', () => {
const result = propOr(fallback, property)(obj)
result // $ExpectType string
})
it('curry 3', () => {
const result = propOr(fallback)(property)(obj)
result // $ExpectType string
})
})
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.
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 {_isArray} from './_internals/_isArray'
import {mapArray} from './map'
export function props(propsToPick, obj) {
if (arguments.length === 1) {
return _obj => props(propsToPick, _obj)
}
if (!_isArray(propsToPick)) {
throw new Error('propsToPick is not a list')
}
return mapArray(prop => obj[prop], propsToPick)
}
import {props} from './props'
const obj = {
a: 1,
b: 2,
}
const propsToPick = ['a', 'c']
test('happy', () => {
const result = props(propsToPick, obj)
expect(result).toEqual([1, undefined])
})
test('curried', () => {
const result = props(propsToPick)(obj)
expect(result).toEqual([1, undefined])
})
test('wrong input', () => {
expect(() => props(null)(obj)).toThrow()
})
import {props} from 'rambda'
const obj = {a: 1, b: 2}
describe('R.props', () => {
it('happy', () => {
const result = props(['a', 'b'], obj)
result // $ExpectType number[]
})
it('curried', () => {
const result = props(['a', 'b'])(obj)
result // $ExpectType number[]
})
})
range(startInclusive: number, endExclusive: number): number[]
It returns list of numbers between startInclusive to endExclusive markers.
range(startInclusive: number, endExclusive: number): number[];
range(startInclusive: number): (endExclusive: number) => number[];
export function range(start, end) {
if (arguments.length === 1) return _end => range(start, _end)
if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
throw new TypeError('Both arguments to range must be numbers')
}
if (end < start) return []
const len = end - start
const willReturn = Array(len)
for (let i = 0; i < len; i++) {
willReturn[i] = start + i
}
return willReturn
}
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])
})
import {range} from 'rambda'
describe('R.range', () => {
it('happy', () => {
const result = range(1, 4)
result // $ExpectType number[]
})
it('curried', () => {
const result = range(1)(4)
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const start = 12
const end = 22
const range = [
{
label: 'Rambda',
fn: () => {
R.range(start, end)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.range(start, end)
},
},
{
label: 'Lodash',
fn: () => {
_.range(start, end)
},
},
]
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;
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 {_isArray} from './_internals/_isArray'
import {_keys} from './_internals/_keys'
import {curry} from './curry'
function reduceFn(reducer, acc, list) {
if (!_isArray(list)) {
throw new TypeError('reduce: list must be array or iterable')
}
let index = 0
const len = list.length
while (index < len) {
acc = reducer(acc, list[index], index, list)
index++
}
return acc
}
export const reduce = curry(reduceFn)
import {reduce} from './reduce'
const reducer = (prev, current, i) => {
expect(i).toBeNumber()
return prev + current
}
const initialValue = 1
const list = [1, 2, 3]
const ERROR = 'reduce: list must be array or iterable'
test('happy', () => {
expect(reduce(reducer, initialValue, list)).toEqual(7)
})
test('with object as iterable', () => {
expect(() =>
reduce(reducer, initialValue, {
a: 1,
b: 2,
})
).toThrowWithMessage(TypeError, ERROR)
})
test('with undefined as iterable', () => {
expect(() => reduce(reducer, 0, null)).toThrowWithMessage(TypeError, ERROR)
})
import {reduce} from 'rambda'
describe('R.reduce', () => {
it('happy', () => {
const result = reduce<number, number>(
(acc, elem) => {
acc // $ExpectType number
elem // $ExpectType number
return acc + elem
},
1,
[1, 2, 3]
)
result // $ExpectType number
})
it('with two types', () => {
const result = reduce<number, string>(
(acc, elem) => {
acc // $ExpectType string
elem // $ExpectType number
return `${acc}${elem}`
},
'foo',
[1, 2, 3]
)
result // $ExpectType string
})
it('with index', () => {
const result = reduce<number, number>(
(acc, elem, i) => {
acc // $ExpectType number
elem // $ExpectType number
i // $ExpectType number
return acc + elem
},
1,
[1, 2, 3]
)
result // $ExpectType number
})
it('fallback', () => {
const result = reduce(
(acc, val) => {
acc // $ExpectType number
return acc + val
},
1,
[1, 2, 3]
)
result // $ExpectType number
})
it('fallback with index', () => {
const result = reduce(
(acc, val, i) => {
acc // $ExpectType number
i // $ExpectType number
return acc + val
},
1,
[1, 2, 3]
)
result // $ExpectType number
})
it('fallback with two types', () => {
const result = reduce(
(acc, val) => {
acc // $ExpectType string
return acc + val
},
'foo',
[1, 2, 3]
)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const fn = (acc, value) => acc + value
const holder = [1, 2, 3]
const acc = ''
const reduce = [
{
label: 'Rambda',
fn: () => {
R.reduce(fn, acc, holder)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.reduce(fn, acc, holder)
},
},
{
label: 'Lodash',
fn: () => {
_.reduce(holder, fn, acc)
},
},
]
reject<T>(predicate: Predicate<T>, list: T[]): T[]
It has the opposite effect of R.filter.
reject<T>(predicate: Predicate<T>, list: T[]): T[];
reject<T>(predicate: Predicate<T>): (list: T[]) => T[];
reject<T>(predicate: Predicate<T>, obj: Dictionary<T>): Dictionary<T>;
reject<T, U>(predicate: Predicate<T>): (obj: Dictionary<T>) => Dictionary<T>;
import {filter} from './filter'
export function reject(predicate, list) {
if (arguments.length === 1) return _list => reject(predicate, _list)
return filter(x => !predicate(x), list)
}
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,
}
expect(reject(isOdd, obj)).toEqual({
b: 2,
d: 4,
})
})
import {reject} from 'rambda'
describe('R.reject with array', () => {
it('happy', () => {
const result = reject(
x => {
x // $ExpectType number
return x > 1
},
[1, 2, 3]
)
result // $ExpectType number[]
})
it('curried require explicit type', () => {
const result = reject<number>(x => {
x // $ExpectType number
return x > 1
})([1, 2, 3])
result // $ExpectType number[]
})
})
describe('R.reject with objects', () => {
it('happy', () => {
const result = reject(
x => {
x // $ExpectType number
return x > 1
},
{a: 1, b: 2}
)
result // $ExpectType Dictionary<number>
})
it('curried require dummy type', () => {
const result = reject<number, any>(x => {
return x > 1
})({a: 1, b: 2})
result // $ExpectType Dictionary<number>
})
})
repeat<T>(x: T): (timesToRepeat: number) => T[]
repeat<T>(x: T): (timesToRepeat: number) => T[];
repeat<T>(x: T, timesToRepeat: number): T[];
export function repeat(x, timesToRepeat) {
if (arguments.length === 1) {
return _timesToRepeat => repeat(x, _timesToRepeat)
}
return Array(timesToRepeat).fill(x)
}
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()
})
import {repeat} from 'rambda'
describe('R.repeat', () => {
it('happy', () => {
const result = repeat(4, 7)
result // $ExpectType number[]
})
it('curried', () => {
const result = repeat(4)(7)
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const num = 10
const str = 'foo'
const repeat = [
{
label: 'Rambda',
fn: () => {
R.repeat(str, num)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.repeat(str, num)
},
},
{
label: 'Lodash',
fn: () => {
_.repeat(str, num)
},
},
]
replace(strOrRegex: RegExp | string, replacer: string, str: string): string
It replaces strOrRegex found in str with replacer.
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 {curry} from './curry'
function replaceFn(pattern, replacer, str) {
return str.replace(pattern, replacer)
}
export const replace = curry(replaceFn)
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')
})
import {replace} from 'rambda'
const str = 'foo bar foo'
const replacer = 'bar'
describe('R.replace', () => {
it('happy', () => {
const result = replace(/foo/g, replacer, str)
result // $ExpectType string
})
it('with string as search pattern', () => {
const result = replace('foo', replacer, str)
result // $ExpectType string
})
})
describe('R.replace - curried', () => {
it('happy', () => {
const result = replace(/foo/g, replacer)(str)
result // $ExpectType string
})
it('with string as search pattern', () => {
const result = replace('foo', replacer)(str)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const replace = [
{
label: 'Rambda',
fn: () => {
R.replace(/\s/g, '|', 'foo bar baz')
},
},
{
label: 'Ramda',
fn: () => {
Ramda.replace(/\s/g, '|', 'foo bar baz')
},
},
{
label: 'Lodash',
fn: () => {
_.replace('foo bar baz', /\s/g, '|')
},
},
]
reverse<T>(input: T[]): T[]
It returns a reversed copy of list or string input.
reverse<T>(input: T[]): T[];
reverse(input: string): string;
export function reverse(listOrString) {
if (typeof listOrString === 'string') {
return listOrString.split('').reverse().join('')
}
const clone = listOrString.slice()
return clone.reverse()
}
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])
})
import {reverse} from 'rambda'
const list = [1, 2, 3, 4, 5]
describe('R.reverse', () => {
it('happy', () => {
const result = reverse(list)
result // $ExpectType number[]
})
})
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.
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 {always} from './always'
import {curry} from './curry'
import {over} from './over'
function setFn(lens, replacer, x) {
return over(lens, always(replacer), x)
}
export const set = curry(setFn)
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])
})
const R = require('../../dist/rambda.js')
const testObj = {a: 1}
const last = [
{
label: 'Rambda',
fn: () => {
R.set(R.lensProp('a'), 2, testObj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.set(Ramda.lensProp('a'), 2, testObj)
},
},
]
slice(from: number, to: number, input: string): string
slice(from: number, to: number, input: string): string;
slice<T>(from: number, to: number, input: T[]): T[];
slice(from: number, to: number): {
(input: string): string;
<T>(input: T[]): T[];
};
slice(from: number): {
(to: number, input: string): string;
<T>(to: number, input: T[]): T[];
};
import {curry} from './curry'
function sliceFn(from, to, list) {
return list.slice(from, to)
}
export const slice = curry(sliceFn)
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')
})
import {slice} from 'rambda'
const list = [1, 2, 3, 4, 5]
describe('R.slice', () => {
it('happy', () => {
const result = slice(1, 3, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = slice(1, 3)(list)
result // $ExpectType number[]
})
})
sort<T>(sortFn: (a: T, b: T) => number, list: T[]): T[]
It returns copy of list sorted by sortFn function, where sortFn needs to return only -1, 0 or 1.
sort<T>(sortFn: (a: T, b: T) => number, list: T[]): T[];
sort<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
import {cloneList} from './_internals/cloneList'
export function sort(sortFn, list) {
if (arguments.length === 1) return _list => sort(sortFn, _list)
return cloneList(list).sort(sortFn)
}
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')
})
import {sort} from 'rambda'
const list = [3, 0, 5, 2, 1]
function sortFn(a: number, b: number): number {
return a > b ? 1 : -1
}
describe('R.sort', () => {
it('happy', () => {
const result = sort(sortFn, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = sort(sortFn)(list)
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const list = ['foo', 'bar', 'baz']
const fn = (a, b) => (a > b ? -1 : 1)
const replace = [
{
label: 'Rambda',
fn: () => {
R.sort(fn, list)
R.sort(fn)(list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.sort(fn, list)
Ramda.sort(fn)(list)
},
},
]
sortBy<T>(sortFn: (a: T) => Ord, list: T[]): T[]
It returns copy of list sorted by sortFn function, where sortFn function returns a value to compare, i.e. it doesn't need to return only -1, 0 or 1.
sortBy<T>(sortFn: (a: T) => Ord, list: T[]): T[];
sortBy<T>(sortFn: (a: T) => Ord): (list: T[]) => T[];
sortBy(sortFn: (a: any) => Ord): <T>(list: T[]) => T[];
import {cloneList} from './_internals/cloneList'
export function sortBy(sortFn, list) {
if (arguments.length === 1) return _list => sortBy(sortFn, _list)
const clone = cloneList(list)
return clone.sort((a, b) => {
const aSortResult = sortFn(a)
const bSortResult = sortFn(b)
if (aSortResult === bSortResult) return 0
return aSortResult < bSortResult ? -1 : 1
})
}
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])
})
import {sortBy, pipe} from 'rambda'
interface Input {
a: number
}
describe('R.sortBy', () => {
it('passing type to sort function', () => {
function fn(x: any): number {
return x.a
}
function fn2(x: Input): number {
return x.a
}
const input = [{a: 2}, {a: 1}, {a: 0}]
const result = sortBy(fn, input)
const curriedResult = sortBy(fn2)(input)
result // $ExpectType { a: number; }[]
curriedResult // $ExpectType Input[]
result[0].a // $ExpectType number
curriedResult[0].a // $ExpectType number
})
it('passing type to sort function and list', () => {
function fn(x: Input): number {
return x.a
}
const input: Input[] = [{a: 2}, {a: 1}, {a: 0}]
const result = sortBy(fn, input)
const curriedResult = sortBy(fn)(input)
result // $ExpectType Input[]
curriedResult // $ExpectType Input[]
result[0].a // $ExpectType number
})
it('with R.pipe', () => {
interface Obj {
value: number
}
const fn = pipe(sortBy<Obj>(x => x.value))
const result = fn([{value: 1}, {value: 2}])
result // $ExpectType Obj[]
})
})
const R = require('../../dist/rambda.js')
const list = [{a: 2}, {a: 1}, {a: 0}]
const fn = x => x.a
const replace = [
{
label: 'Rambda',
fn: () => {
R.sortBy(fn, list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.sortBy(fn, list)
},
},
{
label: 'Lodash',
fn: () => {
_.sortBy(list, fn)
},
},
]
split(separator: string | RegExp): (str: string) => string[]
Curried version of String.prototype.split
split(separator: string | RegExp): (str: string) => string[];
split(separator: string | RegExp, str: string): string[];
export function split(separator, str) {
if (arguments.length === 1) return _str => split(separator, _str)
return str.split(separator)
}
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)
})
import {split} from 'rambda'
const str = 'foo|bar|baz'
const splitChar = '|'
describe('R.split', () => {
it('happy', () => {
const result = split(splitChar, str)
result // $ExpectType string[]
})
it('curried', () => {
const result = split(splitChar)(str)
result // $ExpectType string[]
})
})
const R = require('../../dist/rambda.js')
const str = 'foo|bar|baz'
const sep = '|'
const split = [
{
label: 'Rambda',
fn: () => {
R.split(sep, str)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.split(sep, str)
},
},
{
label: 'Lodash',
fn: () => {
_.split(str, sep)
},
},
]
splitAt<T>(index: number, input: T[]): [T[], T[]]
It splits string or array at a given index.
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 {_isArray} from './_internals/_isArray'
import {drop} from './drop'
import {maybe} from './maybe'
import {take} from './take'
export function splitAt(index, input) {
if (arguments.length === 1) {
return _list => splitAt(index, _list)
}
if (!input) throw new TypeError(`Cannot read property 'slice' of ${input}`)
if (!_isArray(input) && typeof input !== 'string') return [[], []]
const correctIndex = maybe(
index < 0,
input.length + index < 0 ? 0 : input.length + index,
index
)
return [take(correctIndex, input), drop(correctIndex, input)]
}
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)
expect(result).toEqual(['foo ', 'bar'])
})
test('with string - index is negative number', () => {
const result = splitAt(-2, str)
expect(result).toEqual(['foo b', 'ar'])
})
test('with string - index is out of scope', () => {
const result = splitAt(10, str)
expect(result).toEqual([str, ''])
})
test('with array - index is out of scope', () => {
const result = splitAt(4)(list)
expect(result).toEqual([[1, 2, 3], []])
})
const badInputs = [1, true, /foo/g, {}]
const throwingBadInputs = [null, undefined]
test('with bad inputs', () => {
throwingBadInputs.forEach(badInput => {
expect(() => splitAt(1, badInput)).toThrowWithMessage(
TypeError,
`Cannot read property 'slice' of ${badInput}`
)
expect(() => splitAtRamda(1, badInput)).toThrowWithMessage(
TypeError,
`Cannot read properties of ${badInput} (reading 'slice')`
)
})
badInputs.forEach(badInput => {
const result = splitAt(1, badInput)
const ramdaResult = splitAtRamda(1, badInput)
expect(result).toEqual(ramdaResult)
})
})
import {splitAt} from 'ramda'
const index = 1
const str = 'foo'
const list = [1, 2, 3]
describe('R.splitAt with array', () => {
it('happy', () => {
const result = splitAt(index, list)
result // $ExpectType [number[], number[]]
})
it('curried', () => {
const result = splitAt(index)(list)
result // $ExpectType [number[], number[]]
})
})
describe('R.splitAt with string', () => {
it('happy', () => {
const result = splitAt(index, str)
result // $ExpectType [string, string]
})
it('curried', () => {
const result = splitAt(index)(str)
result // $ExpectType [string, string]
})
})
splitEvery<T>(sliceLength: number, input: T[]): (T[])[]
It splits input into slices of sliceLength.
splitEvery<T>(sliceLength: number, input: T[]): (T[])[];
splitEvery(sliceLength: number, input: string): string[];
splitEvery(sliceLength: number): {
(input: string): string[];
<T>(input: T[]): (T[])[];
};
export function splitEvery(sliceLength, listOrString) {
if (arguments.length === 1) {
return _listOrString => splitEvery(sliceLength, _listOrString)
}
if (sliceLength < 1) {
throw new Error(
'First argument to splitEvery must be a positive integer'
)
}
const willReturn = []
let counter = 0
while (counter < listOrString.length) {
willReturn.push(listOrString.slice(counter, (counter += sliceLength)))
}
return willReturn
}
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'
)
})
import {splitEvery} from 'rambda'
const list = [1, 2, 3, 4, 5, 6, 7]
describe('R.splitEvery', () => {
it('happy', () => {
const result = splitEvery(3, list)
result // $ExpectType number[][]
})
it('curried', () => {
const result = splitEvery(3)(list)
result // $ExpectType number[][]
})
})
const R = require('../../dist/rambda.js')
const list = [1, 2, 3, 4, 5, 6, 7]
const splitEvery = [
{
label: 'Rambda',
fn: () => {
R.splitEvery(3, list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.splitEvery(3, list)
},
},
]
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.
splitWhen<T, U>(predicate: Predicate<T>, list: U[]): (U[])[];
splitWhen<T>(predicate: Predicate<T>): <U>(list: U[]) => (U[])[];
export function splitWhen(predicate, input) {
if (arguments.length === 1) {
return _input => splitWhen(predicate, _input)
}
if (!input)
throw new TypeError(`Cannot read property 'length' of ${input}`)
const preFound = []
const postFound = []
let found = false
let counter = -1
while (counter++ < input.length - 1) {
if (found) {
postFound.push(input[counter])
} else if (predicate(input[counter])) {
postFound.push(input[counter])
found = true
} else {
preFound.push(input[counter])
}
}
return [preFound, postFound]
}
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 properties of ${badInput} (reading 'length')`
)
})
badInputs.forEach(badInput => {
const result = splitWhen(equals(2), badInput)
const ramdaResult = splitWhenRamda(equals(2), badInput)
expect(result).toEqual(ramdaResult)
})
})
import {splitWhen} from 'rambda'
const list = [1, 2, 1, 2]
const predicate = (x: number) => x === 2
describe('R.splitWhen', () => {
it('happy', () => {
const result = splitWhen(predicate, list)
result // $ExpectType number[][]
})
it('curried', () => {
const result = splitWhen(predicate)(list)
result // $ExpectType number[][]
})
})
startsWith(target: string, str: string): boolean
When iterable is a string, then it behaves as String.prototype.startsWith.
When iterable is a list, then it uses R.equals to determine if the target list starts in the same way as the given target.
startsWith(target: string, str: string): boolean;
startsWith(target: string): (str: string) => boolean;
startsWith<T>(target: T[], list: T[]): boolean;
startsWith<T>(target: T[]): (list: T[]) => boolean;
import {equals} from './equals.js'
import {_isArray} from './_internals/_isArray.js'
export function startsWith(target, iterable) {
if (arguments.length === 1)
return _iterable => startsWith(target, _iterable)
if (typeof iterable === 'string') {
return iterable.startsWith(target)
}
if (!_isArray(target)) return false
let correct = true
const filtered = target.filter((x, index) => {
if (!correct) return false
const result = equals(x, iterable[index])
if (!result) correct = false
return result
})
return filtered.length === target.length
}
import {startsWith} from './startsWith'
import {possibleTargets, possibleIterables} from './endsWith.spec'
import {startsWith as startsWithRamda} from 'ramda'
import {compareCombinations} from './_internals/testUtils'
test('with string', () => {
expect(startsWith('foo', 'foo-bar')).toBeTrue()
expect(startsWith('baz')('foo-bar')).toBeFalse()
})
test('use R.equals with array', () => {
const list = [{a: 1}, {a: 2}, {a: 3}]
expect(startsWith({a: 1}, list)).toBeFalse()
expect(startsWith([{a: 1}], list)).toBeTrue()
expect(startsWith([{a: 1}, {a: 2}], list)).toBeTrue()
expect(startsWith(list, list)).toBeTrue()
expect(startsWith([{a: 2}], list)).toBeFalse()
})
describe('brute force', () => {
compareCombinations({
fn: startsWith,
fnRamda: startsWithRamda,
firstInput: possibleTargets,
secondInput: possibleIterables,
callback: errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 0,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 0,
"SHOULD_THROW": 0,
"TOTAL_TESTS": 32,
}
`)
},
})
})
import {startsWith} from 'rambda'
describe('R.startsWith - array as iterable', () => {
const target = [{a: 1}]
const iterable = [{a: 1}, {a: 2}]
it('happy', () => {
const result = startsWith(target, iterable)
result // $ExpectType boolean
})
it('curried', () => {
const result = startsWith(target)(iterable)
result // $ExpectType boolean
})
})
describe('R.startsWith - string as iterable', () => {
const target = 'foo'
const iterable = 'foo bar'
it('happy', () => {
const result = startsWith(target, iterable)
result // $ExpectType boolean
})
it('curried', () => {
const result = startsWith(target)(iterable)
result // $ExpectType boolean
})
})
Curried version of x - y
sum(list: number[]): number
sum(list: number[]): number;
export function sum(list) {
return list.reduce((prev, current) => prev + current, 0)
}
import {sum} from './sum'
test('happy', () => {
expect(sum([1, 2, 3, 4, 5])).toBe(15)
})
symmetricDifference<T>(x: T[], y: T[]): T[]
It returns a merged list of x and y with all equal elements removed.
R.equals is used to determine equality.
symmetricDifference<T>(x: T[], y: T[]): T[];
symmetricDifference<T>(x: T[]): <T>(y: T[]) => T[];
import {concat} from './concat'
import {filter} from './filter'
import {includes} from './includes'
export function symmetricDifference(x, y) {
if (arguments.length === 1) {
return _y => symmetricDifference(x, _y)
}
return concat(
filter(value => !includes(value, y), x),
filter(value => !includes(value, x), y)
)
}
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},
])
})
import {symmetricDifference} from 'rambda'
describe('R.symmetricDifference', () => {
it('happy', () => {
const list1 = [1, 2, 3, 4]
const list2 = [3, 4, 5, 6]
const result = symmetricDifference(list1, list2)
result // $ExpectType number[]
})
it('curried', () => {
const list1 = [{id: 1}, {id: 2}, {id: 3}, {id: 4}]
const list2 = [{id: 3}, {id: 4}, {id: 5}, {id: 6}]
const result = symmetricDifference(list1)(list2)
result // $ExpectType { id: number; }[]
})
})
T(): boolean
T(): boolean;
export function T() {
return true
}
tail<T>(input: T[]): T[]
It returns all but the first element of input.
tail<T>(input: T[]): T[];
tail(input: string): string;
import {drop} from './drop'
export function tail(listOrString) {
return drop(1, listOrString)
}
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('')
})
import {tail} from 'rambda'
describe('R.tail', () => {
it('with string', () => {
const result = tail('foo')
result // $ExpectType string
})
it('with list', () => {
const result = tail([1, 2, 3])
result // $ExpectType number[]
})
})
take<T>(howMany: number, input: T[]): T[]
It returns the first howMany elements of input.
take<T>(howMany: number, input: T[]): T[];
take(howMany: number, input: string): string;
take<T>(howMany: number): {
<T>(input: T[]): T[];
(input: string): string;
};
import baseSlice from './_internals/baseSlice'
export function take(howMany, listOrString) {
if (arguments.length === 1)
return _listOrString => take(howMany, _listOrString)
if (howMany < 0) return listOrString.slice()
if (typeof listOrString === 'string') return listOrString.slice(0, howMany)
return baseSlice(listOrString, 0, howMany)
}
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([])
})
import {take} from 'rambda'
const list = [1, 2, 3, 4]
const str = 'foobar'
const howMany = 2
describe('R.take - array', () => {
it('happy', () => {
const result = take(howMany, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = take(howMany)(list)
result // $ExpectType number[]
})
})
describe('R.take - string', () => {
it('happy', () => {
const result = take(howMany, str)
result // $ExpectType string
})
it('curried', () => {
const result = take(howMany)(str)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const list = [1, 2, 3, 4]
const num = 2
const take = [
{
label: 'Rambda',
fn: () => {
R.take(num, list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.take(num, list)
},
},
{
label: 'Lodash',
fn: () => {
_.take(list, num)
},
},
]
takeLast<T>(howMany: number, input: T[]): T[]
It returns the last howMany elements of input.
takeLast<T>(howMany: number, input: T[]): T[];
takeLast(howMany: number, input: string): string;
takeLast<T>(howMany: number): {
<T>(input: T[]): T[];
(input: string): string;
};
import baseSlice from './_internals/baseSlice'
export function takeLast(howMany, listOrString) {
if (arguments.length === 1)
return _listOrString => takeLast(howMany, _listOrString)
const len = listOrString.length
if (howMany < 0) return listOrString.slice()
let numValue = howMany > len ? len : howMany
if (typeof listOrString === 'string')
return listOrString.slice(len - numValue)
numValue = len - numValue
return baseSlice(listOrString, numValue, len)
}
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])
})
import {takeLast} from 'rambda'
const list = [1, 2, 3, 4]
const str = 'foobar'
const howMany = 2
describe('R.takeLast - array', () => {
it('happy', () => {
const result = takeLast(howMany, list)
result // $ExpectType number[]
})
it('curried', () => {
const result = takeLast(howMany)(list)
result // $ExpectType number[]
})
})
describe('R.takeLast - string', () => {
it('happy', () => {
const result = takeLast(howMany, str)
result // $ExpectType string
})
it('curried', () => {
const result = takeLast(howMany)(str)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const list = [1, 2, 3, 4]
const num = 2
const takeLast = [
{
label: 'Rambda',
fn: () => {
R.takeLast(num, list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.takeLast(num, list)
},
},
{
label: 'Lodash',
fn: () => {
_.takeRight(list, num)
},
},
]
takeLastWhile(predicate: (x: string) => boolean, input: string): string
takeLastWhile(predicate: (x: string) => boolean, input: string): string;
takeLastWhile(predicate: (x: string) => boolean): (input: string) => string;
takeLastWhile<T>(predicate: (x: T) => boolean, input: T[]): T[];
takeLastWhile<T>(predicate: (x: T) => boolean): <T>(input: T[]) => T[];
import {_isArray} from './_internals/_isArray'
export function takeLastWhile(predicate, input) {
if (arguments.length === 1) {
return _input => takeLastWhile(predicate, _input)
}
if (input.length === 0) return input
let found = false
const toReturn = []
let counter = input.length
while (!found || counter === 0) {
counter--
if (predicate(input[counter]) === false) {
found = true
} else if (!found) {
toReturn.push(input[counter])
}
}
return _isArray(input) ? toReturn.reverse() : toReturn.reverse().join('')
}
import {takeLastWhile} from './takeLastWhile'
const assert = require('assert')
const list = [1, 2, 3, 4]
test('happy', () => {
const predicate = x => x > 2
const result = takeLastWhile(predicate, list)
expect(result).toEqual([3, 4])
})
test('predicate is always true', () => {
const predicate = x => x > 0
const result = takeLastWhile(predicate)(list)
expect(result).toEqual(list)
})
test('predicate is always false', () => {
const predicate = x => x < 0
const result = takeLastWhile(predicate, list)
expect(result).toEqual([])
})
test('with string', () => {
const result = takeLastWhile(x => x !== 'F', 'FOOBAR')
expect(result).toEqual('OOBAR')
})
import {takeLastWhile} from 'rambda'
const list = [1, 2, 3]
const str = 'FOO'
describe('R.takeLastWhile', () => {
it('with array', () => {
const result = takeLastWhile(x => x > 1, list)
result // $ExpectType number[]
})
it('with array - curried', () => {
const result = takeLastWhile(x => x > 1, list)
result // $ExpectType number[]
})
it('with string', () => {
const result = takeLastWhile(x => x !== 'F', str)
result // $ExpectType string
})
it('with string - curried', () => {
const result = takeLastWhile(x => x !== 'F')(str)
result // $ExpectType string
})
})
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.
tap<T>(fn: (x: T) => void, input: T): T;
tap<T>(fn: (x: T) => void): (input: T) => T;
export function tap(fn, x) {
if (arguments.length === 1) return _x => tap(fn, _x)
fn(x)
return x
}
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)
})
import {tap, pipe} from 'rambda'
describe('R.tap', () => {
it('happy', () => {
pipe(
tap(x => {
x // $ExpectType number[]
}),
(x: number[]) => x.length
)([1, 2])
})
})
test(regExpression: RegExp): (str: string) => boolean
It determines whether str matches regExpression.
test(regExpression: RegExp): (str: string) => boolean;
test(regExpression: RegExp, str: string): boolean;
export function test(pattern, str) {
if (arguments.length === 1) return _str => test(pattern, _str)
if (typeof pattern === 'string') {
throw new TypeError(
`‘test’ requires a value of type RegExp as its first argument; received "${pattern}"`
)
}
return str.search(pattern) !== -1
}
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"'
)
})
import {test} from 'rambda'
const input = 'foo '
const regex = /foo/
describe('R.test', () => {
it('happy', () => {
const result = test(regex, input)
result // $ExpectType boolean
})
it('curried', () => {
const result = test(regex)(input)
result // $ExpectType boolean
})
})
const R = require('../../dist/rambda.js')
const test = [
{
label: 'Rambda',
fn: () => {
R.test(/\s/g, 'x y z')
R.test(/\s/g)('x y z')
},
},
{
label: 'Ramda',
fn: () => {
Ramda.test(/\s/g, 'x y z')
Ramda.test(/\s/g)('x y z')
},
},
]
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).
times<T>(fn: (i: number) => T, howMany: number): T[];
times<T>(fn: (i: number) => T): (howMany: number) => T[];
import {map} from './map'
import {range} from './range'
export function times(fn, howMany) {
if (arguments.length === 1) return _howMany => times(fn, _howMany)
if (!Number.isInteger(howMany) || howMany < 0) {
throw new RangeError('n must be an integer')
}
return map(fn, range(0, howMany))
}
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])
})
import {times, identity} from 'rambda'
describe('R.times', () => {
it('happy', () => {
const result = times(identity, 5)
result // $ExpectType number[]
})
})
toLower<S extends string>(str: S): Lowercase<S>
toLower<S extends string>(str: S): Lowercase<S>;
toLower(str: string): string;
export function toLower(str) {
return str.toLowerCase()
}
import {toLower} from './toLower'
test('toLower', () => {
expect(toLower('FOO|BAR|BAZ')).toEqual('foo|bar|baz')
})
toPairs<O extends object, K extends Extract<keyof O, string | number>>(obj: O): Array<{ [key in K]: [`${key}`, O[key]] }[K]>
It transforms an object to a list.
toPairs<O extends object, K extends Extract<keyof O, string | number>>(obj: O): Array<{ [key in K]: [`${key}`, O[key]] }[K]>;
toPairs<S>(obj: Record<string | number, S>): Array<[string, S]>;
export function toPairs(obj) {
return Object.entries(obj)
}
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)
})
import {toPairs} from 'rambda'
const obj = {
a: 1,
b: 2,
c: [3, 4],
}
describe('R.toPairs', () => {
it('happy', () => {
const result = toPairs(obj)
result // $ExpectType (["b", number] | ["a", number] | ["c", number[]])[]
})
})
toString(x: unknown): string
toString(x: unknown): string;
export function toString(x) {
return x.toString()
}
import {toString} from './toString'
test('happy', () => {
expect(toString([1, 2, 3])).toEqual('1,2,3')
})
toUpper<S extends string>(str: S): Uppercase<S>
toUpper<S extends string>(str: S): Uppercase<S>;
toUpper(str: string): string;
export function toUpper(str) {
return str.toUpperCase()
}
import {toUpper} from './toUpper'
test('toUpper', () => {
expect(toUpper('foo|bar|baz')).toEqual('FOO|BAR|BAZ')
})
transpose<T>(list: (T[])[]): (T[])[]
transpose<T>(list: (T[])[]): (T[])[];
import {_isArray} from './_internals/_isArray'
export function transpose(array) {
return array.reduce((acc, el) => {
el.forEach((nestedEl, i) =>
_isArray(acc[i]) ? acc[i].push(nestedEl) : acc.push([nestedEl])
)
return acc
}, [])
}
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)
})
import {transpose} from 'rambda'
const input = [
['a', 1],
['b', 2],
['c', 3],
]
describe('R.transpose', () => {
it('happy', () => {
const result = transpose(input)
result // $ExpectType (string | number)[][]
})
})
trim(str: string): string
trim(str: string): string;
export function trim(str) {
return str.trim()
}
import {trim} from './trim'
test('trim', () => {
expect(trim(' foo ')).toEqual('foo')
})
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).
It accepts any input and it returns its type.
unapply<T = any>(fn: (args: any[]) => T): (...args: any[]) => T
It calls a function fn with the list of values of the returned function.
R.unapply is the opposite of R.apply method.
unapply<T = any>(fn: (args: any[]) => T): (...args: any[]) => T;
export function unapply(fn) {
return function (...args) {
return fn.call(this, args)
}
}
import {apply} from './apply'
import {unapply} from './unapply'
import {identity} from './identity'
import {converge} from './converge'
import {prop} from './prop'
import {sum} from './sum'
test('happy', () => {
const fn = unapply(identity)
expect(fn(1, 2, 3)).toEqual([1, 2, 3])
expect(fn()).toEqual([])
})
test('returns a function which is always passed one argument', function () {
const fn = unapply(function () {
return arguments.length
})
expect(fn('x')).toEqual(1)
expect(fn('x', 'y')).toEqual(1)
expect(fn('x', 'y', 'z')).toEqual(1)
})
test('forwards arguments to decorated function as an array', function () {
const fn = unapply(function (xs) {
return '[' + xs + ']'
})
expect(fn(2)).toEqual('[2]')
expect(fn(2, 4)).toEqual('[2,4]')
expect(fn(2, 4, 6)).toEqual('[2,4,6]')
})
test('returns a function with length 0', function () {
const fn = unapply(identity)
expect(fn.length).toEqual(0)
})
test('is the inverse of R.apply', function () {
let a, b, c, d, e, f, g, n
const rand = function () {
return Math.floor(200 * Math.random()) - 100
}
f = Math.max
g = unapply(apply(f))
n = 1
while (n <= 100) {
a = rand()
b = rand()
c = rand()
d = rand()
e = rand()
expect(f(a, b, c, d, e)).toEqual(g(a, b, c, d, e))
n += 1
}
f = function (xs) {
return '[' + xs + ']'
}
g = apply(unapply(f))
n = 1
while (n <= 100) {
a = rand()
b = rand()
c = rand()
d = rand()
e = rand()
expect(f([a, b, c, d, e])).toEqual(g([a, b, c, d, e]))
n += 1
}
})
test('it works with converge', () => {
const fn = unapply(sum)
const convergeFn = converge(fn, [prop('a'), prop('b'), prop('c')])
const obj = {
a: 1337,
b: 42,
c: 1,
}
const expected = 1337 + 42 + 1
expect(convergeFn(obj)).toEqual(expected)
})
import {join, unapply, sum} from 'rambda'
describe('R.unapply', () => {
it('happy', () => {
const fn = unapply(sum)
fn(1, 2, 3) // $ExpectType number
})
it('joins a string', () => {
const fn = unapply(join(''))
fn('s', 't', 'r', 'i', 'n', 'g') // $ExpectType string
})
})
union<T>(x: T[], y: T[]): T[]
It takes two lists and return a new list containing a merger of both list with removed duplicates.
R.equals is used to compare for duplication.
union<T>(x: T[], y: T[]): T[];
union<T>(x: T[]): (y: T[]) => T[];
import {includes} from './includes'
import {cloneList} from './_internals/cloneList'
export function union(x, y) {
if (arguments.length === 1) return _y => union(x, _y)
const toReturn = cloneList(x)
y.forEach(yInstance => {
if (!includes(yInstance, x)) toReturn.push(yInstance)
})
return toReturn
}
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)
})
import {union} from 'rambda'
describe('R.union', () => {
it('happy', () => {
const result = union([1, 2], [2, 3])
result // $ExpectType number[]
})
it('with array of objects - case 1', () => {
const list1 = [{a: 1}, {a: 2}]
const list2 = [{a: 2}, {a: 3}]
const result = union(list1, list2)
result // $ExpectType { a: number; }[]
})
it('with array of objects - case 2', () => {
const list1 = [{a: 1, b: 1}, {a: 2}]
const list2 = [{a: 2}, {a: 3, b: 3}]
const result = union(list1, list2)
result[0].a // $ExpectType number
result[0].b // $ExpectType number | undefined
})
})
describe('R.union - curried', () => {
it('happy', () => {
const result = union([1, 2])([2, 3])
result // $ExpectType number[]
})
it('with array of objects - case 1', () => {
const list1 = [{a: 1}, {a: 2}]
const list2 = [{a: 2}, {a: 3}]
const result = union(list1)(list2)
result // $ExpectType { a: number; }[]
})
it('with array of objects - case 2', () => {
const list1 = [{a: 1, b: 1}, {a: 2}]
const list2 = [{a: 2}, {a: 3, b: 3}]
const result = union(list1)(list2)
result[0].a // $ExpectType number
result[0].b // $ExpectType number | undefined
})
})
uniq<T>(list: T[]): T[]
It returns a new array containing only one copy of each element of list.
R.equals is used to determine equality.
uniq<T>(list: T[]): T[];
import {_Set} from './_internals/set'
export function uniq(list) {
const set = new _Set()
const willReturn = []
list.forEach(item => {
if (set.checkUniqueness(item)) {
willReturn.push(item)
}
})
return willReturn
}
import {uniq} from './uniq'
import {uniq as uniqRamda} from 'ramda'
test('happy', () => {
const list = [1, 2, 3, 3, 3, 1, 2, 0]
expect(uniq(list)).toEqual([1, 2, 3, 0])
})
test('with object', () => {
const list = [{a: 1}, {a: 2}, {a: 1}, {a: 2}]
expect(uniq(list)).toEqual([{a: 1}, {a: 2}])
})
test('with nested array', () => {
expect(uniq([[42], [42]])).toEqual([[42]])
})
test('with booleans', () => {
expect(uniq([[false], [false], [true]])).toEqual([[false], [true]])
})
test('with falsy values', () => {
expect(uniq([undefined, null])).toEqual([undefined, null])
})
test('can distinct between string and number', () => {
expect(uniq([1, '1'])).toEqual([1, '1'])
})
import {uniq} from 'rambda'
describe('R.uniq', () => {
it('happy', () => {
const result = uniq([1, 2, 3, 3, 3, 1, 2, 0])
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const {
uniqListOfStrings,
uniqListOfBooleans,
uniqListOfNumbers,
uniqListOfLists,
uniqListOfObjects,
} = require('./_utils.js')
const limit = 100
const modes = [
uniqListOfStrings(limit),
uniqListOfBooleans(limit),
uniqListOfNumbers(limit),
uniqListOfLists(limit),
uniqListOfObjects(limit),
]
function applyBenchmark(fn, input) {
fn(input)
}
const tests = [
{
label: 'Rambda',
fn: R.uniq,
},
{
label: 'Ramda',
fn: Ramda.uniq,
},
]
uniqWith<T, U>(predicate: (x: T, y: T) => boolean, list: T[]): T[]
It returns a new array containing only one copy of each element in list according to predicate function.
This predicate should return true, if two elements are equal.
uniqWith<T, U>(predicate: (x: T, y: T) => boolean, list: T[]): T[];
uniqWith<T, U>(predicate: (x: T, y: T) => boolean): (list: T[]) => T[];
function includesWith(predicate, target, list) {
let willReturn = false
let index = -1
while (++index < list.length && !willReturn) {
const value = list[index]
if (predicate(target, value)) {
willReturn = true
}
}
return willReturn
}
export function uniqWith(predicate, list) {
if (arguments.length === 1) return _list => uniqWith(predicate, _list)
let index = -1
const willReturn = []
while (++index < list.length) {
const value = list[index]
if (!includesWith(predicate, value, willReturn)) {
willReturn.push(value)
}
}
return willReturn
}
import {uniqWith} from './uniqWith'
import {uniqWith as uniqWithRamda} from 'ramda'
const list = [{a: 1}, {a: 1}]
test('happy', () => {
const fn = (x, y) => x.a === y.a
const result = uniqWith(fn, list)
expect(result).toEqual([{a: 1}])
})
test('with list of strings', () => {
const fn = (x, y) => x.length === y.length
const list = ['0', '11', '222', '33', '4', '55']
const result = uniqWith(fn)(list)
const resultRamda = uniqWithRamda(fn, list)
expect(result).toEqual(['0', '11', '222'])
expect(resultRamda).toEqual(['0', '11', '222'])
})
import {uniqWith} from 'rambda'
describe('R.uniqWith', () => {
it('happy', () => {
const list = [{a: 1}, {a: 1}]
const fn = (x: any, y: any) => x.a === y.a
const result = uniqWith(fn, list)
result // $ExpectType { a: number; }[]
})
})
const R = require('../../dist/rambda.js')
const {
uniqListOfStrings,
uniqListOfBooleans,
uniqListOfNumbers,
uniqListOfLists,
uniqListOfObjects,
} = require('./_utils.js')
const limit = 100
const modes = [
[uniqListOfStrings(limit), (x, y) => x.length === y.length],
[uniqListOfBooleans(limit), (x, y) => x === y],
[uniqListOfNumbers(limit), (x, y) => x > y],
[uniqListOfLists(limit), (x, y) => x.length === y.length],
[
uniqListOfObjects(limit),
x => (x, y) => Object.keys(x).length === Object.keys(y).length,
],
]
function applyBenchmark(fn, input) {
return fn(input[1], input[0])
}
const tests = [
{
label: 'Rambda',
fn: R.uniqWith,
},
{
label: 'Ramda',
fn: Ramda.uniqWith,
},
]
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, x: T): T | U
The method returns function that will be called with argument input.
If predicate(input) returns false, then the end result will be the outcome of whenFalse(input).
In the other case, the final output will be the input itself.
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, x: T): T | U;
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U): (x: T) => T | U;
unless<T>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => T, x: T): T;
unless<T>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => T): (x: T) => T;
export function unless(predicate, whenFalse) {
if (arguments.length === 1) {
return _whenFalse => unless(predicate, _whenFalse)
}
return input => (predicate(input) ? input : whenFalse(input))
}
import {inc} from './inc'
import {isNil} from './isNil'
import {unless} from './unless'
test('happy', () => {
const safeInc = unless(isNil, inc)
expect(safeInc(null)).toBeNull()
expect(safeInc(1)).toBe(2)
})
test('curried', () => {
const safeIncCurried = unless(isNil)(inc)
expect(safeIncCurried(null)).toBeNull()
})
import {unless, inc} from 'rambda'
describe('R.unless', () => {
it('happy', () => {
const fn = unless(x => x > 5, inc)
const result = fn(1)
result // $ExpectType number
})
it('with one explicit type', () => {
const result = unless(
x => {
x // $ExpectType number
return x > 5
},
x => {
x // $ExpectType number
return x + 1
},
1
)
result // $ExpectType number
})
it('with two different explicit types', () => {
const result = unless(
x => {
x // $ExpectType number
return x > 5
},
x => {
x // $ExpectType number
return `${x}-foo`
},
1
)
result // $ExpectType string | number
})
})
describe('R.unless - curried', () => {
it('happy', () => {
const fn = unless(x => x > 5, inc)
const result = fn(1)
result // $ExpectType number
})
it('with one explicit type', () => {
const fn = unless<number>(
x => {
x // $ExpectType number
return x > 5
},
x => {
x // $ExpectType number
return x + 1
}
)
const result = fn(1)
result // $ExpectType number
})
it('with two different explicit types', () => {
const fn = unless<number, string>(
x => {
x // $ExpectType number
return x > 5
},
x => {
x // $ExpectType number
return `${x}-foo`
}
)
const result = fn(1)
result // $ExpectType string | number
})
})
update<T>(index: number, newValue: T, list: T[]): T[]
It returns a copy of list with updated element at index with newValue.
update<T>(index: number, newValue: T, list: T[]): T[];
update<T>(index: number, newValue: T): (list: T[]) => T[];
import {curry} from './curry'
import {cloneList} from './_internals/cloneList'
function updateFn(index, newValue, list) {
const clone = cloneList(list)
if (index === -1) return clone.fill(newValue, index)
return clone.fill(newValue, index, index + 1)
}
export const update = curry(updateFn)
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)
})
test('with negative index', () => {
expect(update(-1, 10, [1])).toEqual([10])
expect(update(-1, 10, [])).toEqual([])
expect(update(-1, 10, list)).toEqual([1, 2, 10])
expect(update(-2, 10, list)).toEqual([1, 10, 3])
expect(update(-3, 10, list)).toEqual([10, 2, 3])
})
import {update} from 'rambda'
describe('R.update', () => {
it('happy', () => {
const result = update(1, 0, [1, 2, 3])
result // $ExpectType number[]
})
})
const R = require('../../dist/rambda.js')
const list = [0, 1, 2]
const index = 1
const replacer = 7
const update = [
{
label: 'Rambda',
fn: () => {
R.update(replacer, index, list)
R.update(replacer, index)(list)
R.update(replacer)(index)(list)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.update(replacer, index, list)
Ramda.update(replacer, index)(list)
Ramda.update(replacer)(index)(list)
},
},
]
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.
values<T extends object, K extends keyof T>(obj: T): T[K][];
import {type} from './type'
export function values(obj) {
if (type(obj) !== 'Object') return []
return Object.values(obj)
}
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([])
})
import {values} from 'rambda'
describe('R.values', () => {
it('happy', () => {
const result = values({
a: 1,
b: 2,
c: 3,
})
result // $ExpectType number[]
})
})
view<T, U>(lens: Lens): (target: T) => U
It returns the value of lens focus over target object.
view<T, U>(lens: Lens): (target: T) => U;
view<T, U>(lens: Lens, target: T): U;
const Const = x => ({
x,
map: fn => Const(x),
})
export function view(lens, target) {
if (arguments.length === 1) return _target => view(lens, _target)
return lens(Const)(target).x
}
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')
})
import {lens, view, assoc} from 'rambda'
interface Input {
foo: string
}
const testObject: Input = {
foo: 'Led Zeppelin',
}
const fooLens = lens<Input, string, string>((x: Input) => {
return x.foo
}, assoc('foo'))
describe('R.view', () => {
it('happt', () => {
const result = view<Input, string>(fooLens, testObject)
result // $ExpectType string
})
})
const R = require('../../dist/rambda.js')
const testObj = {a: 1}
const last = [
{
label: 'Rambda',
fn: () => {
R.view(R.lensProp('a'), testObj)
},
},
{
label: 'Ramda',
fn: () => {
Ramda.view(Ramda.lensProp('a'), testObj)
},
},
]
when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): T | U
when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): T | U;
when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U): (input: T) => T | U;
when<T, U>(predicate: (x: T) => boolean): ((whenTrueFn: (a: T) => U) => (input: T) => T | U);
import {curry} from './curry'
function whenFn(predicate, whenTrueFn, input) {
if (!predicate(input)) return input
return whenTrueFn(input)
}
export const when = curry(whenFn)
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')
})
import {when} from 'rambda'
const predicate = (x: number) => x > 2
const whenTrueFn = (x: number) => String(x)
describe('R.when', () => {
it('happy', () => {
const result = when(predicate, whenTrueFn, 1)
result // $ExpectType string | 1
})
it('curry 1', () => {
const fn = when(predicate, whenTrueFn)
const result = fn(1)
result // $ExpectType string | number
})
it('curry 2 require explicit types', () => {
const fn = when<number, string>(predicate)(whenTrueFn)
const result = fn(1)
result // $ExpectType string | number
})
})
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.
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;
export function where(conditions, input) {
if (input === undefined) {
return _input => where(conditions, _input)
}
let flag = true
for (const prop in conditions) {
const result = conditions[prop](input[prop])
if (flag && result === false) {
flag = false
}
}
return flag
}
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)
})
import {where, equals} from 'rambda'
describe('R.where', () => {
it('happy', () => {
const input = {
a: 'foo',
b: 'bar',
x: 11,
y: 19,
}
const conditions = {
a: equals('foo'),
b: equals('bar'),
}
const result = where(conditions, input)
const curriedResult = where(conditions)(input)
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
})
whereEq<T, U>(condition: T, input: U): boolean
It will return true if all of input object fully or partially include rule object.
R.equals is used to determine equality.
whereEq<T, U>(condition: T, input: U): boolean;
whereEq<T>(condition: T): <U>(input: U) => boolean;
import {equals} from './equals'
import {filter} from './filter'
export function whereEq(condition, input) {
if (arguments.length === 1) {
return _input => whereEq(condition, _input)
}
const result = filter(
(conditionValue, conditionProp) =>
equals(conditionValue, input[conditionProp]),
condition
)
return Object.keys(result).length === Object.keys(condition).length
}
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 properties of null (reading 'a')`
)
})
import {whereEq} from 'rambda'
describe('R.whereEq', () => {
it('happy', () => {
const result = whereEq({a: {b: 2}}, {b: 2})
const curriedResult = whereEq({a: {b: 2}})({b: 2})
result // $ExpectType boolean
curriedResult // $ExpectType boolean
})
})
without<T>(matchAgainst: T[], source: T[]): T[]
It will return a new array, based on all members of source list that are not part of matchAgainst list.
R.equals is used to determine equality.
without<T>(matchAgainst: T[], source: T[]): T[];
without<T>(matchAgainst: T[]): (source: T[]) => T[];
import {reduce} from './reduce'
import {_indexOf} from './equals'
export function without(matchAgainst, source) {
if (source === undefined) {
return _source => without(matchAgainst, _source)
}
return reduce(
(prev, current) =>
_indexOf(current, matchAgainst) > -1 ? prev : prev.concat(current),
[],
source
)
}
import {without} from './without'
import {without as withoutRamda} from 'ramda'
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('with list of objects', () => {
const itemsToOmit = [{a: 1}, {c: 3}]
const collection = [{a: 1}, {b: 2}, {c: 3}, {d: 4}]
const expected = [{b: 2}, {d: 4}]
expect(without(itemsToOmit, collection)).toEqual(expected)
expect(withoutRamda(itemsToOmit, collection)).toEqual(expected)
})
test('ramda accepts string as target input while rambda throws', () => {
expect(withoutRamda('0:1', ['0', '0:1'])).toEqual([])
expect(() => without('0:1', ['0', '0:1'])).toThrow()
expect(without(['0:1'], ['0', '0:1'])).toEqual(['0'])
})
test('ramda test', () => {
expect(without([1, 2])([1, 2, 1, 3, 4])).toEqual([3, 4])
})
import {without} from 'rambda'
const itemsToOmit = ['A', 'B', 'C']
const collection = ['A', 'B', 'C', 'D', 'E', 'F']
describe('R.without', () => {
it('happy', () => {
const result = without(itemsToOmit, collection)
result // $ExpectType string[]
})
it('curried', () => {
const result = without(itemsToOmit)(collection)
result // $ExpectType string[]
})
})
xor(x: boolean, y: boolean): boolean
Logical XOR
xor(x: boolean, y: boolean): boolean;
xor(y: boolean): (y: boolean) => boolean;
export function xor(a, b) {
if (arguments.length === 1) return _b => xor(a, _b)
return (Boolean(a) && !b) || (Boolean(b) && !a)
}
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)
})
import {xor} from 'rambda'
describe('R.xor', () => {
it('happy', () => {
xor(true, false) // $ExpectType boolean
})
it('curry', () => {
xor(true)(false) // $ExpectType boolean
})
})
zip<K, V>(x: K[], y: 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.
zip<K, V>(x: K[], y: V[]): KeyValuePair<K, V>[];
zip<K>(x: K[]): <V>(y: V[]) => KeyValuePair<K, V>[];
export function zip(left, right) {
if (arguments.length === 1) return _right => zip(left, _right)
const result = []
const length = Math.min(left.length, right.length)
for (let i = 0; i < length; i++) {
result[i] = [left[i], right[i]]
}
return result
}
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)
})
import {zip} from 'rambda'
describe('R.zip', () => {
it('happy', () => {
const array1 = [1, 2, 3]
const array2 = ['A', 'B', 'C']
const result = zip(array1)(array2)
result // $ExpectType KeyValuePair<number, string>[]
})
})
zipObj<T, K extends string>(keys: K[], values: T[]): { [P in K]: T }
It will return a new object with keys of keys array and values of values array.
zipObj<T, K extends string>(keys: K[], values: T[]): { [P in K]: T };
zipObj<K extends string>(keys: K[]): <T>(values: T[]) => { [P in K]: T };
zipObj<T, K extends number>(keys: K[], values: T[]): { [P in K]: T };
zipObj<K extends number>(keys: K[]): <T>(values: T[]) => { [P in K]: T };
import {take} from './take'
export function zipObj(keys, values) {
if (arguments.length === 1) return yHolder => zipObj(keys, yHolder)
return take(values.length, keys).reduce((prev, xInstance, i) => {
prev[xInstance] = values[i]
return prev
}, {})
}
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()
})
import {zipObj} from 'rambda'
describe('R.zipObj', () => {
it('happy', () => {
// this is wrong since 24.10.2020 `@types/ramda` changes
const result = zipObj(['a', 'b', 'c', 'd'], [1, 2, 3])
result // $ExpectType { b: number; a: number; c: number; d: number; }
})
it('imported from @types/ramda', () => {
const result = zipObj(['a', 'b', 'c'], [1, 2, 3])
const curriedResult = zipObj(['a', 'b', 'c'])([1, 2, 3])
result // $ExpectType { b: number; a: number; c: number; }
curriedResult // $ExpectType { b: number; a: number; c: number; }
})
})
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: T[], list2: U[]): TResult[]
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: T[], list2: U[]): TResult[];
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: T[]): (list2: U[]) => TResult[];
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult): (list1: T[], list2: U[]) => TResult[];
import {curry} from './curry'
import {take} from './take'
function zipWithFn(fn, x, y) {
return take(x.length > y.length ? y.length : x.length, x).map(
(xInstance, i) => fn(xInstance, y[i])
)
}
export const zipWith = curry(zipWithFn)
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])
})
import {zipWith} from 'rambda'
const list1 = [1, 2]
const list2 = [10, 20, 30]
describe('R.zipWith', () => {
it('happy', () => {
const result = zipWith(
(x, y) => {
x // $ExpectType number
y // $ExpectType number
return `${x}-${y}`
},
list1,
list2
)
result // $ExpectType string[]
})
it('curried', () => {
const result = zipWith((x, y) => {
x // $ExpectType unknown
y // $ExpectType unknown
return `${x}-${y}`
})(list1, list2)
result // $ExpectType string[]
})
})
WIP 7.1.0
Replace Async with Promise as return type of R.type.
Add new types as Typescript output for R.type - "Map", "WeakMap", "Generator", "GeneratorFunction", "BigInt", "ArrayBuffer"
7.0.3
Rambda.none has wrong logic - Issue #625
7.0.2
Rambda doesn't work with pnpm due to wrong export configuration - Issue #619
7.0.1
package.json - Issue #6147.0.0
R.compose/R.pipe with @types/ramda. That is significant change so as safeguard, it will lead a major bump. Important - this lead to raising required Typescript version to 4.2.2. In other words, to use Rambda you'll need Typescript version 4.2.2 or newer.Related commit in @types/ramda - https://github.com/DefinitelyTyped/DefinitelyTyped/commit/286eff4f76d41eb8f091e7437eabd8a60d97fc1f#diff-4f74803fa83a81e47cb17a7d8a4e46a7e451f4d9e5ce2f1bd7a70a72d91f4bc1
There are several other changes in @types/ramda as stated in this comment. This leads to change of typings for the following methods in Rambda:
-- R.unless
-- R.toString
-- R.ifElse
-- R.always
-- R.complement
-- R.cond
-- R.is
-- R.sortBy
-- R.dissoc
-- R.toPairs
-- R.assoc
-- R.toLower
-- R.toUpper
One more reason for the braking change is changing of export declarations in package.json based on this blog post and this merged Ramda's PR. This also led to renaming of babel.config.js to babel.config.cjs.
Add R.apply, R.bind and R.unapply
R.startsWith/R.endsWith now support lists as inputs. This way, it matches current Ramda behavior.
Remove unused typing for R.chain.
R.map/R.filter no longer accept bad inputs as iterable. This way, Rambda behaves more like Ramda, which also throws.
Make R.lastIndexOf follow the logic of R.indexOf.
Change R.type logic to Ramda logic. This way, R.type can return Error and Set as results.
Add missing logic in R.equals to compare sets - Issue #599
Improve list cloning - Issue #595
Handle multiple inputs with R.allPass and R.anyPass - Issue #604
Fix R.length wrong logic with inputs as {length: 123} - Issue #606.
Improve non-curry typings of R.merge by using types from mobily/ts-belt.
Improve performance of R.uniqWith.
Wrong R.update if index is -1 - PR #593
Make R.eqProps safe for falsy inputs - based on this opened Ramda PR.
Incorrect benchmarks for R.pipe/R.compose - Issue #608
Fix R.last/R.head typings - Issue #609
6.9.0
R.uniq methods - Issue #581Fixing R.uniq was done by improving R.indexOf which has performance implication to all methods importing R.indexOf:
R.includes
R.intersection
R.difference
R.excludes
R.symmetricDifference
R.union
R.without no longer support the following case - without('0:1', ['0', '0:1']) // => ['0']. Now it throws as the first argument should be a list, not a string. Ramda, on the other hand, returns an empty list - https://github.com/ramda/ramda/issues/3086.
6.8.3
Fix Typescript build process with rambda/immutable - Issue #572
Add R.objOf method
Add R.mapObjIndexed method
Publish shorter README.md version to NPM
6.8.0
R.has use Object.prototype.hasOwnProperty- Issue #572
Expose immutable.ts typings which are Rambda typings with readonly statements - Issue #565
Fix R.intersection wrong order compared to Ramda.
R.path wrong return of null instead of undefined when path value is null - PR #577
6.7.0
ts-toolbelt types from Typescript definitions. Most affected are the following methods, which lose one of its curried definitions:6.6.0
Change R.piped typings to mimic that of R.pipe. Main difference is that R.pipe is focused on unary functions.
Fix wrong logic when R.without use R.includes while it should use array version of R.includes.
Use uglify plugin for UMD bundle.
Remove dist folder from .gitignore in order to fix Deno broken package. Issue #570
Improve R.fromPairs typings - Issue #567
6.5.3
R.without use R.includes while it should use the array version of R.includesThis is Ramda bug, that Rambda also has before this release - https://github.com/ramda/ramda/issues/3086
6.5.2
Wrong R.defaultTo typings - changes introduced in v6.5.0 are missing their TS equivalent.
Update dependencies
6.5.1
Fix wrong versions in changelog
6.5.0
R.defaultTo no longer accepts infinite inputs, thus it follows Ramda implementation.
R.equals supports equality of functions.
R.pipe doesn't use R.compose.
Close Issue #561 - export several internal TS interfaces and types
Close Issue #559 - improve R.propOr typings
Add CHANGELOG.md file in release files list
6.4.0
Close Issue #560 - apply immutable lint to Typescript definitions
Close Issue #553 - fix problem with curried typings of R.prop
Fix wrong R.last typing
Upgrade all rollup related dependencies
R.type supports Symbol just like Ramda.
Remove file extension in main property in package.json in order to allow experimental-modules. See also this Ramda's PR - https://github.com/ramda/ramda/pull/2678/files
Import R.indexBy/R.when/R.zipObj/R.propEq/R.complement changes from recent @types/ramda release.
R.tryCatch stop supporting asynchronous functions; the previous behaviour is exported to Rambdax as R.tryCatchAsync
6.3.1
Evolved declaration in Typescript definition6.3.0
Add R.takeLastWhile
Add R.dropWhile
Add R.eqProps
Add R.dropLastWhile
Add R.dropRepeats
Add R.dropRepeatsWith
Add R.evolve
Add typings for R.takeWhile when iterable is a string
6.2.0
Add R.props
Add R.zipWith
Add R.splitAt
Add R.splitWhen
Close Issue #547 - restore readonly declaration in 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
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.1
R.reject as it wrongly declares that with object, it pass property to predicate.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.
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.
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.
5.13.1
R.takeWhile5.13.0
Add R.takeWhile method
Fix R.lensPath issue when using string as path input. The issue was introduced when fixing Issue #524 in the previous release.
5.12.1
Close Issue #524 -
wrong R.assocPath when path includes numbers
R.includes throws on wrong input, i.e. R.includes(1, null)
5.12.0
Add R.move method
Add R.union method
Close Issue #519 -
ts-toolbelt needs other type of export with --isolatedModules flag
Change R.when implementation and typings to match those of Ramda
R.over and R.set use R.curry instead of manual currying
R.lensPath typings support string as path, i.e. 'a.b' instead of ['a', 'b']
R.equals now supports negative zero just like Ramda.equals
R.replace uses R.curry
5.11.0
Forgot to export R.of because of wrong marker in files/index.d.ts
5.10.0
Close Issue #514 -
wrong R.length with empty string
Close Issue #511 - error in ts-toolbelt library
Close Issue #510 - R.clamp should throw if min argument is greater than max argument
PR #508 - add R.of
Definition of R.curry are not same as those of @types/ramda
Definitions of R.either is same as that of R.both
Definitions of R.ifElse no longer use any type
Definition of R.flatten requires passing type for the output
Fix definition of R.propOr, R.dissoc
Fix curried definitions of R.take, R.takeLast, R.drop and R.dropLast
5.9.0
R.pickAll definition allows passing string as path to search.
R.propEq definition is now similar to that in @types/ramda.
R.none matches R.all implementation and pass index as second argument to predicate input.
R.reduce - drop support for object as iterable. Now it throws the same error as Ramda. Also instead of returning the initial value when iterable is undefined, now it throws.
Add index as additional argument to the Typescript definitions of the following methods:
R.all
R.find
R.findLast
R.findIndex
R.findLastIndex
5.8.0
Add R.mergeAll
Add R.mergeDeepRight
Add R.mergeLeft
Add R.partition
Add R.pathEq
Add R.tryCatch
Add R.unless
Add R.whereEq
Add R.where
Add R.last typing for empty array
5.7.0 Revert PR #469 as R.curry was slow | Also now R.flip throws if arity is greater than or equal to 5
5.6.3 Merge several PRs of @farwayer
PR #482 - improve R.forEach performance by not using R.map
PR #485 - improve R.map performance
PR #482 - improve R.reduce performance
Fix missing high arity typings for R.compose/pipe
R.merge definitions match those of @types/ramda
Remove dist folder from Rambda repo
5.6.2
Close Issue #476 - typesafe R.propEq definitions
Approve PR #477 - fix R.groupWith when list length is 1
Update ts-toolbelt files as now there is update pipeline for it.
Approve PR #474 - intruduce internal isArray helper
Approve PR #469 - R.flip supports any arity | implement R.curry with R.curryN add R.applySpec
Close Issue #464 - R.flip should handle functions with arity above 2
Close Issue #468 - fs-extra should be dev dependency as it was wrongly added as production dependency in 5.2.0
R.flip typings now match @types/ramda typings
Add R.hasPath method
Add R.mathMod typings
Fix R.omit typings
Fix R.pick typings
Close Issue #460 -
R.pathsshould be curried
Close Issue #458 - wrong
R.propIstyping
Close Issue #408 - add
R.chain
Close Issue #430 - add
R.when
Also restore R.converge, R.findLast, R.findLastIndex and R.curryN as I have forgotten to export them when releasing 5.2.0.
Fix Typescript comment for every method
Release new documentation site
Ramda repo now holds all Rambdax methods and tests
Add R.converge and R.curryN from PR #412
Close Issue #410 - wrong implementation of R.groupWith
Close Issue #411 - change the order of declared R.map typings rules
Move R.partialCurry to Rambdax(reason for major bump).
Use new type of export in Typescript definitions.
Approve PR #381 - add R.applySpec
Approve PR #375 - add lenses(Thank you @synthet1c)
Add R.lens
Add R.lensIndex
Add R.lensPath
Add R.lensProp
Add R.over
Add R.set
Add R.view
Sync with Ramda 0.27
Add R.paths
Add R.xor
Close Issue #373
Add R.cond
4.5.0 Add R.clamp
4.4.2 Improve R.propOr typings
4.4.1 Make R.reject has the same typing as R.filter
4.4.0 Several changes:
Close Issue #317 - add R.transpose
Close Issue #325 - R.filter should return equal values for bad inputs null and undefined
Approve suggestion for R.indexBy to accept string not only function as first argument.
Edit of R.path typings
4.2.0 Approve PR #314 - add R.and
4.1.1 Add missing typings for R.slice
4.1.0 Add R.findLast and R.findLastIndex
4.0.2 Fix R.isEmpty wrong behaviour compared to the Ramda method
4.0.1 Approve PR #289 - remove console.log in R.values method
4.0.0 Multiple breaking changes as Rambda methods are changed in order to increase the similarity between with Ramda
Add to Differences:
R.type can return 'NaN'
R.compose doesn't pass `this` context
R.clone doesn't work with number, booleans and strings as input
All breaking changes:
-- R.add works only with numbers
-- Fix R.adjust which had wrong order of arguments
-- R.adjust works when index is out of bounds
-- R.complement support function with multiple arguments
-- R.compose/pipe throws when called with no argument
-- R.clone works with Date value as input
-- R.drop/dropLast/take/takeLast always return new copy of the list/string
-- R.take/takeLast return original list/string with negative index
-- R.equals handles NaN and RegExp types
-- R.type/R.equals supports new Boolean/new Number/new Date/new String expressions
-- R.has works with non-object
-- R.ifElse pass all arguments
-- R.length works with bad input
-- R.propEq work with bad input for object argument
-- R.range work with bad inputs
-- R.times work with bad inputs
-- R.reverse works with strings
-- R.splitEvery throws on non-positive integer index
-- R.test throws just like Ramda when first argument is not regex
-- R.values works with bad inputs
-- R.zipObj ignores extra keys
This is pre 4.0.0 release and it contains all of the above changes
Close issue #287 - ts-toolbelt directory was changed but not reflected in files property in package.json
Close issue #273 - ts-toolbelt needs other type of export when isolatedModules TypeScript property
Close issue #245 - complete typings tests for methods that have more specific Typescript definitions
3.2.1 Fast fix for issue #273 - messed up typings
3.2.0 There are several changes:
Close issue #263 - broken curry typing solved by ts-toolbelt local dependency.
Add R.partialCurry typings.
Approve PR #266 that adds R.slice method.
3.1.0 This might be breaking change for Typescript users, as very different definitions are introduced. With the previous state of the definitions, it was not possible to pass dtslint typings tests.
R.either and R.both supports multiple arguments as they should.
Several methods added by @squidfunk - R.assocPath, R.symmetricDifference, R.intersperse, R.intersection and R.difference
3.0.1 Close issue #234 - wrong curry typing
3.0.0 Deprecate R.contains, while R.includes is now following Ramda API(it uses R.equals for comparision)
2.14.5 R.without needs currying
2.14.4 Close issue #227 - add index as third argument of R.reduce typings
2.14.2 Use R.curry with R.reduce as manual curry there didn't work as expected.
2.14.1 Fix wrong typescript with R.head - PR #228 pushed by @tonivj5
2.14.0 Add R.groupWith by @selfrefactor | Add R.propOr, R.mathMod, R.mean, R.median, R.negate, R.product by @ku8ar
2.12.0 Add R.propIs - PR #213 and add R.sum - issue #207
2.11.2 Close Rambdax issue #32 - wrong R.type when function is input
2.11.1 Approve PR #182 - Changed typings to allow object as input to R.forEach and R.map
2.11.0 Approve PR #179 - R.adjust handles negative index; R.all doesn't need R.filter
2.10.2 Close issue #175 - missing typescript file
2.10.0 Approve huge and important PR #171 submitted by @helmuthdu - Add comments to each method, improve Typescript support
2.9.0 R.toPairs and R.fromPairs
2.8.0 Approve PR #165 R.clone
2.7.1 expose src | Discussed at issue #147
2.7.0 Approve PR #161 R.isEmpty
2.6.0 R.map, R.filter and R.forEach pass original object to iterator as third argument | Discussed at issue #147
2.5.0 Close issue #149 Add R.partial | R.type handles NaN
2.4.0 Major bump of Rollup; Stop building for ES5
2.3.1 Close issue #90 | Add string type of path in R.pathOr
2.3.0 Close issue #89 | Fix missing Number TS definition in R.type
2.2.0 R.defaultTo accepts indefinite number of input arguments. So the following is valid expression: const x = defaultTo('foo',null, null, 'bar')
2.1.0 Restore R.zip using WatermelonDB implementation.
2.0.0 Major version caused by removing of R.zip and R.addIndex. Issue #85 rightfully finds that the implementation of R.addIndex is not correct. This led to removing this method and also of R.zip as it had depended on it. The second change is that R.map, R.filter are passing array index as second argument when looping over arrays. The third change is that R.includes will return false if input is neigher string nor array. The previous behaviour was to throw an error. The last change is to increase the number of methods that are passing index as second argument to the predicate function.
1.2.6 Use src folder instead of modules
1.2.5 Fix omit typing
1.2.4 Add missing Typescript definitions - PR#82
1.2.2 Change curry method used across most of library methods
1.2.1 Add R.assoc | fix passing undefined to R.map and R.merge issue #77
1.2.0 Add R.min, R.minBy, R.max, R.maxBy, R.nth and R.keys
1.1.5 Close issue #74 R.zipObj
1.1.4 Close issue #71 CRA fail to build rambda
1.1.2 Approve PR #67 use babel-plugin-annotate-pure-calls
1.1.1 Approve PR #66 R.zip
1.1.0 R.compose accepts more than one input argument issue #65
1.0.13 Approve PR #64 R.indexOf
1.0.12 Close issue #61 make all functions modules
1.0.11 Close issue #60 problem with babelrc
1.0.10 Close issue #59 add R.dissoc
1.0.9 Close issue #58 - Incorrect R.equals
1.0.8 R.map and R.filter pass object properties when mapping over objects
1.0.7 Add R.uniqWith
1.0.6 Close issue #52 - ES5 compatible code
1.0.5 Close issue #51
1.0.4 Close issue #50 - add R.pipe typings
1.0.3 R.ifElse accept also boolean as condition argument
1.0.2 Remove typedDefaultTo and typedPathOr | Add R.pickAll and R.none
1.0.0 Major change as build is now ES6 not ES5 compatible (Related to issue #46)| Making Rambda fully tree-shakeable| Edit Typescript definition
0.9.8 Revert to ES5 compatible build - issue #46
0.9.7 Refactor for Rollup tree-shake | Remove R.padEnd and R.padStart
0.9.6 Close issue #44 - R.reverse mutates the array
0.9.5 Close issue #45 - invalid Typescript typings
0.9.4 Add R.reject and R.without (PR#41 PR#42) | Remove 'browser' field in package.json due to Webpack bug 4674
0.9.3 Add R.forEach and R.times
0.9.2 Add Typescript definitions
0.9.1 Close issue #36 - move current behaviour of defaultTo to a new method typedDefaultTo; make defaultTo follow Ramda spec; add pathOr; add typedPathOr.
0.9.0 Add R.pipe PR#35
0.8.9 Add R.isNil
0.8.8 Migrate to ES modules PR33 | Add R.flip to the API | R.map/filter works with objects
0.8.7 Change Webpack with Rollup - PR29
0.8.6 Add R.tap and R.identity
0.8.5 Add R.all, R.allPass, R.both, R.either and R.complement
0.8.4 Learning to run yarn test before yarn publish the hard way
0.8.3 Add R.always, R.T and R.F
0.8.2 Add concat, padStart, padEnd, lastIndexOf, toString, reverse, endsWith and startsWith methods
0.8.1 Add R.ifElse
0.8.0 Add R.not, R.includes | Take string as condition for R.pick and R.omit
0.7.6 Fix incorrect implementation of R.values
0.7.5 Fix incorrect implementation of R.omit
0.7.4 issue #13 - Fix R.curry, which used to return incorrectly function when called with more arguments
0.7.3 Close issue #9 - Compile to es2015; Approve PR #10 - add R.addIndex to the API
0.7.2 Add Promise support for R.type
0.7.1 Close issue #7 - add R.reduce to the API
0.7.0 Close issue #5 - change name of curry to partialCurry; add new method curry, which works just like Ramda's curry
0.6.2 Add separate documentation site via docsify
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)
Deprecated from
Used bysection
Rambda since October/2020 commit that removes RambdaReleases
Rambda's releases before 6.4.0 were used mostly for testing purposes.
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
Lightweight and faster alternative to Ramda with included TS definitions
The npm package rambda receives a total of 551,776 weekly downloads. As such, rambda popularity was classified as popular.
We found that rambda demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers 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
Node.js will be enforcing stricter semver-major PR policies a month before major releases to enhance stability and ensure reliable release candidates.
Security News
Research
Socket's threat research team has detected five malicious npm packages targeting Roblox developers, deploying malware to steal credentials and personal data.
Security News
vlt introduced its new package manager and a serverless registry this week, innovating in a space where npm has stagnated.