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.
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.
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.20) and Ramda(0.27.1).
| method | Rambda | Ramda | Lodash |
|---|---|---|---|
| add | 96.25% slower | 96.24% slower | 🚀 Fastest |
| adjust | 🚀 Fastest | 5.52% slower | 🔳 |
| all | 🚀 Fastest | 94.95% slower | 🔳 |
| allPass | 🚀 Fastest | 98.95% slower | 🔳 |
| any | 🚀 Fastest | 98.18% slower | 6.18% slower |
| anyPass | 🚀 Fastest | 99.09% slower | 🔳 |
| append | 🚀 Fastest | 84.09% slower | 🔳 |
| applySpec | 🚀 Fastest | 75.73% slower | 🔳 |
| assoc | 87.98% slower | 57.39% slower | 🚀 Fastest |
| clone | 🚀 Fastest | 96.03% slower | 91.75% slower |
| compose | 🚀 Fastest | 96.45% slower | 77.83% slower |
| converge | 49.12% slower | 🚀 Fastest | 🔳 |
| curry | 🚀 Fastest | 34.9% slower | 🔳 |
| curryN | 63.32% slower | 🚀 Fastest | 🔳 |
| defaultTo | 🚀 Fastest | 50.3% slower | 🔳 |
| drop | 🚀 Fastest | 97.45% slower | 🔳 |
| dropLast | 🚀 Fastest | 97.07% slower | 🔳 |
| equals | 72.11% slower | 79.48% slower | 🚀 Fastest |
| filter | 🚀 Fastest | 94.74% slower | 58.18% slower |
| find | 🚀 Fastest | 98.2% slower | 88.96% slower |
| findIndex | 🚀 Fastest | 97.97% slower | 79.39% slower |
| flatten | 6.56% slower | 95.38% slower | 🚀 Fastest |
| ifElse | 🚀 Fastest | 70.97% slower | 🔳 |
| includes | 🚀 Fastest | 71.7% slower | 🔳 |
| indexOf | 🚀 Fastest | 84.08% slower | 7.86% slower |
| init | 94.42% slower | 97.55% slower | 🚀 Fastest |
| is | 🚀 Fastest | 11.72% slower | 🔳 |
| isEmpty | 51.68% slower | 93.82% slower | 🚀 Fastest |
| last | 🚀 Fastest | 99.64% slower | 1.05% slower |
| lastIndexOf | 🚀 Fastest | 42.38% slower | 🔳 |
| map | 🚀 Fastest | 69.63% slower | 4.68% slower |
| match | 🚀 Fastest | 46.75% slower | 🔳 |
| merge | 63.55% slower | 🚀 Fastest | 55.25% slower |
| none | 🚀 Fastest | 98.22% slower | 🔳 |
| omit | 🚀 Fastest | 70.66% slower | 97.56% slower |
| over | 🚀 Fastest | 50.77% slower | 🔳 |
| path | 🚀 Fastest | 74.94% slower | 5.72% slower |
| pick | 🚀 Fastest | 26.29% slower | 86.82% slower |
| prop | 🚀 Fastest | 89.89% slower | 🔳 |
| propEq | 🚀 Fastest | 95.26% slower | 🔳 |
| range | 95.17% slower | 90.22% slower | 🚀 Fastest |
| reduce | 52.76% slower | 74.02% slower | 🚀 Fastest |
| repeat | 85.91% slower | 95.31% slower | 🚀 Fastest |
| replace | 0.47% slower | 28.13% slower | 🚀 Fastest |
| set | 🚀 Fastest | 36.26% slower | 🔳 |
| sort | 🚀 Fastest | 63.15% slower | 🔳 |
| sortBy | 🚀 Fastest | 61.57% slower | 88.88% slower |
| split | 🚀 Fastest | 85.34% slower | 33.69% slower |
| splitEvery | 🚀 Fastest | 90.18% slower | 🔳 |
| take | 93.44% slower | 98.04% slower | 🚀 Fastest |
| takeLast | 92.61% slower | 98.83% slower | 🚀 Fastest |
| test | 🚀 Fastest | 94.42% slower | 🔳 |
| type | 18.91% slower | 🚀 Fastest | 🔳 |
| uniq | 98.98% slower | 96.58% slower | 🚀 Fastest |
| update | 🚀 Fastest | 38.88% slower | 🔳 |
| view | 🚀 Fastest | 82.21% slower | 🔳 |
Walmart Canada reported by w-b-dev
add(a: number, b: number): number
It adds a and b.
:boom: It doesn't work with strings, as the inputs are parsed to numbers before calculation.
R.add(2, 3) // => 5
Try this R.add example in Rambda REPL
add(a: number, b: number): number;
add(a: number): (b: number) => number;
export function add(a, b){
if (arguments.length === 1) return _b => add(a, _b)
return Number(a) + Number(b)
}
import { add } from './add'
test('with number', () => {
expect(add(2, 3)).toEqual(5)
expect(add(7)(10)).toEqual(17)
})
test('string is bad input', () => {
expect(add('foo', 'bar')).toBeNaN()
})
test('ramda specs', () => {
expect(add('1', '2')).toEqual(3)
expect(add(1, '2')).toEqual(3)
expect(add(true, false)).toEqual(1)
expect(add(null, null)).toEqual(0)
expect(add(undefined, undefined)).toEqual(NaN)
expect(add(new Date(1), new Date(2))).toEqual(3)
})
adjust<T>(index: number, replaceFn: (x: T) => T, list: readonly T[]): readonly T[]
It replaces index in array list with the result of replaceFn(list[i]).
R.adjust(
0,
a => a + 1,
[0, 100]
) // => [1, 100]
Try this R.adjust example in Rambda REPL
adjust<T>(index: number, replaceFn: (x: T) => T, list: readonly T[]): readonly T[];
adjust<T>(index: number, replaceFn: (x: T) => T): (list: readonly T[]) => readonly T[];
import { curry } from './curry'
function adjustFn(
index, replaceFn, list
){
const actualIndex = index < 0 ? list.length + index : index
if (index >= list.length || actualIndex < 0) return list
const clone = list.slice()
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)
})
:boom: Reason for the failure: Ramda method accepts an array-like object
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('adjust', function() {
it('accepts an array-like object', function() {
function args() {
return arguments;
}
eq(R.adjust(2, R.add(1), args(0, 1, 2, 3)), [0, 1, 3, 3]);
});
});
all<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean
It returns true, if all members of array list returns true, when applied as argument to predicate function.
const list = [ 0, 1, 2, 3, 4 ]
const predicate = x => x > -1
const result = R.all(predicate, list)
// => true
Try this R.all example in Rambda REPL
all<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean;
all<T>(predicate: (x: T) => boolean): (list: readonly 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()
})
allPass<T>(predicates: readonly ((x: T) => boolean)[]): (input: T) => boolean
It returns true, if all functions of predicates return true, when input is their argument.
const input = {
a : 1,
b : 2,
}
const predicates = [
x => x.a === 1,
x => x.b === 2,
]
const result = R.allPass(predicates)(input) // => true
Try this R.allPass example in Rambda REPL
allPass<T>(predicates: readonly ((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()
})
:boom: Reason for the failure: Ramda method returns a curried function whose arity matches that of the highest-arity predicate
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('allPass', function() {
var odd = function(n) { return n % 2 !== 0; };
var lt20 = function(n) { return n < 20; };
var gt5 = function(n) { return n > 5; };
var plusEq = function(w, x, y, z) { return w + x === y + z; };
it('returns a curried function whose arity matches that of the highest-arity predicate', function() {
eq(R.allPass([odd, gt5, plusEq]).length, 4);
eq(R.allPass([odd, gt5, plusEq])(9, 9, 9, 9), true);
eq(R.allPass([odd, gt5, plusEq])(9)(9)(9)(9), true);
});
});
always<T>(x: T): () => T
It returns function that always returns x.
const fn = R.always(7)
console.log(fn())// => 7
Try this R.always example in Rambda REPL
always<T>(x: T): () => T;
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()
})
and<T, U>(x: T, y: U): T | U
Logical AND
R.and(true, true); // => true
R.and(false, true); // => false
R.and(true, 'foo'); // => 'foo'
Try this R.and example in Rambda REPL
and<T, U>(x: T, y: U): T | U;
and<T>(x: T): <U>(y: U) => T | U;
export function and(a, b){
if (arguments.length === 1) return _b => and(a, _b)
return a && b
}
import { and } from './and'
test('happy', () => {
expect(and(1, 'foo')).toBe('foo')
expect(and(true, true)).toBeTrue()
expect(and(true)(true)).toBeTrue()
expect(and(true, false)).toBeFalse()
expect(and(false, true)).toBeFalse()
expect(and(false, false)).toBeFalse()
})
any<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean
It returns true, if at least one member of list returns true, when passed to a predicate function.
const list = [1, 2, 3]
const predicate = x => x * x > 8
R.any(fn, list)
// => true
Try this R.any example in Rambda REPL
any<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean;
any<T>(predicate: (x: T) => boolean): (list: readonly T[]) => boolean;
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()
})
anyPass<T>(predicates: readonly SafePred<T>[]): SafePred<T>
It accepts list of predicates and returns a function. This function with its input will return true, if any of predicates returns true for this input.
const isBig = x => x > 20
const isOdd = x => x % 2 === 1
const input = 11
const fn = R.anyPass(
[isBig, isOdd]
)
const result = fn(input)
// => true
Try this R.anyPass example in Rambda REPL
anyPass<T>(predicates: readonly 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('happy', () => {
expect(anyPass([])(3)).toEqual(false)
})
:boom: Reason for the failure: Ramda method returns a curried function whose arity matches that of the highest-arity predicate
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('anyPass', function() {
var odd = function(n) { return n % 2 !== 0; };
var gt20 = function(n) { return n > 20; };
var lt5 = function(n) { return n < 5; };
var plusEq = function(w, x, y, z) { return w + x === y + z; };
it('returns a curried function whose arity matches that of the highest-arity predicate', function() {
eq(R.anyPass([odd, lt5, plusEq]).length, 4);
eq(R.anyPass([odd, lt5, plusEq])(6, 7, 8, 9), false);
eq(R.anyPass([odd, lt5, plusEq])(6)(7)(8)(9), false);
});
});
append<T>(x: T, list: readonly T[]): readonly T[]
It adds element x at the end of list.
const x = 'foo'
const result = R.append(x, ['bar', 'baz'])
// => ['bar', 'baz', 'foo']
Try this R.append example in Rambda REPL
append<T>(x: T, list: readonly T[]): readonly T[];
append<T>(x: T): <T>(list: readonly T[]) => readonly T[];
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 = input.slice()
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' ])
})
applySpec<Spec extends Record<string, (...args: readonly any[]) => any>>(
spec: Spec
): (
...args: Parameters<ValueOfRecord<Spec>>
) => { readonly [Key in keyof Spec]: ReturnType<Spec[Key]> }
:boom: The currying in this function works best with functions with 4 arguments or less. (arity of 4)
const fn = R.applySpec({
sum: R.add,
nested: { mul: R.multiply }
})
const result = fn(2, 4)
// => { sum: 6, nested: { mul: 8 } }
Try this R.applySpec example in Rambda REPL
applySpec<Spec extends Record<string, (...args: readonly any[]) => any>>(
spec: Spec
): (
...args: Parameters<ValueOfRecord<Spec>>
) => { readonly [Key in keyof Spec]: ReturnType<Spec[Key]> };
applySpec<T>(spec: any): (...args: readonly 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',
})
})
assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & U
It makes a shallow clone of obj with setting or overriding the property prop with newValue.
:boom: This copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.
R.assoc('c', 3, {a: 1, b: 2})
// => {a: 1, b: 2, c: 3}
Try this R.assoc example in Rambda REPL
assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & U;
assoc<T, K extends string>(prop: K, val: T): <U>(obj: U) => Record<K, T> & U;
assoc<K extends string>(prop: K): AssocPartialOne<K>;
import { 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 } })
})
assocPath<Output>(path: Path, newValue: any, obj: object): Output
It makes a shallow clone of obj with setting or overriding with newValue the property found with path.
const path = 'b.c'
const newValue = 2
const obj = { a: 1 }
R.assocPath(path, newValue, obj)
// => { a : 1, b : { c : 2 }}
Try this R.assocPath example in Rambda REPL
assocPath<Output>(path: Path, newValue: any, obj: object): Output;
assocPath<Output>(path: Path, newValue: any): (obj: object) => Output;
assocPath<Output>(path: Path): FunctionToolbelt.Curry<(newValue: any, obj: object) => Output>;
import { _isArray } from './_internals/_isArray'
import { _isInteger } from './_internals/_isInteger'
import { assoc } from './assoc'
import { curry } from './curry'
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 = input.slice()
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)
})
both(pred1: Pred, pred2: Pred): Pred
It returns a function with input argument.
This function will return true, if both firstCondition and secondCondition return true when input is passed as their argument.
const firstCondition = x => x > 10
const secondCondition = x => x < 20
const fn = R.both(secondCondition)
const result = [fn(15), fn(30)]
// => [true, false]
Try this R.both example in Rambda REPL
both(pred1: Pred, pred2: Pred): Pred;
both<T>(pred1: Predicate<T>, pred2: Predicate<T>): Predicate<T>;
both<T>(pred1: Predicate<T>): (pred2: Predicate<T>) => Predicate<T>;
both(pred1: Pred): (pred2: Pred) => Pred;
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')
})
:boom: Reason for the failure: Ramda library supports fantasy-land
var S = require('sanctuary');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('both', function() {
it('accepts fantasy-land applicative functors', function() {
var Just = S.Just;
var Nothing = S.Nothing;
eq(R.both(Just(true), Just(true)), Just(true));
eq(R.both(Just(true), Just(false)), Just(false));
eq(R.both(Just(true), Nothing()), Nothing());
eq(R.both(Nothing(), Just(false)), Nothing());
eq(R.both(Nothing(), Nothing()), Nothing());
});
});
chain<T, U>(fn: (n: T) => readonly U[], list: readonly T[]): readonly U[]
The method is also known as flatMap.
const duplicate = n => [ n, n ]
const list = [ 1, 2, 3 ]
const result = chain(duplicate, list)
// => [ 1, 1, 2, 2, 3, 3 ]
Try this R.chain example in Rambda REPL
chain<T, U>(fn: (n: T) => readonly U[], list: readonly T[]): readonly U[];
chain<T, U>(fn: (n: T) => readonly U[]): (list: readonly T[]) => readonly U[];
chain<X0, X1, R>(fn: (x0: X0, x1: X1) => R, fn1: (x1: X1) => X0): (x1: X1) => R;
export function chain(fn, list){
if (arguments.length === 1){
return _list => chain(fn, _list)
}
return [].concat(...list.map(fn))
}
import { chain } from './chain'
const duplicate = n => [ n, n ]
test('happy', () => {
const fn = x => [ x * 2 ]
const list = [ 1, 2, 3 ]
const result = chain(fn, list)
expect(result).toEqual([ 2, 4, 6 ])
})
test('maps then flattens one level', () => {
expect(chain(duplicate, [ 1, 2, 3 ])).toEqual([ 1, 1, 2, 2, 3, 3 ])
})
test('maps then flattens one level - curry', () => {
expect(chain(duplicate)([ 1, 2, 3 ])).toEqual([ 1, 1, 2, 2, 3, 3 ])
})
test('flattens only one level', () => {
const nest = n => [ [ n ] ]
expect(chain(nest, [ 1, 2, 3 ])).toEqual([ [ 1 ], [ 2 ], [ 3 ] ])
})
5 failed Ramda.chain specs
:boom: Reason for the failure: Ramda method passes to
chainproperty if available | Ramda library supports fantasy-land
clamp(min: number, max: number, input: number): number
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.
const result = [
R.clamp(0, 10, 5),
R.clamp(0, 10, -1),
R.clamp(0, 10, 11)
]
// => [5, 0, 10]
Try this R.clamp example in Rambda REPL
clamp(min: number, max: number, input: number): number;
clamp(min: number, max: number): (input: number) => number;
import { curry } from './curry'
function clampFn(
min, max, input
){
if (min > max){
throw new Error('min must not be greater than max in clamp(min, max, value)')
}
if (input >= min && input <= max) return input
if (input > max) return max
if (input < min) return min
}
export const clamp = curry(clampFn)
import { clamp } from './clamp'
test('when min is greater than max', () => {
expect(() => clamp(
-5, -10, 5
)).toThrowWithMessage(Error,
'min must not be greater than max in clamp(min, max, value)')
})
test('rambda specs', () => {
expect(clamp(
1, 10, 0
)).toEqual(1)
expect(clamp(
3, 12, 1
)).toEqual(3)
expect(clamp(
-15, 3, -100
)).toEqual(-15)
expect(clamp(
1, 10, 20
)).toEqual(10)
expect(clamp(
3, 12, 23
)).toEqual(12)
expect(clamp(
-15, 3, 16
)).toEqual(3)
expect(clamp(
1, 10, 4
)).toEqual(4)
expect(clamp(
3, 12, 6
)).toEqual(6)
expect(clamp(
-15, 3, 0
)).toEqual(0)
})
clone<T>(input: T): T
It creates a deep copy of the input, which may contain (nested) Arrays and Objects, Numbers, Strings, Booleans and Dates.
const objects = [{a: 1}, {b: 2}];
const objectsClone = R.clone(objects);
const result = [
R.equals(objects, objectsClone),
R.equals(objects[0], objectsClone[0]),
] // => [ true, true ]
Try this R.clone example in Rambda REPL
clone<T>(input: T): T;
clone<T>(input: readonly T[]): readonly T[];
import { _isArray } from './_internals/_isArray'
export function clone(input){
const out = _isArray(input) ? Array(input.length) : {}
if (input && input.getTime) return new Date(input.getTime())
for (const key in input){
const v = input[ key ]
out[ key ] =
typeof v === 'object' && v !== null ?
v.getTime ?
new Date(v.getTime()) :
clone(v) :
v
}
return out
}
import assert from 'assert'
import { clone } from './clone'
import { equals } from './equals'
test('with array', () => {
const arr = [
{
b : 2,
c : 'foo',
d : [ 1, 2, 3 ],
},
1,
new Date(),
null,
]
expect(clone(arr)).toEqual(arr)
})
test('with object', () => {
const obj = {
a : 1,
b : 2,
c : 3,
d : [ 1, 2, 3 ],
e : new Date(),
}
expect(clone(obj)).toEqual(obj)
})
test('with date', () => {
const date = new Date(
2014, 10, 14, 23, 59, 59, 999
)
const cloned = clone(date)
assert.notStrictEqual(date, cloned)
expect(cloned).toEqual(new Date(
2014, 10, 14, 23, 59, 59, 999
))
expect(cloned.getDay()).toEqual(5)
})
test('with R.equals', () => {
const objects = [ { a : 1 }, { b : 2 } ]
const objectsClone = clone(objects)
const result = [
equals(objects, objectsClone),
equals(objects[ 0 ], objectsClone[ 0 ]),
]
expect(result).toEqual([ true, true ])
})
:boom: Reason for the failure: Rambda method work only with objects and arrays
var assert = require('assert');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('deep clone integers, strings and booleans', function() {
it('clones integers', function() {
eq(R.clone(-4), -4);
eq(R.clone(9007199254740991), 9007199254740991);
});
it('clones floats', function() {
eq(R.clone(-4.5), -4.5);
eq(R.clone(0.0), 0.0);
});
it('clones strings', function() {
eq(R.clone('ramda'), 'ramda');
});
it('clones booleans', function() {
eq(R.clone(true), true);
});
});
describe('deep clone objects', function() {
it('clones objects with circular references', function() {
var x = {c: null};
var y = {a: x};
var z = {b: y};
x.c = z;
var clone = R.clone(x);
assert.notStrictEqual(x, clone);
assert.notStrictEqual(x.c, clone.c);
assert.notStrictEqual(x.c.b, clone.c.b);
assert.notStrictEqual(x.c.b.a, clone.c.b.a);
assert.notStrictEqual(x.c.b.a.c, clone.c.b.a.c);
eq(R.keys(clone), R.keys(x));
eq(R.keys(clone.c), R.keys(x.c));
eq(R.keys(clone.c.b), R.keys(x.c.b));
eq(R.keys(clone.c.b.a), R.keys(x.c.b.a));
eq(R.keys(clone.c.b.a.c), R.keys(x.c.b.a.c));
x.c.b = 1;
assert.notDeepEqual(clone.c.b, x.c.b);
});
});
describe('deep clone arrays', function() {
});
describe('deep clone functions', function() {
});
describe('built-in types', function() {
it('clones RegExp object', function() {
R.forEach(function(pattern) {
var clone = R.clone(pattern);
assert.notStrictEqual(clone, pattern);
eq(clone.constructor, RegExp);
eq(clone.source, pattern.source);
eq(clone.global, pattern.global);
eq(clone.ignoreCase, pattern.ignoreCase);
eq(clone.multiline, pattern.multiline);
}, [/x/, /x/g, /x/i, /x/m, /x/gi, /x/gm, /x/im, /x/gim]);
});
});
describe('deep clone deep nested mixed objects', function() {
it('clones array with mutual ref object', function() {
var obj = {a: 1};
var list = [{b: obj}, {b: obj}];
var clone = R.clone(list);
assert.strictEqual(list[0].b, list[1].b);
assert.strictEqual(clone[0].b, clone[1].b);
assert.notStrictEqual(clone[0].b, list[0].b);
assert.notStrictEqual(clone[1].b, list[1].b);
eq(clone[0].b, {a:1});
eq(clone[1].b, {a:1});
obj.a = 2;
eq(clone[0].b, {a:1});
eq(clone[1].b, {a:1});
});
});
describe('deep clone edge cases', function() {
it('nulls, undefineds and empty objects and arrays', function() {
eq(R.clone(null), null);
eq(R.clone(undefined), undefined);
assert.notStrictEqual(R.clone(undefined), null);
var obj = {};
assert.notStrictEqual(R.clone(obj), obj);
var list = [];
assert.notStrictEqual(R.clone(list), list);
});
});
describe('Let `R.clone` use an arbitrary user defined `clone` method', function() {
it('dispatches to `clone` method if present', function() {
function ArbitraryClone(x) { this.value = x; }
ArbitraryClone.prototype.clone = function() { return new ArbitraryClone(this.value); };
var obj = new ArbitraryClone(42);
var arbitraryClonedObj = R.clone(obj);
eq(arbitraryClonedObj, new ArbitraryClone(42));
eq(arbitraryClonedObj instanceof ArbitraryClone, true);
});
});
complement<T extends readonly any[]>(pred: (...args: T) => boolean): (...args: T) => boolean
It returns inverted version of origin function that accept input as argument.
The return value of inverted is the negative boolean value of origin(input).
const origin = x => x > 5
const inverted = complement(origin)
const result = [
origin(7),
inverted(7)
] => [ true, false ]
Try this R.complement example in Rambda REPL
complement<T extends readonly any[]>(pred: (...args: T) => boolean): (...args: T) => boolean;
export function complement(fn){
return (...input) => !fn(...input)
}
import { complement } from './complement'
test('happy', () => {
const fn = complement(x => x.length === 0)
expect(fn([ 1, 2, 3 ])).toBeTrue()
})
test('with multiple parameters', () => {
const between = function (
a, b, c
){
return a < b && b < c
}
const f = complement(between)
expect(f(
4, 5, 11
)).toEqual(false)
expect(f(
12, 2, 6
)).toEqual(true)
})
:boom: Reason for the failure: Ramda library supports fantasy-land
var S = require('sanctuary');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('complement', function() {
it('accepts fantasy-land functors', function() {
var Just = S.Just;
var Nothing = S.Nothing;
eq(R.complement(Just(true)), Just(false));
eq(R.complement(Just(false)), Just(true));
eq(R.complement(Nothing()), Nothing());
});
});
compose<T1>(fn0: () => T1): () => T1
It performs right-to-left function composition.
const result = R.compose(
R.map(x => x * 2),
R.filter(x => x > 2)
)([1, 2, 3, 4])
// => [6, 8]
Try this R.compose example in Rambda REPL
compose<T1>(fn0: () => T1): () => T1;
compose<V0, T1>(fn0: (x0: V0) => T1): (x0: V0) => T1;
compose<V0, V1, T1>(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1;
compose<V0, V1, V2, T1>(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1;
compose<T1, T2>(fn1: (x: T1) => T2, fn0: () => T1): () => T2;
compose<V0, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0) => T1): (x0: V0) => T2;
compose<V0, V1, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T2;
compose<V0, V1, V2, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T2;
compose<T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T3;
compose<V0, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T3;
compose<V0, V1, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T3;
compose<V0, V1, V2, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T3;
compose<T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T4;
compose<V0, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T4;
compose<V0, V1, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T4;
compose<V0, V1, V2, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T4;
compose<T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T5;
compose<V0, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T5;
compose<V0, V1, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T5;
compose<V0, V1, V2, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T5;
compose<T1, T2, T3, T4, T5, T6>(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T6;
compose<V0, T1, T2, T3, T4, T5, T6>(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T6;
compose<V0, V1, T1, T2, T3, T4, T5, T6>(
fn5: (x: T5) => T6,
fn4: (x: T4) => T5,
fn3: (x: T3) => T4,
fn2: (x: T2) => T3,
fn1: (x: T1) => T2,
fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T6;
compose<V0, V1, V2, T1, T2, T3, T4, T5, T6>(
fn5: (x: T5) => T6,
fn4: (x: T4) => T5,
fn3: (x: T3) => T4,
fn2: (x: T2) => T3,
fn1: (x: T1) => T2,
fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T6;
export function compose(...fns){
if (fns.length === 0){
throw new Error('compose requires at least one argument')
}
return (...args) => {
const list = fns.slice()
if (list.length > 0){
const fn = list.pop()
let result = fn(...args)
while (list.length > 0){
result = list.pop()(result)
}
return result
}
}
}
import { add } from './add'
import { compose } from './compose'
import { filter } from './filter'
import { last } from './last'
import { map } from './map'
test('happy', () => {
const result = compose(
last, map(add(10)), map(add(1))
)([ 1, 2, 3 ])
expect(result).toEqual(14)
})
test('can accepts initially two arguments', () => {
const result = compose(map(x => x * 2),
(list, limit) => filter(x => x > limit, list))([ 1, 2, 3, 4, false ], 2)
expect(result).toEqual([ 6, 8 ])
})
test('when no arguments is passed', () => {
expect(() => compose()).toThrow('compose requires at least one argument')
})
test('ramda spec', () => {
const f = function (
a, b, c
){
return [ a, b, c ]
}
const g = compose(f)
expect(g(
1, 2, 3
)).toEqual([ 1, 2, 3 ])
})
:boom: Reason for the failure: Ramda method passes context to functions | Rambda composed functions have no length
var assert = require('assert');
var jsv = require('jsverify');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('compose', function() {
it('performs right-to-left function composition', function() {
// f :: (String, Number?) -> ([Number] -> [Number])
var f = R.compose(R.map, R.multiply, parseInt);
eq(f.length, 2);
eq(f('10')([1, 2, 3]), [10, 20, 30]);
eq(f('10', 2)([1, 2, 3]), [2, 4, 6]);
});
it('passes context to functions', function() {
function x(val) {
return this.x * val;
}
function y(val) {
return this.y * val;
}
function z(val) {
return this.z * val;
}
var context = {
a: R.compose(x, y, z),
x: 4,
y: 2,
z: 1
};
eq(context.a(5), 40);
});
it('can be applied to one argument', function() {
var f = function(a, b, c) { return [a, b, c]; };
var g = R.compose(f);
eq(g.length, 3);
eq(g(1, 2, 3), [1, 2, 3]);
});
});
describe('compose properties', function() {
jsv.property('composes two functions', jsv.fn(), jsv.fn(), jsv.nat, function(f, g, x) {
return R.equals(R.compose(f, g)(x), f(g(x)));
jsv.property('associative', jsv.fn(), jsv.fn(), jsv.fn(), jsv.nat, function(f, g, h, x) {
var result = f(g(h(x)));
return R.all(R.equals(result), [
R.compose(f, g, h)(x),
R.compose(f, R.compose(g, h))(x),
R.compose(R.compose(f, g), h)(x)
]);
});
concat<T>(x: readonly T[], y: readonly T[]): readonly T[]
It returns a new string or array, which is the result of merging x and y.
R.concat([1, 2])([3, 4]) // => [1, 2, 3, 4]
R.concat('foo', 'bar') // => 'foobar'
Try this R.concat example in Rambda REPL
concat<T>(x: readonly T[], y: readonly T[]): readonly T[];
concat<T>(x: readonly T[]): (y: readonly T[]) => readonly T[];
concat(x: string, y: string): string;
concat(x: string): (y: string) => string;
export function concat(x, y){
if (arguments.length === 1) return _y => concat(x, _y)
return typeof x === 'string' ? `${ x }${ y }` : [ ...x, ...y ]
}
import { concat } from './concat'
test('happy', () => {
const arr1 = [ 'a', 'b', 'c' ]
const arr2 = [ 'd', 'e', 'f' ]
const a = concat(arr1, arr2)
const b = concat(arr1)(arr2)
const expectedResult = [ 'a', 'b', 'c', 'd', 'e', 'f' ]
expect(a).toEqual(expectedResult)
expect(b).toEqual(expectedResult)
})
test('with strings', () => {
expect(concat('ABC', 'DEF')).toEqual('ABCDEF')
})
:boom: Reason for the failure: Ramda method pass to
concatproperty if present
var assert = require('assert');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('concat', function() {
var z1 = {
x: 'z1',
concat: function(that) { return this.x + ' ' + that.x; }
};
var z2 = {
x: 'z2'
};
it('delegates to non-String object with a concat method, as second param', function() {
eq(R.concat(z1, z2), 'z1 z2');
});
});
cond(conditions: readonly (readonly [Pred, (...a: readonly any[]) => any])[]): (...x: readonly any[]) => any
It takes list with conditions and returns a new function fn that expects input as argument.
This function will start evaluating the conditions in order to find the first winner(order of conditions matter).
The winner is this condition, which left side returns true when input is its argument. Then the evaluation of the right side of the winner will be the final result.
If no winner is found, then fn returns undefined.
const fn = R.cond([
[ x => x > 25, R.always('more than 25') ],
[ x => x > 15, R.always('more than 15') ],
[ R.T, x => `${x} is nothing special` ],
])
const result = [
fn(30),
fn(20),
fn(10),
]
// => ['more than 25', 'more than 15', '10 is nothing special']
Try this R.cond example in Rambda REPL
cond(conditions: readonly (readonly [Pred, (...a: readonly any[]) => any])[]): (...x: readonly any[]) => any;
cond<A, B>(conditions: readonly (readonly [SafePred<A>, (...a: readonly A[]) => B])[]): (...x: readonly A[]) => B;
export function cond(conditions){
return input => {
let done = false
let toReturn
conditions.forEach(([ predicate, resultClosure ]) => {
if (!done && predicate(input)){
done = true
toReturn = resultClosure(input)
}
})
return toReturn
}
}
import { always } from './always'
import { cond } from './cond'
import { equals } from './equals'
import { T } from './T'
test('returns a function', () => {
expect(typeof cond([])).toEqual('function')
})
test('returns a conditional function', () => {
const fn = cond([
[ equals(0), always('water freezes at 0°C') ],
[ equals(100), always('water boils at 100°C') ],
[
T,
function (temp){
return 'nothing special happens at ' + temp + '°C'
},
],
])
expect(fn(0)).toEqual('water freezes at 0°C')
expect(fn(50)).toEqual('nothing special happens at 50°C')
expect(fn(100)).toEqual('water boils at 100°C')
})
test('no winner', () => {
const fn = cond([
[ equals('foo'), always(1) ],
[ equals('bar'), always(2) ],
])
expect(fn('quux')).toEqual(undefined)
})
test('predicates are tested in order', () => {
const fn = cond([
[ T, always('foo') ],
[ T, always('bar') ],
[ T, always('baz') ],
])
expect(fn()).toEqual('foo')
})
:boom: Reason for the failure: pass to transformer is not applied in Rambda method
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('cond', function() {
it('forwards all arguments to predicates and to transformers', function() {
var fn = R.cond([
[function(_, x) { return x === 42; }, function() { return arguments.length; }]
]);
eq(fn(21, 42, 84), 3);
});
it('retains highest predicate arity', function() {
var fn = R.cond([
[R.nAry(2, R.T), R.T],
[R.nAry(3, R.T), R.T],
[R.nAry(1, R.T), R.T]
]);
eq(fn.length, 3);
});
});
converge(after: ((...a: readonly any[]) => any), fns: ReadonlyArray<((...x: readonly any[]) => any)>): (...y: readonly any[]) => any
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.
:boom: Explanation is taken from
Ramdadocumentation
const result = R.converge(R.multiply)([ R.add(1), R.add(3) ])(2)
// => 15
Try this R.converge example in Rambda REPL
converge(after: ((...a: readonly any[]) => any), fns: ReadonlyArray<((...x: readonly any[]) => any)>): (...y: readonly any[]) => any;
import { curryN } from './curryN'
import { map } from './map'
import { max } from './max'
import { reduce } from './reduce'
export function converge(fn, transformers){
if (arguments.length === 1)
return _transformers => converge(fn, _transformers)
const highestArity = reduce(
(a, b) => max(a, b.length), 0, transformers
)
return curryN(highestArity, function (){
return fn.apply(this,
map(g => g.apply(this, arguments), transformers))
})
}
import { add } from './add'
import { converge } from './converge'
import { multiply } from './multiply'
const f1 = converge(multiply, [ a => a + 1, a => a + 10 ])
const f2 = converge(multiply, [ a => a + 1, (a, b) => a + b + 10 ])
const f3 = converge(multiply, [ a => a + 1, (
a, b, c
) => a + b + c + 10 ])
test('happy', () => {
expect(f2(6, 7)).toEqual(161)
})
test('passes the results of applying the arguments individually', () => {
const result = converge(multiply)([ add(1), add(3) ])(2)
expect(result).toEqual(15)
})
test('returns a function with the length of the longest argument', () => {
expect(f1.length).toEqual(1)
expect(f2.length).toEqual(2)
expect(f3.length).toEqual(3)
})
test('passes context to its functions', () => {
const a = function (x){
return this.f1(x)
}
const b = function (x){
return this.f2(x)
}
const c = function (x, y){
return this.f3(x, y)
}
const d = converge(c, [ a, b ])
const context = {
f1 : add(1),
f2 : add(2),
f3 : add,
}
expect(a.call(context, 1)).toEqual(2)
expect(b.call(context, 1)).toEqual(3)
expect(d.call(context, 1)).toEqual(5)
})
test('works with empty functions list', () => {
const fn = converge(function (){
return arguments.length
}, [])
expect(fn.length).toEqual(0)
expect(fn()).toEqual(0)
})
curry(fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any
It expects a function as input and returns its curried version.
const fn = (a, b, c) => a + b + c
const curried = R.curry(fn)
const sum = curried(1,2)
const result = sum(3) // => 6
Try this R.curry example in Rambda REPL
curry(fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any;
export function curry(fn, args = []){
return (..._args) =>
(rest => rest.length >= fn.length ? fn(...rest) : curry(fn, rest))([
...args,
..._args,
])
}
import { curry } from './curry'
test('happy', () => {
const addFourNumbers = (
a, b, c, d
) => a + b + c + d
const curriedAddFourNumbers = curry(addFourNumbers)
const f = curriedAddFourNumbers(1, 2)
const g = f(3)
expect(g(4)).toEqual(10)
})
test('when called with more arguments', () => {
const add = curry((n, n2) => n + n2)
expect(add(
1, 2, 3
)).toEqual(3)
})
test('when called with zero arguments', () => {
const sub = curry((a, b) => a - b)
const s0 = sub()
expect(s0(5, 2)).toEqual(3)
})
test('when called via multiple curry stages', () => {
const join = curry((
a, b, c, d
) => [ a, b, c, d ].join('-'))
const stage1 = join('A')
const stage2 = stage1('B', 'C')
expect(stage2('D')).toEqual('A-B-C-D')
})
:boom: Reason for the failure: Ramda library support placeholder(R.__)
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
var jsv = require('jsverify');
var funcN = require('./shared/funcN');
describe('curry', function() {
it('properly reports the length of the curried function', function() {
var f = R.curry(function(a, b, c, d) {return (a + b * c) / d;});
eq(f.length, 4);
var g = f(12);
eq(g.length, 3);
var h = g(3);
eq(h.length, 2);
eq(g(3, 6).length, 1);
});
it('preserves context', function() {
var ctx = {x: 10};
var f = function(a, b) { return a + b * this.x; };
var g = R.curry(f);
eq(g.call(ctx, 2, 4), 42);
eq(g.call(ctx, 2).call(ctx, 4), 42);
});
it('supports R.__ placeholder', function() {
var f = function(a, b, c) { return [a, b, c]; };
var g = R.curry(f);
var _ = R.__;
eq(g(1)(2)(3), [1, 2, 3]);
eq(g(1)(2, 3), [1, 2, 3]);
eq(g(1, 2)(3), [1, 2, 3]);
eq(g(1, 2, 3), [1, 2, 3]);
eq(g(_, 2, 3)(1), [1, 2, 3]);
eq(g(1, _, 3)(2), [1, 2, 3]);
eq(g(1, 2, _)(3), [1, 2, 3]);
eq(g(1, _, _)(2)(3), [1, 2, 3]);
eq(g(_, 2, _)(1)(3), [1, 2, 3]);
eq(g(_, _, 3)(1)(2), [1, 2, 3]);
eq(g(1, _, _)(2, 3), [1, 2, 3]);
eq(g(_, 2, _)(1, 3), [1, 2, 3]);
eq(g(_, _, 3)(1, 2), [1, 2, 3]);
eq(g(1, _, _)(_, 3)(2), [1, 2, 3]);
eq(g(_, 2, _)(_, 3)(1), [1, 2, 3]);
eq(g(_, _, 3)(_, 2)(1), [1, 2, 3]);
eq(g(_, _, _)(_, _)(_)(1, 2, 3), [1, 2, 3]);
eq(g(_, _, _)(1, _, _)(_, _)(2, _)(_)(3), [1, 2, 3]);
});
it('supports @@functional/placeholder', function() {
var f = function(a, b, c) { return [a, b, c]; };
var g = R.curry(f);
var _ = {'@@functional/placeholder': true, x: Math.random()};
eq(g(1)(2)(3), [1, 2, 3]);
eq(g(1)(2, 3), [1, 2, 3]);
eq(g(1, 2)(3), [1, 2, 3]);
eq(g(1, 2, 3), [1, 2, 3]);
eq(g(_, 2, 3)(1), [1, 2, 3]);
eq(g(1, _, 3)(2), [1, 2, 3]);
eq(g(1, 2, _)(3), [1, 2, 3]);
eq(g(1, _, _)(2)(3), [1, 2, 3]);
eq(g(_, 2, _)(1)(3), [1, 2, 3]);
eq(g(_, _, 3)(1)(2), [1, 2, 3]);
eq(g(1, _, _)(2, 3), [1, 2, 3]);
eq(g(_, 2, _)(1, 3), [1, 2, 3]);
eq(g(_, _, 3)(1, 2), [1, 2, 3]);
eq(g(1, _, _)(_, 3)(2), [1, 2, 3]);
eq(g(_, 2, _)(_, 3)(1), [1, 2, 3]);
eq(g(_, _, 3)(_, 2)(1), [1, 2, 3]);
eq(g(_, _, _)(_, _)(_)(1, 2, 3), [1, 2, 3]);
eq(g(_, _, _)(1, _, _)(_, _)(2, _)(_)(3), [1, 2, 3]);
});
});
describe('curry properties', function() {
jsv.property('curries multiple values', funcN(4), jsv.json, jsv.json, jsv.json, jsv.json, function(f, a, b, c, d) {
var g = R.curry(f);
return R.all(R.equals(f(a, b, c, d)), [
g(a, b, c, d),
g(a)(b)(c)(d),
g(a)(b, c, d),
g(a, b)(c, d),
g(a, b, c)(d)
]);
jsv.property('curries with placeholder', funcN(3), jsv.json, jsv.json, jsv.json, function(f, a, b, c) {
var _ = {'@@functional/placeholder': true, x: Math.random()};
var g = R.curry(f);
return R.all(R.equals(f(a, b, c)), [
g(_, _, c)(a, b),
g(a, _, c)(b),
g(_, b, c)(a),
g(a, _, _)(_, c)(b),
g(a, b, _)(c)
]);
});
curryN(length: number, fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any
It returns a curried equivalent of the provided function, with the specified arity.
curryN(length: number, fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any;
function _curryN(
n, cache, fn
){
return function (){
let ci = 0
let ai = 0
const cl = cache.length
const al = arguments.length
const args = new Array(cl + al)
while (ci < cl){
args[ ci ] = cache[ ci ]
ci++
}
while (ai < al){
args[ cl + ai ] = arguments[ ai ]
ai++
}
const remaining = n - args.length
return args.length >= n ?
fn.apply(this, args) :
_arity(remaining, _curryN(
n, args, fn
))
}
}
function _arity(n, fn){
switch (n){
case 0:
return function (){
return fn.apply(this, arguments)
}
case 1:
return function (_1){
return fn.apply(this, arguments)
}
case 2:
return function (_1, _2){
return fn.apply(this, arguments)
}
case 3:
return function (
_1, _2, _3
){
return fn.apply(this, arguments)
}
case 4:
return function (
_1, _2, _3, _4
){
return fn.apply(this, arguments)
}
case 5:
return function (
_1, _2, _3, _4, _5
){
return fn.apply(this, arguments)
}
case 6:
return function (
_1, _2, _3, _4, _5, _6
){
return fn.apply(this, arguments)
}
case 7:
return function (
_1, _2, _3, _4, _5, _6, _7
){
return fn.apply(this, arguments)
}
case 8:
return function (
_1, _2, _3, _4, _5, _6, _7, _8
){
return fn.apply(this, arguments)
}
case 9:
return function (
_1, _2, _3, _4, _5, _6, _7, _8, _9
){
return fn.apply(this, arguments)
}
default:
return function (
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10
){
return fn.apply(this, arguments)
}
}
}
export function curryN(n, fn){
if (arguments.length === 1) return _fn => curryN(n, _fn)
if (n > 10){
throw new Error('First argument to _arity must be a non-negative integer no greater than ten')
}
return _arity(n, _curryN(
n, [], fn
))
}
import { curryN } from './curryN'
function multiply(
a, b, c, d, e, f, g, h, i, j, k, l
){
if (l){
return a * b * c * d * e * f * g * h * i * j * k * l
}
if (k){
return a * b * c * d * e * f * g * h * i * j * k
}
if (j){
return a * b * c * d * e * f * g * h * i * j
}
if (i){
return a * b * c * d * e * f * g * h * i
}
if (h){
return a * b * c * d * e * f * g * h
}
if (g){
return a * b * c * d * e * f * g
}
if (f){
return a * b * c * d * e * f
}
if (e){
return a * b * c * d * e
}
return a * b * c
}
test('accepts an arity', () => {
const curried = curryN(3, multiply)
expect(curried(1)(2)(3)).toEqual(6)
expect(curried(1, 2)(3)).toEqual(6)
expect(curried(1)(2, 3)).toEqual(6)
expect(curried(
1, 2, 3
)).toEqual(6)
})
test('can be partially applied', () => {
const curry3 = curryN(3)
const curried = curry3(multiply)
expect(curried.length).toEqual(3)
expect(curried(1)(2)(3)).toEqual(6)
expect(curried(1, 2)(3)).toEqual(6)
expect(curried(1)(2, 3)).toEqual(6)
expect(curried(
1, 2, 3
)).toEqual(6)
})
test('preserves context', () => {
const ctx = { x : 10 }
const f = function (a, b){
return a + b * this.x
}
const g = curryN(2, f)
expect(g.call(
ctx, 2, 4
)).toEqual(42)
expect(g.call(ctx, 2).call(ctx, 4)).toEqual(42)
})
test('number of arguments is 4', () => {
const fn = curryN(4, multiply)
expect(fn(
1, 2, 3, 4
)).toEqual(6)
})
test('number of arguments is 5', () => {
const fn = curryN(5, multiply)
expect(fn(
1, 2, 3, 4, 5
)).toEqual(120)
})
test('number of arguments is 6', () => {
const fn = curryN(6, multiply)
expect(fn(
1, 2, 3, 4, 5, 6
)).toEqual(720)
})
test('number of arguments is 7', () => {
const fn = curryN(7, multiply)
expect(fn(
1, 2, 3, 4, 5, 6, 7
)).toEqual(5040)
})
test('number of arguments is 8', () => {
const fn = curryN(8, multiply)
expect(fn(
1, 2, 3, 4, 5, 6, 7, 8
)).toEqual(40320)
})
test('number of arguments is 9', () => {
const fn = curryN(9, multiply)
expect(fn(
1, 2, 3, 4, 5, 6, 7, 8, 9
)).toEqual(362880)
})
test('number of arguments is 10', () => {
const fn = curryN(10, multiply)
expect(fn(
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
)).toEqual(3628800)
})
test('number of arguments is 11', () => {
expect(() => {
const fn = curryN(11, multiply)
fn(
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
)
}).toThrowWithMessage(Error,
'First argument to _arity must be a non-negative integer no greater than ten')
})
test('forwards extra arguments', () => {
const createArray = function (){
return Array.prototype.slice.call(arguments)
}
const fn = curryN(3, createArray)
expect(fn(
1, 2, 3
)).toEqual([ 1, 2, 3 ])
expect(fn(
1, 2, 3, 4
)).toEqual([ 1, 2, 3, 4 ])
expect(fn(1, 2)(3, 4)).toEqual([ 1, 2, 3, 4 ])
expect(fn(1)(
2, 3, 4
)).toEqual([ 1, 2, 3, 4 ])
expect(fn(1)(2)(3, 4)).toEqual([ 1, 2, 3, 4 ])
})
dec(x: number): number
It decrements a number.
dec(x: number): number;
export const dec = x => x - 1
import { dec } from './dec'
test('happy', () => {
expect(dec(2)).toBe(1)
})
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).
:boom: Rambda's defaultTo accept indefinite number of arguments when non curried, i.e.
R.defaultTo(2, foo, bar, baz).
R.defaultTo('foo', 'bar') // => 'bar'
R.defaultTo('foo', undefined) // => 'foo'
// Important - emtpy string is not falsy value(same as Ramda)
R.defaultTo('foo', '') // => 'foo'
Try this R.defaultTo example in Rambda REPL
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')
})
difference<T>(a: readonly T[], b: readonly T[]): readonly T[]
It returns the uniq set of all elements in the first list a not contained in the second list b.
const a = [ 1, 2, 3, 4 ]
const b = [ 3, 4, 5, 6 ]
const result = difference(a, b)
// => [ 1, 2 ]
Try this R.difference example in Rambda REPL
difference<T>(a: readonly T[], b: readonly T[]): readonly T[];
difference<T>(a: readonly T[]): (b: readonly T[]) => readonly 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'
test('difference', () => {
const a = [ 1, 2, 3, 4 ]
const b = [ 3, 4, 5, 6 ]
expect(difference(a)(b)).toEqual([ 1, 2 ])
expect(difference([], [])).toEqual([])
})
test('difference with objects', () => {
const a = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
const b = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
expect(difference(a, b)).toEqual([ { id : 1 }, { id : 2 } ])
})
test('no duplicates in first list', () => {
const M2 = [ 1, 2, 3, 4, 1, 2, 3, 4 ]
const N2 = [ 3, 3, 4, 4, 5, 5, 6, 6 ]
expect(difference(M2, N2)).toEqual([ 1, 2 ])
})
test('should use R.equals', () => {
expect(difference([ NaN ], [ NaN ]).length).toEqual(0)
})
dissoc<T>(prop: string, obj: any): T
It returns a new object that does not contain property prop.
R.dissoc('b', {a: 1, b: 2, c: 3})
// => {a: 1, c: 3}
Try this R.dissoc example in Rambda REPL
dissoc<T>(prop: string, obj: any): T;
dissoc<T>(prop: string): (obj: any) => T;
export function dissoc(prop, obj){
if (arguments.length === 1) return _obj => dissoc(prop, _obj)
if (obj === null || obj === undefined) return {}
const willReturn = {}
for (const p in obj){
willReturn[ p ] = obj[ p ]
}
delete willReturn[ prop ]
return willReturn
}
import { dissoc } from './dissoc'
test('input is null or undefined', () => {
expect(dissoc('b', null)).toEqual({})
expect(dissoc('b', undefined)).toEqual({})
})
test('property exists curried', () => {
expect(dissoc('b')({
a : 1,
b : 2,
})).toEqual({ a : 1 })
})
test('property doesn\'t exists', () => {
expect(dissoc('c', {
a : 1,
b : 2,
})).toEqual({
a : 1,
b : 2,
})
})
test('works with non-string property', () => {
expect(dissoc(42, {
a : 1,
42 : 2,
})).toEqual({ a : 1 })
expect(dissoc(null, {
a : 1,
null : 2,
})).toEqual({ a : 1 })
expect(dissoc(undefined, {
a : 1,
undefined : 2,
})).toEqual({ a : 1 })
})
test('includes prototype properties', () => {
function Rectangle(width, height){
this.width = width
this.height = height
}
const area = Rectangle.prototype.area = function (){
return this.width * this.height
}
const rect = new Rectangle(7, 6)
expect(dissoc('area', rect)).toEqual({
width : 7,
height : 6,
})
expect(dissoc('width', rect)).toEqual({
height : 6,
area : area,
})
expect(dissoc('depth', rect)).toEqual({
width : 7,
height : 6,
area : area,
})
})
divide(x: number, y: number): number
R.divide(71, 100) // => 0.71
Try this R.divide example in Rambda REPL
divide(x: number, y: number): number;
divide(x: number): (y: number) => number;
export function divide(a, b){
if (arguments.length === 1) return _b => divide(a, _b)
return a / b
}
import { divide } from './divide'
test('happy', () => {
expect(divide(71, 100)).toEqual(0.71)
expect(divide(71)(100)).toEqual(0.71)
})
drop<T>(howMany: number, input: readonly T[]): readonly T[]
It returns howMany items dropped from beginning of list or string input.
R.drop(2, ['foo', 'bar', 'baz']) // => ['baz']
R.drop(2, 'foobar') // => 'obar'
Try this R.drop example in Rambda REPL
drop<T>(howMany: number, input: readonly T[]): readonly T[];
drop(howMany: number, input: string): string;
drop<T>(howMany: number): {
<T>(input: readonly T[]): readonly 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)
})
dropLast<T>(howMany: number, input: readonly T[]): readonly T[]
It returns howMany items dropped from the end of list or string input.
R.dropLast(2, ['foo', 'bar', 'baz']) // => ['foo']
R.dropLast(2, 'foobar') // => 'foob'
Try this R.dropLast example in Rambda REPL
dropLast<T>(howMany: number, input: readonly T[]): readonly T[];
dropLast(howMany: number, input: string): string;
dropLast<T>(howMany: number): {
<T>(input: readonly T[]): readonly 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)
})
:boom: Reason for the failure: Ramda method can act as a transducer
var assert = require('assert');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('dropLast', function() {
it('can act as a transducer', function() {
var dropLast2 = R.dropLast(2);
assert.deepEqual(R.into([], dropLast2, [1, 3, 5, 7, 9, 1, 2]), [1, 3, 5, 7, 9]);
assert.deepEqual(R.into([], dropLast2, [1]), []);
});
});
dropLastWhile(predicate: (x: string) => boolean, iterable: string): string
const list = [1, 2, 3, 4, 5];
const predicate = x => x >= 3
const result = dropLastWhile(predicate, list);
// => [1, 2]
Try this R.dropLastWhile example in Rambda REPL
dropLastWhile(predicate: (x: string) => boolean, iterable: string): string;
dropLastWhile(predicate: (x: string) => boolean): (iterable: string) => string;
dropLastWhile<T>(predicate: (x: T) => boolean, iterable: readonly T[]): readonly T[];
dropLastWhile<T>(predicate: (x: T) => boolean): <T>(iterable: readonly T[]) => readonly T[];
import { _isArray } from './_internals/_isArray'
export function dropLastWhile(predicate, iterable){
if (arguments.length === 1){
return _iterable => dropLastWhile(predicate, _iterable)
}
if (iterable.length === 0) return iterable
const isArray = _isArray(iterable)
if (typeof predicate !== 'function'){
throw new Error(`'predicate' is from wrong type ${ typeof predicate }`)
}
if (!isArray && typeof iterable !== 'string'){
throw new Error(`'iterable' is from wrong type ${ typeof iterable }`)
}
let found = false
const toReturn = []
let counter = iterable.length
while (counter > 0){
counter--
if (!found && predicate(iterable[ counter ]) === false){
found = true
toReturn.push(iterable[ counter ])
} else if (found){
toReturn.push(iterable[ counter ])
}
}
return isArray ? toReturn.reverse() : toReturn.reverse().join('')
}
import { dropLastWhile as dropLastWhileRamda } from 'ramda'
import { compareCombinations } from './_internals/testUtils'
import { dropLastWhile } from './dropLastWhile'
const list = [ 1, 2, 3, 4, 5 ]
const str = 'foobar'
test('with list', () => {
const result = dropLastWhile(x => x >= 3, list)
expect(result).toEqual([ 1, 2 ])
})
test('with string', () => {
const result = dropLastWhile(x => x !== 'b')(str)
expect(result).toBe('foob')
})
test('with empty list', () => {
expect(dropLastWhile(() => true, [])).toEqual([])
expect(dropLastWhile(() => false, [])).toEqual([])
})
const possiblePredicates = [
x => x > 2,
x => x < 2,
x => x < -2,
x => x > 10,
'',
[],
[ 1 ],
]
const possibleIterables = [
list,
[ {}, '1', 2 ],
str,
`${ str }${ str }`,
/foo/g,
Promise.resolve('foo'),
2,
]
describe('brute force', () => {
compareCombinations({
fn : dropLastWhile,
fnRamda : dropLastWhileRamda,
firstInput : possiblePredicates,
secondInput : possibleIterables,
callback : errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 12,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 21,
"SHOULD_THROW": 0,
}
`)
},
})
})
1 failed Ramda.dropLastWhile specs
:boom: Reason for the failure: Ramda method can act as a transducer
dropRepeats<T>(list: readonly T[]): readonly T[]
It removes any successive duplicates according to R.equals.
const result = R.dropRepeats([
1,
1,
{a: 1},
{a:1},
1
])
// => [1, {a: 1}, 1]
Try this R.dropRepeats example in Rambda REPL
dropRepeats<T>(list: readonly T[]): readonly 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,
}
`)
},
fn : dropRepeats,
fnRamda : dropRepeatsRamda,
})
})
1 failed Ramda.dropRepeats specs
:boom: Reason for the failure: Ramda method can act as a transducer
dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean, list: readonly T[]): readonly T[]
const list = [{a:1,b:2}, {a:1,b:3}, {a:2, b:4}]
const result = R.dropRepeatsWith(R.prop('a'))
// => [{a:1,b:2}, {a:2, b:4}]
Try this R.dropRepeatsWith example in Rambda REPL
dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean, list: readonly T[]): readonly T[];
dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean): (list: readonly T[]) => readonly T[];
import { _isArray } from './_internals/_isArray'
export function dropRepeatsWith(predicate, list){
if (arguments.length === 1){
return _iterable => dropRepeatsWith(predicate, _iterable)
}
if (!_isArray(list)){
throw new Error(`${ list } is not a list`)
}
const toReturn = []
list.reduce((prev, current) => {
if (prev === undefined){
toReturn.push(current)
return current
}
if (!predicate(prev, current)){
toReturn.push(current)
}
return current
}, undefined)
return toReturn
}
import { dropRepeatsWith as dropRepeatsWithRamda, eqProps } from 'ramda'
import { compareCombinations } from './_internals/testUtils'
import { dropRepeatsWith } from './dropRepeatsWith'
import { path } from './path'
const eqI = eqProps('i')
test('happy', () => {
const list = [ { i : 1 }, { i : 2 }, { i : 2 }, { i : 3 } ]
const expected = [ { i : 1 }, { i : 2 }, { i : 3 } ]
const result = dropRepeatsWith(eqI, list)
expect(result).toEqual(expected)
})
test('keeps elements from the left predicate input', () => {
const list = [
{
i : 1,
n : 1,
},
{
i : 1,
n : 2,
},
{
i : 1,
n : 3,
},
{
i : 4,
n : 1,
},
{
i : 4,
n : 2,
},
]
const expected = [
{
i : 1,
n : 1,
},
{
i : 4,
n : 1,
},
]
const result = dropRepeatsWith(eqI)(list)
expect(result).toEqual(expected)
})
const possiblePredicates = [
null,
undefined,
x => x + 1,
x => true,
x => false,
x => '',
path([ 'a', 'b' ]),
]
const possibleLists = [
null,
undefined,
[],
[ 1 ],
[ { a : { b : 1 } }, { a : { b : 1 } } ],
[ /foo/g, /foo/g ],
]
describe('brute force', () => {
compareCombinations({
firstInput : possiblePredicates,
secondInput : possibleLists,
callback : errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 4,
"ERRORS_TYPE_MISMATCH": 14,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 0,
"SHOULD_THROW": 0,
}
`)
},
fn : dropRepeatsWith,
fnRamda : dropRepeatsWithRamda,
})
})
dropWhile(fn: Predicate<string>, iterable: string): string
const list = [1, 2, 3, 4]
const predicate = x => x < 3
const result = R.dropWhile(predicate, list)
// => [3, 4]
Try this R.dropWhile example in Rambda REPL
dropWhile(fn: Predicate<string>, iterable: string): string;
dropWhile(fn: Predicate<string>): (iterable: string) => string;
dropWhile<T>(fn: Predicate<T>, iterable: readonly T[]): readonly T[];
dropWhile<T>(fn: Predicate<T>): (iterable: readonly T[]) => readonly T[];
import { _isArray } from '../src/_internals/_isArray'
export function dropWhile(predicate, iterable){
if (arguments.length === 1){
return _iterable => dropWhile(predicate, _iterable)
}
const isArray = _isArray(iterable)
if (!isArray && typeof iterable !== 'string'){
throw new Error('`iterable` is neither list nor a string')
}
let flag = false
const holder = []
let counter = -1
while (counter++ < iterable.length - 1){
if (flag){
holder.push(iterable[ counter ])
} else if (!predicate(iterable[ counter ])){
if (!flag) flag = true
holder.push(iterable[ counter ])
}
}
return isArray ? holder : holder.join('')
}
import { dropWhile as dropWhileRamda } from 'ramda'
import { compareCombinations } from './_internals/testUtils'
import { dropWhile } from './dropWhile'
const list = [ 1, 2, 3, 4 ]
test('happy', () => {
const predicate = x => x < 3
const result = dropWhile(predicate, list)
expect(result).toEqual([ 3, 4 ])
})
test('always true', () => {
const predicate = () => true
const result = dropWhileRamda(predicate, list)
expect(result).toEqual([])
})
test('always false', () => {
const predicate = () => 0
const result = dropWhile(predicate)(list)
expect(result).toEqual(list)
})
test('works with string as iterable', () => {
const iterable = 'foobar'
const predicate = x => x !== 'b'
const result = dropWhile(predicate, iterable)
expect(result).toBe('bar')
})
const possiblePredicates = [
null,
undefined,
() => 0,
() => true,
/foo/g,
{},
[],
]
const possibleIterables = [
null,
undefined,
[],
{},
1,
'',
'foobar',
[ '' ],
[ 1, 2, 3, 4, 5 ],
]
describe('brute force', () => {
compareCombinations({
firstInput : possiblePredicates,
callback : errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 15,
"ERRORS_TYPE_MISMATCH": 14,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 14,
"SHOULD_THROW": 0,
}
`)
},
secondInput : possibleIterables,
fn : dropWhile,
fnRamda : dropWhileRamda,
})
})
either(firstPredicate: Pred, secondPredicate: Pred): Pred
It returns a new predicate function from firstPredicate and secondPredicate inputs.
This predicate function will return true, if any of the two input predicates return true.
const firstPredicate = x => x > 10
const secondPredicate = x => x % 2 === 0
const predicate = R.either(firstPredicate, secondPredicate)
const result = [
predicate(15),
predicate(8),
predicate(7),
]
// => [true, true, false]
Try this R.either example in Rambda REPL
either(firstPredicate: Pred, secondPredicate: Pred): Pred;
either<T>(firstPredicate: Predicate<T>, secondPredicate: Predicate<T>): Predicate<T>;
either<T>(firstPredicate: Predicate<T>): (secondPredicate: Predicate<T>) => Predicate<T>;
either(firstPredicate: Pred): (secondPredicate: Pred) => Pred;
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()
})
:boom: Reason for the failure: Ramda library supports fantasy-land
var S = require('sanctuary');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('either', function() {
it('accepts fantasy-land applicative functors', function() {
var Just = S.Just;
var Nothing = S.Nothing;
eq(R.either(Just(true), Just(true)), Just(true));
eq(R.either(Just(true), Just(false)), Just(true));
eq(R.either(Just(false), Just(false)), Just(false));
eq(R.either(Just(true), Nothing()), Nothing());
eq(R.either(Nothing(), Just(false)), Nothing());
eq(R.either(Nothing(), Nothing()), Nothing());
});
});
endsWith(target: string, str: string): boolean
Curried version of String.prototype.endsWith
:boom: It doesn't work with arrays unlike its corresponding Ramda method.
const str = 'foo-bar'
const target = '-bar'
const result = R.endsWith(target, str)
// => true
Try this R.endsWith example in Rambda REPL
endsWith(target: string, str: string): boolean;
endsWith(target: string): (str: string) => boolean;
export function endsWith(target, str){
if (arguments.length === 1) return _str => endsWith(target, _str)
return str.endsWith(target)
}
import { endsWith } from './endsWith'
test('happy', () => {
expect(endsWith('bar', 'foo-bar')).toBeTrue()
expect(endsWith('baz')('foo-bar')).toBeFalse()
})
test('does not work with arrays', () => {
expect(() => endsWith([ 'c' ], [ 'a', 'b', 'c' ])).toThrowWithMessage(Error,
'str.endsWith is not a function')
})
:boom: Reason for the failure: Rambda method doesn't support arrays
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('startsWith', function() {
it('should return true when an array ends with the provided value', function() {
eq(R.endsWith(['c'], ['a', 'b', 'c']), true);
});
it('should return true when an array ends with the provided values', function() {
eq(R.endsWith(['b', 'c'], ['a', 'b', 'c']), true);
});
it('should return false when an array does not end with the provided value', function() {
eq(R.endsWith(['b'], ['a', 'b', 'c']), false);
});
it('should return false when an array does not end with the provided values', function() {
eq(R.endsWith(['a', 'b'], ['a', 'b', 'c']), false);
});
});
eqProps<T, U>(prop: string, obj1: T, obj2: U): boolean
It returns true if property prop in obj1 is equal to property prop in obj2 according to R.equals.
const obj1 = {a: 1, b:2}
const obj2 = {a: 1, b:3}
const result = R.eqProps('a', obj1, obj2)
// => true
Try this R.eqProps example in Rambda REPL
eqProps<T, U>(prop: string, obj1: T, obj2: U): boolean;
eqProps<P extends string>(prop: P): <T, U>(obj1: Record<P, T>, obj2: Record<P, U>) => boolean;
eqProps<T>(prop: string, obj1: T): <U>(obj2: U) => boolean;
import { curry } from './curry'
import { equals } from './equals'
function eqPropsFn(
prop, obj1, obj2
){
if (!obj1 || !obj2){
throw new Error('wrong object inputs are passed to R.eqProps')
}
return equals(obj1[ prop ], obj2[ prop ])
}
export const eqProps = curry(eqPropsFn)
import { eqProps as eqPropsRamda } from 'ramda'
import { compareCombinations } from './_internals/testUtils'
import { eqProps } from './eqProps'
const obj1 = {
a : 1,
b : 2,
}
const obj2 = {
a : 1,
b : 3,
}
test('props are equal', () => {
const result = eqProps(
'a', obj1, obj2
)
expect(result).toBeTrue()
})
test('props are not equal', () => {
const result = eqProps(
'b', obj1, obj2
)
expect(result).toBeFalse()
})
test('prop does not exist ', () => {
const result = eqProps(
'c', obj1, obj2
)
expect(result).toBeTrue()
})
const possibleProps = [ 'a', 'a.b', null, false, 0, 1, {}, [] ]
const possibleObjects = [
{ a : 1 },
{
a : 1,
b : 2,
},
{},
[],
null,
{
a : { b : 1 },
c : 2,
},
{
a : { b : 1 },
c : 3,
},
{ a : { b : 2 } },
]
describe('brute force', () => {
let totalTestsCounter = 0
compareCombinations({
firstInput : possibleProps,
setCounter : () => totalTestsCounter++,
callback : errorsCounters => {
// console.log({ totalTestsCounter })
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 120,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 0,
"SHOULD_THROW": 0,
}
`)
},
secondInput : possibleObjects,
thirdInput : possibleObjects,
fn : eqProps,
fnRamda : eqPropsRamda,
})
})
equals<T>(x: T, y: T): boolean
It deeply compares x and y and returns true if they are equal.
:boom: It doesn't handle cyclical data structures and functions
R.equals(
[1, {a:2}, [{b: 3}]],
[1, {a:2}, [{b: 3}]]
) // => true
Try this R.equals example in Rambda REPL
equals<T>(x: T, y: T): boolean;
equals<T>(x: T): (y: T) => boolean;
import { type } from './type'
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() ]
}
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 === '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'
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('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()
})
:boom: Reason for the failure: Rambda method doesn't support recursive data structures, objects with same enumerable properties, map/weakmap type of variables | Ramda dispatches to
equalsmethod recursively | Rambda method doesn't support equality of functions
/* global Map, Set, WeakMap, WeakSet */
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('equals', function() {
var a = [];
var b = a;
it('never considers Boolean primitive equal to Boolean object', function() {
eq(R.equals(true, new Boolean(true)), false);
eq(R.equals(new Boolean(true), true), false);
eq(R.equals(false, new Boolean(false)), false);
eq(R.equals(new Boolean(false), false), false);
});
it('never considers number primitive equal to Number object', function() {
eq(R.equals(0, new Number(0)), false);
eq(R.equals(new Number(0), 0), false);
});
it('never considers string primitive equal to String object', function() {
eq(R.equals('', new String('')), false);
eq(R.equals(new String(''), ''), false);
eq(R.equals('x', new String('x')), false);
eq(R.equals(new String('x'), 'x'), false);
});
var supportsSticky = false;
try { RegExp('', 'y'); supportsSticky = true; } catch (e) {}
var supportsUnicode = false;
try { RegExp('', 'u'); supportsUnicode = true; } catch (e) {}
var listA = [1, 2, 3];
var listB = [1, 3, 2];
var c = {}; c.v = c;
var d = {}; d.v = d;
var e = []; e.push(e);
var f = []; f.push(f);
var nestA = {a:[1, 2, {c:1}], b:1};
var nestB = {a:[1, 2, {c:1}], b:1};
var nestC = {a:[1, 2, {c:2}], b:1};
it('handles recursive data structures', function() {
eq(R.equals(c, d), true);
eq(R.equals(e, f), true);
eq(R.equals(nestA, nestB), true);
eq(R.equals(nestA, nestC), false);
});
it('requires that both objects have the same enumerable properties with the same values', function() {
var a1 = [];
var a2 = [];
a2.x = 0;
var b1 = new Boolean(false);
var b2 = new Boolean(false);
b2.x = 0;
var d1 = new Date(0);
var d2 = new Date(0);
d2.x = 0;
var n1 = new Number(0);
var n2 = new Number(0);
n2.x = 0;
var r1 = /(?:)/;
var r2 = /(?:)/;
r2.x = 0;
var s1 = new String('');
var s2 = new String('');
s2.x = 0;
eq(R.equals(a1, a2), false);
eq(R.equals(b1, b2), false);
eq(R.equals(d1, d2), false);
eq(R.equals(n1, n2), false);
eq(R.equals(r1, r2), false);
eq(R.equals(s1, s2), false);
});
if (typeof ArrayBuffer !== 'undefined' && typeof Int8Array !== 'undefined') {
var typArr1 = new ArrayBuffer(10);
typArr1[0] = 1;
var typArr2 = new ArrayBuffer(10);
typArr2[0] = 1;
var typArr3 = new ArrayBuffer(10);
var intTypArr = new Int8Array(typArr1);
typArr3[0] = 0;
it('handles typed arrays', function() {
eq(R.equals(typArr1, typArr2), true);
eq(R.equals(typArr1, typArr3), false);
eq(R.equals(typArr1, intTypArr), false);
});
}
if (typeof Promise !== 'undefined') {
it('compares Promise objects by identity', function() {
var p = Promise.resolve(42);
var q = Promise.resolve(42);
eq(R.equals(p, p), true);
eq(R.equals(p, q), false);
});
}
if (typeof Map !== 'undefined') {
it('compares Map objects by value', function() {
eq(R.equals(new Map([]), new Map([])), true);
eq(R.equals(new Map([]), new Map([[1, 'a']])), false);
eq(R.equals(new Map([[1, 'a']]), new Map([])), false);
eq(R.equals(new Map([[1, 'a']]), new Map([[1, 'a']])), true);
eq(R.equals(new Map([[1, 'a'], [2, 'b']]), new Map([[2, 'b'], [1, 'a']])), true);
eq(R.equals(new Map([[1, 'a']]), new Map([[2, 'a']])), false);
eq(R.equals(new Map([[1, 'a']]), new Map([[1, 'b']])), false);
eq(R.equals(new Map([[1, 'a'], [2, new Map([[3, 'c']])]]), new Map([[1, 'a'], [2, new Map([[3, 'c']])]])), true);
eq(R.equals(new Map([[1, 'a'], [2, new Map([[3, 'c']])]]), new Map([[1, 'a'], [2, new Map([[3, 'd']])]])), false);
eq(R.equals(new Map([[[1, 2, 3], [4, 5, 6]]]), new Map([[[1, 2, 3], [4, 5, 6]]])), true);
eq(R.equals(new Map([[[1, 2, 3], [4, 5, 6]]]), new Map([[[1, 2, 3], [7, 8, 9]]])), false);
});
it('dispatches to `equals` method recursively in Set', function() {
var a = new Map();
var b = new Map();
a.set(a, a);
eq(R.equals(a, b), false);
a.set(b, b);
b.set(b, b);
b.set(a, a);
eq(R.equals(a, b), true);
});
}
if (typeof Set !== 'undefined') {
it('compares Set objects by value', function() {
eq(R.equals(new Set([]), new Set([])), true);
eq(R.equals(new Set([]), new Set([1])), false);
eq(R.equals(new Set([1]), new Set([])), false);
eq(R.equals(new Set([1, 2]), new Set([2, 1])), true);
eq(R.equals(new Set([1, new Set([2, new Set([3])])]), new Set([1, new Set([2, new Set([3])])])), true);
eq(R.equals(new Set([1, new Set([2, new Set([3])])]), new Set([1, new Set([2, new Set([4])])])), false);
eq(R.equals(new Set([[1, 2, 3], [4, 5, 6]]), new Set([[1, 2, 3], [4, 5, 6]])), true);
eq(R.equals(new Set([[1, 2, 3], [4, 5, 6]]), new Set([[1, 2, 3], [7, 8, 9]])), false);
});
it('dispatches to `equals` method recursively in Set', function() {
var a = new Set();
var b = new Set();
a.add(a);
eq(R.equals(a, b), false);
a.add(b);
b.add(b);
b.add(a);
eq(R.equals(a, b), true);
});
}
if (typeof WeakMap !== 'undefined') {
it('compares WeakMap objects by identity', function() {
var m = new WeakMap([]);
eq(R.equals(m, m), true);
eq(R.equals(m, new WeakMap([])), false);
});
}
if (typeof WeakSet !== 'undefined') {
it('compares WeakSet objects by identity', function() {
var s = new WeakSet([]);
eq(R.equals(s, s), true);
eq(R.equals(s, new WeakSet([])), false);
});
}
it('dispatches to `equals` method recursively', function() {
function Left(x) { this.value = x; }
Left.prototype.equals = function(x) {
return x instanceof Left && R.equals(x.value, this.value);
};
function Right(x) { this.value = x; }
Right.prototype.equals = function(x) {
return x instanceof Right && R.equals(x.value, this.value);
};
eq(R.equals(new Left([42]), new Left([42])), true);
eq(R.equals(new Left([42]), new Left([43])), false);
eq(R.equals(new Left(42), {value: 42}), false);
eq(R.equals({value: 42}, new Left(42)), false);
eq(R.equals(new Left(42), new Right(42)), false);
eq(R.equals(new Right(42), new Left(42)), false);
eq(R.equals([new Left(42)], [new Left(42)]), true);
eq(R.equals([new Left(42)], [new Right(42)]), false);
eq(R.equals([new Right(42)], [new Left(42)]), false);
eq(R.equals([new Right(42)], [new Right(42)]), true);
});
});
evolve<T, U>(rules: ReadonlyArray<(x: T) => U>, list: readonly T[]): readonly U[]
It takes object or array of functions as set of rules. These rules are applied to the iterable input to produce the result.
:boom: Error handling of this method differs between Ramda and Rambda. Ramda for some wrong inputs returns result and for other - it returns one of the inputs. Rambda simply throws when inputs are not correct. Full details for this mismatch are listed in
source/_snapshots/evolve.spec.js.snapfile.
const rules = {
foo : add(1),
bar : add(-1),
}
const input = {
a : 1,
foo : 2,
bar : 3,
}
const result = evolve(rules, input)
const expected = {
a : 1,
foo : 3,
bar : 2,
})
// => `result` is equal to `expected`
Try this R.evolve example in Rambda REPL
evolve<T, U>(rules: ReadonlyArray<(x: T) => U>, list: readonly T[]): readonly U[];
evolve<T, U>(rules: ReadonlyArray<(x: T) => U>) : (list: readonly T[]) => readonly 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,
}
`)
},
secondInput : possibleIterables,
fn : evolve,
fnRamda : evolveRamda,
})
})
1 failed Ramda.evolve specs
:boom: Reason for the failure: Rambda throws if
iterableinput is neither array nor object
F(): boolean
F() // => false
Try this R.F example in Rambda REPL
F(): boolean;
export function F(){
return false
}
filter<T>(predicate: Predicate<T>): (input: readonly T[]) => readonly T[]
It filters list or object input using a predicate function.
const list = [3, 4, 3, 2]
const listPredicate = x => x > 2
const object = {abc: 'fo', xyz: 'bar', baz: 'foo'}
const objectPredicate = (x, prop) => x.length + prop.length > 5
const result = [
R.filter(listPredicate, list),
R.filter(objectPredicate, object)
]
// => [ [3, 4], { xyz: 'bar', baz: 'foo'} ]
Try this R.filter example in Rambda REPL
filter<T>(predicate: Predicate<T>): (input: readonly T[]) => readonly T[];
filter<T>(predicate: Predicate<T>, input: readonly T[]): readonly 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(fn, obj){
const willReturn = {}
for (const prop in obj){
if (fn(
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) return []
if (_isArray(iterable)) return filterArray(predicate, iterable)
return filterObject(predicate, iterable)
}
import Ramda from 'ramda'
import { F } from './F'
import { filter } from './filter'
import { T } from './T'
const sampleObject = {
a : 1,
b : 2,
c : 3,
d : 4,
}
test('happy', () => {
const isEven = n => n % 2 === 0
expect(filter(isEven, [ 1, 2, 3, 4 ])).toEqual([ 2, 4 ])
expect(filter(isEven, {
a : 1,
b : 2,
d : 3,
})).toEqual({ b : 2 })
})
test('bad inputs difference between Ramda and Rambda', () => {
expect(filter(T)(undefined)).toEqual([])
expect(filter(F, null)).toEqual([])
expect(() => Ramda.filter(T, null)).toThrowWithMessage(TypeError,
'Cannot read property \'filter\' of null')
expect(() => Ramda.filter(T, undefined)).toThrowWithMessage(TypeError,
'Cannot read property \'filter\' of undefined')
})
test('predicate when input is object', () => {
const obj = {
a : 1,
b : 2,
}
const predicate = (
val, prop, inputObject
) => {
expect(inputObject).toEqual(obj)
expect(typeof prop).toEqual('string')
return val < 2
}
expect(filter(predicate, obj)).toEqual({ a : 1 })
})
test('with object', () => {
const isEven = n => n % 2 === 0
const result = filter(isEven, sampleObject)
const expectedResult = {
b : 2,
d : 4,
}
expect(result).toEqual(expectedResult)
})
:boom: Reason for the failure: Ramda method dispatches to
filtermethod of object
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
var Maybe = require('./shared/Maybe');
describe('filter', function() {
var even = function(x) {return x % 2 === 0;};
it('dispatches to passed-in non-Array object with a `filter` method', function() {
var f = {filter: function(f) { return f('called f.filter'); }};
eq(R.filter(function(s) { return s; }, f), 'called f.filter');
});
it('correctly uses fantasy-land implementations', function() {
var m1 = Maybe.Just(-1);
var m2 = R.filter(function(x) { return x > 0; } , m1);
eq(m2.isNothing, true);
});
});
find<T>(predicate: (x: T) => boolean, list: readonly T[]): T | undefined
It returns the first element of list that satisfy the predicate.
If there is no such element, it returns undefined.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 'bar'}, {foo: 1}]
const result = R.find(predicate, list)
// => {foo: 1}
Try this R.find example in Rambda REPL
find<T>(predicate: (x: T) => boolean, list: readonly T[]): T | undefined;
find<T>(predicate: (x: T) => boolean): (list: readonly T[]) => T | undefined;
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()
})
findIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number
It returns the index of the first element of list satisfying the predicate function.
If there is no such element, then -1 is returned.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 'bar'}, {foo: 1}]
const result = R.findIndex(predicate, list)
// => 1
Try this R.findIndex example in Rambda REPL
findIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number;
findIndex<T>(predicate: (x: T) => boolean): (list: readonly T[]) => number;
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)
})
findLast<T>(fn: (x: T) => boolean, list: readonly T[]): T | undefined
It returns the last element of list satisfying the predicate function.
If there is no such element, then undefined is returned.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 0}, {foo: 1}]
const result = R.findLast(predicate, list)
// => {foo: 1}
Try this R.findLast example in Rambda REPL
findLast<T>(fn: (x: T) => boolean, list: readonly T[]): T | undefined;
findLast<T>(fn: (x: T) => boolean): (list: readonly T[]) => T | undefined;
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)
})
findLastIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number
It returns the index of the last element of list satisfying the predicate function.
If there is no such element, then -1 is returned.
const predicate = x => R.type(x.foo) === 'Number'
const list = [{foo: 0}, {foo: 1}]
const result = R.findLastIndex(predicate, list)
// => 1
Try this R.findLastIndex example in Rambda REPL
findLastIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number;
findLastIndex<T>(predicate: (x: T) => boolean): (list: readonly T[]) => number;
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)
})
flatten<T>(list: readonly any[]): readonly T[]
It deeply flattens an array.
const result = R.flatten([
1,
2,
[3, 30, [300]],
[4]
])
// => [ 1, 2, 3, 30, 300, 4 ]
Try this R.flatten example in Rambda REPL
flatten<T>(list: readonly any[]): readonly 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 ])
})
flip<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult
It returns function which calls fn with exchanged first and second argument.
:boom: Rambda's flip will throw if the arity of the input function is greater or equal to 5.
const subtractFlip = R.flip(R.subtract)
const result = [
subtractFlip(1,7),
R.flip(1, 6)
]
// => [6, -6]
Try this R.flip example in Rambda REPL
flip<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult;
flip<F extends (...args: any) => any, P extends FunctionToolbelt.Parameters<F>>(fn: F): FunctionToolbelt.Curry<(...args: ListToolbelt.Merge<readonly [P[1], P[0]], P>) => FunctionToolbelt.Return<F>>;
function flipFn(fn){
return (...input) => {
if (input.length === 1){
return holder => fn(holder, input[ 0 ])
} else if (input.length === 2){
return fn(input[ 1 ], input[ 0 ])
} else if (input.length === 3){
return fn(
input[ 1 ], input[ 0 ], input[ 2 ]
)
} else if (input.length === 4){
return fn(
input[ 1 ], input[ 0 ], input[ 2 ], input[ 3 ]
)
}
throw new Error('R.flip doesn\'t work with arity > 4')
}
}
export function flip(fn){
return flipFn(fn)
}
import { flip } from './flip'
import { subtract } from './subtract'
import { update } from './update'
test('function with arity of 2', () => {
const subtractFlipped = flip(subtract)
expect(subtractFlipped(1)(7)).toEqual(6)
expect(subtractFlipped(1, 7)).toEqual(6)
expect(subtractFlipped(
1, 7, 9
)).toEqual(6)
})
test('function with arity of 3', () => {
const updateFlipped = flip(update)
const result = updateFlipped(
88, 0, [ 1, 2, 3 ]
)
const curriedResult = updateFlipped(88, 0)([ 1, 2, 3 ])
const tripleCurriedResult = updateFlipped(88)(0)([ 1, 2, 3 ])
expect(result).toEqual([ 88, 2, 3 ])
expect(curriedResult).toEqual([ 88, 2, 3 ])
expect(tripleCurriedResult).toEqual([ 88, 2, 3 ])
})
test('function with arity of 4', () => {
const testFunction = (
a, b, c, d
) => `${ a - b }==${ c - d }`
const testFunctionFlipped = flip(testFunction)
const result = testFunction(
1, 2, 3, 4
)
const flippedResult = testFunctionFlipped(
2, 1, 3, 4
)
expect(result).toEqual(flippedResult)
expect(result).toEqual('-1==-1')
})
test('function with arity of 5', () => {
const testFunction = (
a, b, c, d, e
) => `${ a - b }==${ c - d - e }`
const testFunctionFlipped = flip(testFunction)
expect(() => testFunctionFlipped(
1, 2, 3, 4, 5
)).toThrowWithMessage(Error,
'R.flip doesn\'t work with arity > 4')
})
:boom: Reason for the failure: Ramda.flip returns a curried function | Rambda.flip work only for functions with arity below 5
var jsv = require('jsverify');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
var funcN = require('./shared/funcN');
describe('flip', function() {
it('returns a function which inverts the first two arguments to the supplied function', function() {
var f = function(a, b, c) {return a + ' ' + b + ' ' + c;};
var g = R.flip(f);
eq(f('a', 'b', 'c'), 'a b c');
eq(g('a', 'b', 'c'), 'b a c');
});
it('returns a curried function', function() {
var f = function(a, b, c) {return a + ' ' + b + ' ' + c;};
var g = R.flip(f)('a');
eq(g('b', 'c'), 'b a c');
});
it('returns a function with the correct arity', function() {
var f2 = function(a, b) {return a + ' ' + b;};
var f3 = function(a, b, c) {return a + ' ' + b + ' ' + c;};
eq(R.flip(f2).length, 2);
eq(R.flip(f3).length, 3);
});
});
describe('flip properties', function() {
jsv.property('inverts first two arguments', funcN(3), jsv.json, jsv.json, jsv.json, function(f, a, b, c) {
var g = R.flip(f);
return R.equals(f(a, b, c), g(b, a, c));
});
});
forEach<T>(fn: Iterator<T, void>, list: readonly T[]): readonly T[]
It applies iterable function over all members of list and returns list.
:boom: It works with objects, unlike
Ramda.
const sideEffect = {}
const result = R.forEach(
x => sideEffect[`foo${x}`] = x
)([1, 2])
sideEffect // => {foo1: 1, foo2: 2}
result // => [1, 2]
Try this R.forEach example in Rambda REPL
forEach<T>(fn: Iterator<T, void>, list: readonly T[]): readonly T[];
forEach<T>(fn: Iterator<T, void>): (list: readonly T[]) => readonly 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)
})
:boom: Reason for the failure: Ramda method dispatches to
forEachmethod
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('forEach', function() {
var list = [{x: 1, y: 2}, {x: 100, y: 200}, {x: 300, y: 400}, {x: 234, y: 345}];
it('dispatches to `forEach` method', function() {
var dispatched = false;
var fn = function() {};
function DummyList() {}
DummyList.prototype.forEach = function(callback) {
dispatched = true;
eq(callback, fn);
};
R.forEach(fn, new DummyList());
eq(dispatched, true);
});
});
fromPairs<V>(listOfPairs: readonly KeyValuePair<string, V>[]): { readonly [index: string]: V }
It transforms a listOfPairs to an object.
const listOfPairs = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ] ]
const expected = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
const result = R.fromPairs(listOfPairs)
// => `result` is equal to `expected`
Try this R.fromPairs example in Rambda REPL
fromPairs<V>(listOfPairs: readonly KeyValuePair<string, V>[]): { readonly [index: string]: V };
fromPairs<V>(listOfPairs: readonly KeyValuePair<number, V>[]): { readonly [index: number]: V };
export function fromPairs(listOfPairs){
const toReturn = {}
listOfPairs.forEach(([ prop, value ]) => toReturn[ prop ] = value)
return toReturn
}
import { fromPairs } from './fromPairs'
const list = [
[ 'a', 1 ],
[ 'b', 2 ],
[ 'c', [ 3, 4 ] ],
]
const expected = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
test('happy', () => {
expect(fromPairs(list)).toEqual(expected)
})
groupBy<T>(groupFn: (x: T) => string, list: readonly T[]): { readonly [index: string]: readonly T[] }
It splits list according to a provided groupFn function and returns an object.
const list = [ 'a', 'b', 'aa', 'bb' ]
const groupFn = x => x.length
const result = R.groupBy(groupFn, list)
// => { '1': ['a', 'b'], '2': ['aa', 'bb'] }
Try this R.groupBy example in Rambda REPL
groupBy<T>(groupFn: (x: T) => string, list: readonly T[]): { readonly [index: string]: readonly T[] };
groupBy<T>(groupFn: (x: T) => string): (list: readonly T[]) => { readonly [index: string]: readonly T[] };
export function groupBy(groupFn, list){
if (arguments.length === 1) return _list => groupBy(groupFn, _list)
const result = {}
for (let i = 0; i < list.length; i++){
const item = list[ i ]
const key = groupFn(item)
if (!result[ key ]){
result[ key ] = []
}
result[ key ].push(item)
}
return result
}
import { groupBy } from './groupBy'
import { prop } from './prop'
test('groupBy', () => {
const list = [
{
age : 12,
name : 'john',
},
{
age : 12,
name : 'jack',
},
{
age : 24,
name : 'mary',
},
{
age : 24,
name : 'steve',
},
]
const expectedResult = {
12 : [
{
age : 12,
name : 'john',
},
{
age : 12,
name : 'jack',
},
],
24 : [
{
age : 24,
name : 'mary',
},
{
age : 24,
name : 'steve',
},
],
}
expect(groupBy(prop('age'))(list)).toEqual(expectedResult)
expect(groupBy(prop('age'), list)).toEqual(expectedResult)
})
:boom: Reason for the failure: Ramda method support transforms
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
var _isTransformer = require('rambda/internal/_isTransformer');
describe('groupBy', function() {
it('dispatches on transformer objects in list position', function() {
var byType = R.prop('type');
var xf = {
'@@transducer/init': function() { return {}; },
'@@transducer/result': function(x) { return x; },
'@@transducer/step': R.mergeRight
};
eq(_isTransformer(R.groupBy(byType, xf)), true);
});
});
groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: readonly T[]) => readonly (readonly T[])[]
It returns separated version of list or string input, where separation is done with equality compareFn function.
const compareFn = (x, y) => x === y
const list = [1, 2, 2, 1, 1, 2]
const result = R.groupWith(isConsecutive, list)
// => [[1], [2,2], [1,1], [2]]
Try this R.groupWith example in Rambda REPL
groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: readonly T[]) => readonly (readonly T[])[];
groupWith<T>(compareFn: (x: T, y: T) => boolean, input: readonly T[]): readonly (readonly T[])[];
groupWith<T>(compareFn: (x: T, y: T) => boolean, input: string): readonly string[];
import { _isArray } from './_internals/_isArray'
export function groupWith(compareFn, list){
if (!_isArray(list)) throw new TypeError('list.reduce is not a function')
const clone = list.slice()
if (list.length === 1) return [ clone ]
const toReturn = []
let holder = []
clone.reduce((
prev, current, i
) => {
if (i === 0) return current
const okCompare = compareFn(prev, current)
const holderIsEmpty = holder.length === 0
const lastCall = i === list.length - 1
if (okCompare){
if (holderIsEmpty) holder.push(prev)
holder.push(current)
if (lastCall) toReturn.push(holder)
return current
}
if (holderIsEmpty){
toReturn.push([ prev ])
if (lastCall) toReturn.push([ current ])
return current
}
toReturn.push(holder)
if (lastCall) toReturn.push([ current ])
holder = []
return current
}, undefined)
return toReturn
}
import { equals } from './equals'
import { groupWith } from './groupWith'
test('issue is fixed', () => {
const result = groupWith(equals, [ 1, 2, 2, 3 ])
const expected = [ [ 1 ], [ 2, 2 ], [ 3 ] ]
expect(result).toEqual(expected)
})
test('long list', () => {
const result = groupWith(equals, [
0,
1,
1,
2,
3,
5,
8,
13,
21,
21,
21,
1,
2,
])
const expected = [
[ 0 ],
[ 1, 1 ],
[ 2 ],
[ 3 ],
[ 5 ],
[ 8 ],
[ 13 ],
[ 21, 21, 21 ],
[ 1 ],
[ 2 ],
]
expect(result).toEqual(expected)
})
test('readme example', () => {
const list = [ 4, 3, 6, 2, 2, 1 ]
const result = groupWith((a, b) => a - b === 1, list)
const expected = [ [ 4, 3 ], [ 6 ], [ 2 ], [ 2, 1 ] ]
expect(result).toEqual(expected)
})
test('throw with string as input', () => {
expect(() => groupWith(equals, 'Mississippi')).toThrowWithMessage(TypeError,
'list.reduce is not a function')
})
const isConsecutive = function (a, b){
return a + 1 === b
}
test('fix coverage', () => {
expect(groupWith(isConsecutive, [ 1, 2, 3, 0 ])).toEqual([ [ 1, 2, 3 ], [ 0 ] ])
})
test('from ramda 0', () => {
expect(groupWith(equals, [])).toEqual([])
expect(groupWith(isConsecutive, [])).toEqual([])
})
test('from ramda 1', () => {
expect(groupWith(isConsecutive, [ 4, 3, 2, 1 ])).toEqual([
[ 4 ],
[ 3 ],
[ 2 ],
[ 1 ],
])
})
test('from ramda 2', () => {
expect(groupWith(isConsecutive, [ 1, 2, 3, 4 ])).toEqual([ [ 1, 2, 3, 4 ] ])
})
test('from ramda 3', () => {
expect(groupWith(isConsecutive, [ 1, 2, 2, 3 ])).toEqual([
[ 1, 2 ],
[ 2, 3 ],
])
expect(groupWith(isConsecutive, [ 1, 2, 9, 3, 4 ])).toEqual([
[ 1, 2 ],
[ 9 ],
[ 3, 4 ],
])
})
test('list with single item', () => {
const result = groupWith(equals, [ 0 ])
const expected = [ [ 0 ] ]
expect(result).toEqual(expected)
})
:boom: Reason for the failure: Ramda method support string
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('groupWith', function() {
it('can be turned into the original list through concatenation', function() {
var list = [1, 1, 2, 3, 4, 4, 5, 5];
eq(R.unnest(R.groupWith(R.equals, list)), list);
eq(R.unnest(R.groupWith(R.complement(R.equals), list)), list);
eq(R.unnest(R.groupWith(R.T, list)), list);
eq(R.unnest(R.groupWith(R.F, list)), list);
});
it('also works on strings', function() {
eq(R.groupWith(R.equals)('Mississippi'), ['M','i','ss','i','ss','i','pp','i']);
});
});
has<T>(prop: string, obj: T): boolean
It returns true if obj has property prop.
const obj = {a: 1}
const result = [
R.has('a', obj),
R.has('b', obj)
]
// => [true, false]
Try this R.has example in Rambda REPL
has<T>(prop: string, obj: T): boolean;
has(prop: string): <T>(obj: T) => boolean;
export function has(prop, obj){
if (arguments.length === 1) return _obj => has(prop, _obj)
if (!obj) return false
return obj[ prop ] !== undefined
}
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)
})
:boom: Reason for the failure: Rambda method does check properties from the prototype chain
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('has', function() {
var fred = {name: 'Fred', age: 23};
var anon = {age: 99};
it('does not check properties from the prototype chain', function() {
var Person = function() {};
Person.prototype.age = function() {};
var bob = new Person();
eq(R.has('age', bob), false);
});
});
hasPath<T>(
path: string | readonly string[],
input: object
): boolean
It will return true, if input object has truthy path(calculated with R.path).
const path = 'a.b'
const pathAsArray = ['a', 'b']
const obj = {a: {b: []}}
const result = [
R.hasPath(path, obj),
R.hasPath(pathAsArray, obj),
R.hasPath('a.c', obj),
]
// => [true, true, false]
Try this R.hasPath example in Rambda REPL
hasPath<T>(
path: string | readonly string[],
input: object
): boolean;
hasPath<T>(
path: string | readonly string[]
): (input: object) => boolean;
import { path } from './path'
export function hasPath(maybePath, obj){
if (arguments.length === 1){
return objHolder => hasPath(maybePath, objHolder)
}
return path(maybePath, 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)
})
head<T>(input: readonly T[]): T | undefined
It returns the first element of list or string input.
const result = [
R.head([1, 2, 3]),
R.head('foo')
]
// => [1, 'f']
Try this R.head example in Rambda REPL
head<T>(input: readonly T[]): T | undefined;
head(input: string): string;
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('')
})
identical<T>(x: T, y: T): boolean
It returns true if its arguments a and b are identical.
Otherwise, it returns false.
:boom: Values are identical if they reference the same memory.
NaNis identical toNaN;0and-0are not identical.
const obj = {a: 1};
R.identical(obj, obj); // => true
R.identical(1, 1); // => true
R.identical(1, '1'); // => false
R.identical([], []); // => false
R.identical(0, -0); // => false
R.identical(NaN, NaN); // => true
Try this R.identical example in Rambda REPL
identical<T>(x: T, y: T): boolean;
identical<T>(x: T): (y: T) => boolean;
import _objectIs from './_internals/_objectIs'
export function identical(a, b){
if (arguments.length === 1) return _b => identical(a, _b)
return _objectIs(a, b)
}
import { F, T } from '../rambda'
import { _isInteger } from './_internals/_isInteger'
import { _objectIs } from './_internals/_objectIs'
import { identical } from './identical'
test('with boolean', () => {
expect(F()).toBeFalse()
expect(T()).toBeTrue()
})
test('internal isInteger', () => {
expect(_isInteger(1)).toBeTrue()
expect(_isInteger(0.3)).toBeFalse()
})
test('internal objectIs', () => {
expect(_objectIs(1, 1)).toBeTrue()
expect(_objectIs(NaN, NaN)).toBeTrue()
})
test('identical', () => {
const a = {}
expect(identical(100)(100)).toEqual(true)
expect(identical(100, '100')).toEqual(false)
expect(identical('string', 'string')).toEqual(true)
expect(identical([], [])).toEqual(false)
expect(identical(a, a)).toEqual(true)
expect(identical(undefined, undefined)).toEqual(true)
expect(identical(null, undefined)).toEqual(false)
})
identity<T>(input: T): T
It just passes back the supplied input argument.
:boom: Logic
R.identity(7) // => 7
Try this R.identity example in Rambda REPL
identity<T>(input: T): T;
export function identity(input){
return input
}
import { identity } from './identity'
test('happy', () => {
expect(identity(7)).toEqual(7)
expect(identity(true)).toEqual(true)
expect(identity({ a : 1 })).toEqual({ a : 1 })
})
ifElse<T, U>(
condition: (x: T) => boolean,
onTrue: (x: T) => U,
onFalse: (x: T) => U,
): (x: T) => U
It expects condition, onTrue and onFalse functions as inputs and it returns a new function with example name of fn.
When fn`` is called with inputargument, it will return eitheronTrue(input)oronFalse(input)depending oncondition(input)` evaluation.
const fn = R.ifElse(
x => x>10,
x => x*2,
x => x*10
)
const result = [ fn(8), fn(18) ]
// => [80, 36]
Try this R.ifElse example in Rambda REPL
ifElse<T, U>(
condition: (x: T) => boolean,
onTrue: (x: T) => U,
onFalse: (x: T) => U,
): (x: T) => U;
ifElse<T, K, U>(
condition: (x: T, y: K) => boolean,
onTrue: (x: T, y: K) => U,
onFalse: (x: T, y: K) => U,
): (x: T, y: K) => U;
import { 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)
})
:boom: Reason for the failure: Rambda method doesn't return a curried function
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('ifElse', function() {
var t = function(a) { return a + 1; };
var identity = function(a) { return a; };
var isArray = function(a) { return Object.prototype.toString.call(a) === '[object Array]'; };
it('returns a function whose arity equals the max arity of the three arguments to `ifElse`', function() {
function a0() { return 0; }
function a1(x) { return x; }
function a2(x, y) { return x + y; }
eq(R.ifElse(a0, a1, a2).length, 2);
eq(R.ifElse(a0, a2, a1).length, 2);
eq(R.ifElse(a1, a0, a2).length, 2);
eq(R.ifElse(a1, a2, a0).length, 2);
eq(R.ifElse(a2, a0, a1).length, 2);
eq(R.ifElse(a2, a1, a0).length, 2);
});
it('returns a curried function', function() {
var v = function(a) { return typeof a === 'number'; };
var ifIsNumber = R.ifElse(v);
eq(ifIsNumber(t, identity)(15), 16);
eq(ifIsNumber(t, identity)('hello'), 'hello');
var fn = R.ifElse(R.gt, R.subtract, R.add);
eq(fn(2)(7), 9);
eq(fn(2, 7), 9);
eq(fn(7)(2), 5);
eq(fn(7, 2), 5);
});
});
inc(x: number): number
It increments a number.
R.inc(1) // => 2
Try this R.inc example in Rambda REPL
inc(x: number): number;
export const inc = x => x + 1
import { inc } from './inc'
test('happy', () => {
expect(inc(1)).toBe(2)
})
includes(valueToFind: string, input: readonly string[] | string): boolean
If input is string, then this method work as native String.includes.
If input is array, then R.equals is used to define if valueToFind belongs to the list.
const result = [
R.includes('oo', 'foo'),
R.includes({a: 1}, [{a: 1}])
]
// => [true, true ]
Try this R.includes example in Rambda REPL
includes(valueToFind: string, input: readonly string[] | string): boolean;
includes(valueToFind: string): (input: readonly string[] | string) => boolean;
includes<T>(valueToFind: T, input: readonly T[]): boolean;
includes<T>(valueToFind: T): (input: readonly T[]) => boolean;
import { _isArray } from './_internals/_isArray'
import { equals } from './equals'
export function includes(valueToFind, input){
if (arguments.length === 1) return _input => includes(valueToFind, _input)
if (typeof input === 'string'){
return input.includes(valueToFind)
}
if (!input){
throw new TypeError(`Cannot read property \'indexOf\' of ${ input }`)
}
if (!_isArray(input)) return false
let index = -1
while (++index < input.length){
if (equals(input[ index ], valueToFind)){
return true
}
}
return false
}
import R from 'ramda'
import { includes } from './includes'
test('includes with string', () => {
const str = 'foo bar'
expect(includes('bar')(str)).toBeTrue()
expect(R.includes('bar')(str)).toBeTrue()
expect(includes('never', str)).toBeFalse()
expect(R.includes('never', str)).toBeFalse()
})
test('includes with array', () => {
const arr = [ 1, 2, 3 ]
expect(includes(2)(arr)).toBeTrue()
expect(R.includes(2)(arr)).toBeTrue()
expect(includes(4, arr)).toBeFalse()
expect(R.includes(4, arr)).toBeFalse()
})
test('with wrong input that does not throw', () => {
const result = includes(1, /foo/g)
const ramdaResult = R.includes(1, /foo/g)
expect(result).toBeFalse()
expect(ramdaResult).toBeFalse()
})
test('throws on wrong input - match ramda behaviour', () => {
expect(() => includes(2, null)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of null')
expect(() => R.includes(2, null)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of null')
expect(() => includes(2, undefined)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of undefined')
expect(() => R.includes(2, undefined)).toThrowWithMessage(TypeError,
'Cannot read property \'indexOf\' of undefined')
})
:boom: Reason for the failure: Ramda method pass to
equalsmethod if available
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('includes', function() {
it('has R.equals semantics', function() {
function Just(x) { this.value = x; }
Just.prototype.equals = function(x) {
return x instanceof Just && R.equals(x.value, this.value);
};
eq(R.includes(0, [-0]), false);
eq(R.includes(-0, [0]), false);
eq(R.includes(NaN, [NaN]), true);
eq(R.includes(new Just([42]), [new Just([42])]), true);
});
});
indexBy<T, K extends string | number = string>(condition: (key: T) => K, list: readonly T[]): { readonly [key in K]: T }
It generates object with properties provided by condition and values provided by list array.
If condition is a function, then all list members are passed through it.
If condition is a string, then all list members are passed through R.path(condition).
const list = [ {id: 10}, {id: 20} ]
const withFunction = R.indexBy(
x => x.id,
list
)
const withString = R.indexBy(
'id',
list
)
const result = [
withFunction,
R.equals(withFunction, withString)
]
// => [ { 10: {id: 10}, 20: {id: 20} }, true ]
Try this R.indexBy example in Rambda REPL
indexBy<T, K extends string | number = string>(condition: (key: T) => K, list: readonly T[]): { readonly [key in K]: T };
indexBy<T, K extends string | number | undefined = string>(condition: (key: T) => K, list: readonly T[]): { readonly [key in NonNullable<K>]?: T };
indexBy<T, K extends string | number = string>(condition: (key: T) => K): (list: readonly T[]) => { readonly [key in K]: T };
indexBy<T, K extends string | number | undefined = string>(condition: (key: T) => K | undefined): (list: readonly T[]) => { readonly [key in NonNullable<K>]?: T };
indexBy<T>(condition: string, list: readonly T[]): { readonly [key: string]: T };
indexBy<T>(condition: string): (list: readonly T[]) => { readonly [key: string]: T };
import { path } from './path'
function indexByPath(pathInput, list){
const toReturn = {}
for (let i = 0; i < list.length; i++){
const item = list[ i ]
toReturn[ path(pathInput, item) ] = item
}
return toReturn
}
export function indexBy(condition, list){
if (arguments.length === 1){
return _list => indexBy(condition, _list)
}
if (typeof condition === 'string'){
return indexByPath(condition, list)
}
const toReturn = {}
for (let i = 0; i < list.length; i++){
const item = list[ i ]
toReturn[ condition(item) ] = item
}
return toReturn
}
import { indexBy } from './indexBy'
import { prop } from './prop'
test('happy', () => {
const list = [
{ id : 1 },
{
id : 1,
a : 2,
},
{ id : 2 },
{ id : 10 },
{ id : 'a' },
]
expect(indexBy(prop('id'))(list)).toEqual({
1 : {
id : 1,
a : 2,
},
2 : { id : 2 },
10 : { id : 10 },
a : { id : 'a' },
})
})
test('with string as condition', () => {
const list = [ { id : 1 }, { id : 2 }, { id : 10 }, { id : 'a' } ]
const standardResult = indexBy(obj => obj.id, list)
const suggestionResult = indexBy('id', list)
expect(standardResult).toEqual(suggestionResult)
})
test('with string - bad path', () => {
const list = [
{
a : {
b : 1,
c : 2,
},
},
{ a : { c : 4 } },
{},
{
a : {
b : 10,
c : 20,
},
},
]
const result = indexBy('a.b', list)
const expected = {
1 : {
a : {
b : 1,
c : 2,
},
},
10 : {
a : {
b : 10,
c : 20,
},
},
undefined : {},
}
expect(result).toEqual(expected)
})
:boom: Reason for the failure: Ramda method can act as a transducer
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('indexBy', function() {
it('can act as a transducer', function() {
var list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];
var transducer = R.compose(
R.indexBy(R.prop('id')),
R.map(R.pipe(
R.adjust(0, R.toUpper),
R.adjust(1, R.omit(['id']))
)));
var result = R.into({}, transducer, list);
eq(result, {ABC: {title: 'B'}, XYZ: {title: 'A'}});
});
});
indexOf<T>(valueToFind: T, list: readonly T[]): number
It returns the index of the first element of list equals to valueToFind.
If there is no such element, it returns -1.
const list = [0, 1, 2, 3]
const result = [
R.indexOf(2, list),
R.indexOf(0, list)
]
// => [2, -1]
Try this R.indexOf example in Rambda REPL
indexOf<T>(valueToFind: T, list: readonly T[]): number;
indexOf<T>(valueToFind: T): (list: readonly T[]) => number;
export function indexOf(valueToFind, list){
if (arguments.length === 1){
return _list => indexOf(valueToFind, _list)
}
let index = -1
const { length } = list
while (++index < length){
if (list[ index ] === valueToFind){
return index
}
}
return -1
}
import { indexOf } from './indexOf'
test('happy', () => {
expect(indexOf(3, [ 1, 2, 3, 4 ])).toEqual(2)
expect(indexOf(10)([ 1, 2, 3, 4 ])).toEqual(-1)
})
:boom: Reason for the failure: Ramda method dispatches to
indexOfmethod
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('indexOf', function() {
var input = [1, 2, 3, 4, 5];
var list = [1, 2, 3];
list[-2] = 4; // Throw a wrench in the gears by assigning a non-valid array index as object property.
it('has R.equals semantics', function() {
function Just(x) { this.value = x; }
Just.prototype.equals = function(x) {
return x instanceof Just && R.equals(x.value, this.value);
};
eq(R.indexOf(0, [-0]), -1);
eq(R.indexOf(-0, [0]), -1);
eq(R.indexOf(NaN, [NaN]), 0);
eq(R.indexOf(new Just([42]), [new Just([42])]), 0);
});
it('dispatches to `indexOf` method', function() {
function Empty() {}
Empty.prototype.indexOf = R.always(-1);
function List(head, tail) {
this.head = head;
this.tail = tail;
}
List.prototype.indexOf = function(x) {
var idx = this.tail.indexOf(x);
return this.head === x ? 0 : idx >= 0 ? 1 + idx : -1;
};
var list = new List('b',
new List('a',
new List('n',
new List('a',
new List('n',
new List('a',
new Empty()
)
)
)
)
)
);
eq(R.indexOf('a', 'banana'), 1);
eq(R.indexOf('x', 'banana'), -1);
eq(R.indexOf('a', list), 1);
eq(R.indexOf('x', list), -1);
});
});
init<T>(input: readonly T[]): readonly T[]
It returns all but the last element of list or string input.
const result = [
R.init([1, 2, 3]) ,
R.init('foo') // => 'fo'
]
// => [[1, 2], 'fo']
Try this R.init example in Rambda REPL
init<T>(input: readonly T[]): readonly 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('')
})
intersection<T>(listA: readonly T[], listB: readonly T[]): readonly T[]
It loops throw listA and listB and returns the intersection of the two according to R.equals.
const listA = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
const listB = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
const result = intersection(listA, listB)
// => [{ id : 3 }, { id : 4 }]
Try this R.intersection example in Rambda REPL
intersection<T>(listA: readonly T[], listB: readonly T[]): readonly T[];
intersection<T>(listA: readonly T[]): (listB: readonly T[]) => readonly T[];
import { filter } from './filter'
import { includes } from './includes'
export function intersection(listA, listB){
if (arguments.length === 1) return _list => intersection(listA, _list)
return filter(value => includes(value, listB), listA)
}
import { intersection } from './intersection'
test('intersection', () => {
const list1 = [ 1, 2, 3, 4 ]
const list2 = [ 3, 4, 5, 6 ]
expect(intersection(list1)(list2)).toEqual([ 3, 4 ])
expect(intersection([], [])).toEqual([])
})
test('intersection with objects', () => {
const list1 = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
const list2 = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
expect(intersection(list1)(list2)).toEqual([ { id : 3 }, { id : 4 } ])
})
intersperse<T>(separator: T, list: readonly T[]): readonly T[]
It adds a separator between members of list.
const list = [ 0, 1, 2, 3 ]
const separator = '|'
const result = intersperse(separator, list)
// => [0, '|', 1, '|', 2, '|', 3]
Try this R.intersperse example in Rambda REPL
intersperse<T>(separator: T, list: readonly T[]): readonly T[];
intersperse<T>(separator: T): (list: readonly T[]) => readonly T[];
export function intersperse(separator, list){
if (arguments.length === 1) return _list => intersperse(separator, _list)
let index = -1
const len = list.length
const willReturn = []
while (++index < len){
if (index === len - 1){
willReturn.push(list[ index ])
} else {
willReturn.push(list[ index ], separator)
}
}
return willReturn
}
import { intersperse } from './intersperse'
test('intersperse', () => {
const list = [ { id : 1 }, { id : 2 }, { id : 10 }, { id : 'a' } ]
expect(intersperse('!', list)).toEqual([
{ id : 1 },
'!',
{ id : 2 },
'!',
{ id : 10 },
'!',
{ id : 'a' },
])
expect(intersperse('!')([])).toEqual([])
})
is(targetPrototype: any, x: any): boolean
It returns true if x is instance of targetPrototype.
const result = [
R.is(String, 'foo'),
R.is(Array, 1)
]
// => [true, false]
Try this R.is example in Rambda REPL
is(targetPrototype: any, x: any): boolean;
is(targetPrototype: any): (x: any) => boolean;
export function is(targetPrototype, x){
if (arguments.length === 1) return _x => is(targetPrototype, _x)
return (
x != null && x.constructor === targetPrototype ||
x instanceof targetPrototype
)
}
import { is } from './is'
test('works with built-in types', () => {
expect(is(Array, undefined)).toBeFalse()
expect(is(Array)([])).toBeTrue()
expect(is(Boolean, new Boolean(false))).toBeTrue()
expect(is(Date, new Date())).toBeTrue()
expect(is(Function, () => {})).toBeTrue()
expect(is(Number, new Number(0))).toBeTrue()
expect(is(Object, {})).toBeTrue()
expect(is(RegExp, /(?:)/)).toBeTrue()
expect(is(String, new String(''))).toBeTrue()
})
test('works with user-defined types', () => {
function Foo(){}
function Bar(){}
Bar.prototype = new Foo()
const foo = new Foo()
const bar = new Bar()
expect(is(Foo, foo)).toBeTrue()
expect(is(Bar, bar)).toBeTrue()
expect(is(Foo, bar)).toBeTrue()
expect(is(Bar, foo)).toBeFalse()
})
test('does not coerce', () => {
expect(is(Boolean, 1)).toBeFalse()
expect(is(Number, '1')).toBeFalse()
expect(is(Number, false)).toBeFalse()
})
test('recognizes primitives as their object equivalents', () => {
expect(is(Boolean, false)).toBeTrue()
expect(is(Number, 0)).toBeTrue()
expect(is(String, '')).toBeTrue()
})
test('does not consider primitives to be instances of Object', () => {
expect(is(Object, false)).toBeFalse()
expect(is(Object, 0)).toBeFalse()
expect(is(Object, '')).toBeFalse()
})
isEmpty<T>(x: T): boolean
It returns true if x is empty.
const result = [
R.isEmpty(''),
R.isEmpty({ x : 0 })
]
// => [true, false]
Try this R.isEmpty example in Rambda REPL
isEmpty<T>(x: T): boolean;
import { 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)
})
:boom: Reason for the failure: Ramda method supports typed arrays
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('isEmpty', function() {
it('returns true for empty typed array', function() {
eq(R.isEmpty(Uint8Array.from('')), true);
eq(R.isEmpty(Float32Array.from('')), true);
eq(R.isEmpty(new Float32Array([])), true);
eq(R.isEmpty(Uint8Array.from('1')), false);
eq(R.isEmpty(Float32Array.from('1')), false);
eq(R.isEmpty(new Float32Array([1])), false);
});
});
isNil(x: any): x is null | undefined
It returns true if x is either null or undefined.
const result = [
R.isNil(null),
R.isNil(1),
]
// => [true, false]
Try this R.isNil example in Rambda REPL
isNil(x: any): x is null | undefined;
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: readonly T[]): string
It returns a string of all list instances joined with a glue.
R.join('-', [1, 2, 3]) // => '1-2-3'
Try this R.join example in Rambda REPL
join<T>(glue: string, list: readonly T[]): string;
join<T>(glue: string): (list: readonly T[]) => string;
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')
})
keys<T extends object>(x: T): readonly (keyof T)[]
It applies Object.keys over x and returns its keys.
R.keys({a:1, b:2}) // => ['a', 'b']
Try this R.keys example in Rambda REPL
keys<T extends object>(x: T): readonly (keyof T)[];
keys<T>(x: T): readonly string[];
export function keys(x){
return Object.keys(x)
}
import { keys } from './keys'
test('happy', () => {
expect(keys({ a : 1 })).toEqual([ 'a' ])
})
:boom: Reason for the failure: Ramda method works for primitives
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('keys', function() {
var obj = {a: 100, b: [1, 2, 3], c: {x: 200, y: 300}, d: 'D', e: null, f: undefined};
function C() { this.a = 100; this.b = 200; }
C.prototype.x = function() { return 'x'; };
C.prototype.y = 'y';
var cobj = new C();
it('works for primitives', function() {
eq(R.keys(null), []);
eq(R.keys(undefined), []);
eq(R.keys(55), []);
eq(R.keys('foo'), []);
eq(R.keys(true), []);
eq(R.keys(false), []);
eq(R.keys(NaN), []);
eq(R.keys(Infinity), []);
eq(R.keys([]), []);
});
});
last(str: string): string
It returns the last element of input, as the input can be either a string or an array.
const result = [
R.last([1, 2, 3]),
R.last('foo'),
]
// => [3, 'o']
Try this R.last example in Rambda REPL
last(str: string): string;
last(emptyList: readonly []): undefined;
last<T extends any>(list: readonly T[]): T;
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('')
})
lastIndexOf<T>(target: T, list: readonly T[]): number
It returns the last index of target in list array.
R.equals is used to determine equality between target and members of list.
If there is no such index, then -1 is returned.
const list = [1, 2, 3, 1, 2, 3]
const result = [
R.lastIndexOf(2, list),
R.lastIndexOf(4, list),
]
// => [4, -1]
Try this R.lastIndexOf example in Rambda REPL
lastIndexOf<T>(target: T, list: readonly T[]): number;
lastIndexOf<T>(target: T): (list: readonly T[]) => number;
import { equals } from './equals'
export function lastIndexOf(target, list){
if (arguments.length === 1) return _list => lastIndexOf(target, _list)
let index = list.length
while (--index > 0){
if (equals(list[ index ], target)){
return index
}
}
return -1
}
import { lastIndexOf } from './lastIndexOf'
test('happy', () => {
const a = lastIndexOf(1, [ 1, 2, 3, 1, 2 ])
const b = lastIndexOf(1)([ 1, 2, 3, 1, 2 ])
expect(a).toEqual(3)
expect(b).toEqual(3)
})
test('false', () => {
const a = lastIndexOf(10, [ 1, 2, 3, 1, 2 ])
expect(a).toEqual(-1)
})
:boom: Reason for the failure: Ramda method dispatches to
lastIndexOfmethod
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('lastIndexOf', function() {
var input = [1, 2, 3, 4, 5, 1];
var list = ['a', 1, 'a'];
list[-2] = 'a'; // Throw a wrench in the gears by assigning a non-valid array index as object property.
it('has R.equals semantics', function() {
function Just(x) { this.value = x; }
Just.prototype.equals = function(x) {
return x instanceof Just && R.equals(x.value, this.value);
};
eq(R.lastIndexOf(0, [-0]), -1);
eq(R.lastIndexOf(-0, [0]), -1);
eq(R.lastIndexOf(NaN, [NaN]), 0);
eq(R.lastIndexOf(new Just([42]), [new Just([42])]), 0);
});
it('dispatches to `lastIndexOf` method', function() {
function Empty() {}
Empty.prototype.lastIndexOf = R.always(-1);
function List(head, tail) {
this.head = head;
this.tail = tail;
}
List.prototype.lastIndexOf = function(x) {
var idx = this.tail.lastIndexOf(x);
return idx >= 0 ? 1 + idx : this.head === x ? 0 : -1;
};
var list = new List('b',
new List('a',
new List('n',
new List('a',
new List('n',
new List('a',
new Empty()
)
)
)
)
)
);
eq(R.lastIndexOf('a', 'banana'), 5);
eq(R.lastIndexOf('x', 'banana'), -1);
eq(R.lastIndexOf('a', list), 5);
eq(R.lastIndexOf('x', list), -1);
});
it('finds function, compared by identity', function() {
var f = function() {};
var g = function() {};
var list = [g, f, g, f];
eq(R.lastIndexOf(f, list), 3);
});
});
length<T>(input: readonly T[]): number
It returns the length property of list or string input.
const result = [
R.length([1, 2, 3, 4]),
R.length('foo'),
]
// => [4, 3]
Try this R.length example in Rambda REPL
length<T>(input: readonly T[]): number;
export function length(x){
if (!x && x !== '' || x.length === undefined){
return NaN
}
return x.length
}
import { length } from './length'
test('happy', () => {
expect(length('foo')).toEqual(3)
expect(length([ 1, 2, 3 ])).toEqual(3)
expect(length([])).toEqual(0)
})
test('with empty string', () => {
expect(length('')).toEqual(0)
})
test('with bad input returns NaN', () => {
expect(length(0)).toBeNaN()
expect(length({})).toBeNaN()
expect(length(null)).toBeNaN()
expect(length(undefined)).toBeNaN()
})
:boom: Reason for the failure: Ramda method supports object with
lengthmethod
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('length', function() {
it('returns the length of a string', function() {
eq(R.length(''), 0);
eq(R.length('xyz'), 3);
});
it('returns NaN for length property of unexpected type', function() {
eq(R.identical(NaN, R.length({length: ''})), true);
eq(R.identical(NaN, R.length({length: '1.23'})), true);
eq(R.identical(NaN, R.length({length: null})), true);
eq(R.identical(NaN, R.length({length: undefined})), true);
eq(R.identical(NaN, R.length({})), true);
});
});
lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens
It returns a lens for the given getter and setter functions.
The getter gets the value of the focus; the setter sets the value of the focus.
The setter should not mutate the data structure.
const xLens = R.lens(R.prop('x'), R.assoc('x'));
R.view(xLens, {x: 1, y: 2}) // => 1
R.set(xLens, 4, {x: 1, y: 2}) // => {x: 4, y: 2}
R.over(xLens, R.negate, {x: 1, y: 2}) // => {x: -1, y: 2}
Try this R.lens example in Rambda REPL
lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
export function lens(getter, setter){
return function (functor){
return function (target){
return functor(getter(target)).map(focus => setter(focus, target))
}
}
}
lensIndex(index: number): Lens
It returns a lens that focuses on specified index.
const list = ['a', 'b', 'c']
const headLens = R.lensIndex(0)
R.view(headLens, list) // => 'a'
R.set(headLens, 'x', list) // => ['x', 'b', 'c']
R.over(headLens, R.toUpper, list) // => ['A', 'b', 'c']
Try this R.lensIndex example in Rambda REPL
lensIndex(index: number): Lens;
import { 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)
})
lensPath(path: RamdaPath): Lens
It returns a lens that focuses on specified path.
const lensPath = R.lensPath(['x', 0, 'y'])
const input = {x: [{y: 2, z: 3}, {y: 4, z: 5}]}
R.view(lensPath, input) // => 2
R.set(lensPath, 1, input)
// => {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
R.over(xHeadYLens, R.negate, input)
// => {x: [{y: -2, z: 3}, {y: 4, z: 5}]}
Try this R.lensPath example in Rambda REPL
lensPath(path: RamdaPath): Lens;
lensPath(path: string): Lens;
import { 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)
})
lensProp(prop: string): {
<T, U>(obj: T): U
It returns a lens that focuses on specified property prop.
const xLens = R.lensProp('x');
const input = {x: 1, y: 2}
R.view(xLens, input) // => 1
R.set(xLens, 4, input)
// => {x: 4, y: 2}
R.over(xLens, R.negate, input)
// => {x: -1, y: 2}
Try this R.lensProp example in Rambda REPL
lensProp(prop: string): {
<T, U>(obj: T): U;
set<T, U, V>(val: T, obj: U): V;
};
import { 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)
})
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.
:boom: Unlike Ramda's
map, here property and input object are passed as arguments tofn, wheniterableis an object.
const fn = x => x * 2
const fnWhenObject = (val, prop)=>{
return `${prop}-${val}`
}
const iterable = [1, 2]
const obj = {a: 1, b: 2}
const result = [
R.map(fn, list),
R.map(fnWhenObject, obj)
]
// => [ [1, 4], {a: 'a-1', b: 'b-2'}]
Try this R.map example in Rambda REPL
map<T, U>(fn: ObjectIterator<T, U>, iterable: Dictionary<T>): Dictionary<U>;
map<T, U>(fn: Iterator<T, U>, iterable: readonly T[]): readonly U[];
map<T, U>(fn: Iterator<T, U>): (iterable: readonly T[]) => readonly U[];
map<T, U, S>(fn: ObjectIterator<T, U>): (iterable: Dictionary<T>) => Dictionary<U>;
map<T>(fn: Iterator<T, T>): (iterable: readonly T[]) => readonly T[];
map<T>(fn: Iterator<T, T>, iterable: readonly T[]): readonly 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 function map(fn, list){
if (arguments.length === 1) return _list => map(fn, _list)
if (list === undefined) return []
if (_isArray(list)) return mapArray(fn, list)
return mapObject(fn, list)
}
import { map } from './map'
const double = x => x * 2
const sampleObject = {
a : 1,
b : 2,
c : 3,
d : 4,
}
test('with array', () => {
expect(map(double, [ 1, 2, 3 ])).toEqual([ 2, 4, 6 ])
})
test('with object', () => {
const obj = {
a : 1,
b : 2,
}
expect(map(double, obj)).toEqual({
a : 2,
b : 4,
})
})
test('pass input object as third argument', () => {
const obj = {
a : 1,
b : 2,
}
const iterator = (
val, prop, inputObject
) => {
expect(inputObject).toEqual(obj)
return val * 2
}
expect(map(iterator, obj)).toEqual({
a : 2,
b : 4,
})
})
test('with object passes property as second argument', () => {
map((_, prop) => {
expect(typeof prop).toEqual('string')
})(sampleObject)
})
/**
* https://github.com/selfrefactor/rambda/issues/77
*/
test('when undefined instead of array', () => {
expect(map(double, undefined)).toEqual([])
})
match(regExpression: RegExp, str: string): readonly string[]
Curried version of String.prototype.match which returns empty array, when there is no match.
const result = [
R.match('a', 'foo'),
R.match(/([a-z]a)/g, 'bananas')
]
// => [[], ['ba', 'na', 'na']]
Try this R.match example in Rambda REPL
match(regExpression: RegExp, str: string): readonly string[];
match(regExpression: RegExp): (str: string) => readonly 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 property \'match\' of null')
})
mathMod(x: number, y: number): number
R.mathMod behaves like the modulo operator should mathematically, unlike the % operator (and by extension, R.modulo). So while -17 % 5 is -2, mathMod(-17, 5) is 3.
:boom: Explanation is taken from
Ramdadocumentation site.
const result = [
R.mathMod(-17, 5),
R.mathMod(17, 5),
R.mathMod(17, -5),
R.mathMod(17, 0)
]
// => [3, 2, NaN, NaN]
Try this R.mathMod example in Rambda REPL
mathMod(x: number, y: number): number;
mathMod(x: number): (y: number) => number;
import _isInteger from './_internals/_isInteger'
export function mathMod(x, y){
if (arguments.length === 1) return _y => mathMod(x, _y)
if (!_isInteger(x) || !_isInteger(y) || y < 1) return NaN
return (x % y + y) % y
}
import { mathMod } from './mathMod'
test('happy', () => {
expect(mathMod(-17)(5)).toEqual(3)
expect(mathMod(17, 5)).toEqual(2)
expect(mathMod(17, -5)).toBeNaN()
expect(mathMod(17, 0)).toBeNaN()
expect(mathMod('17', 5)).toBeNaN()
expect(mathMod({}, 2)).toBeNaN()
expect(mathMod([], 2)).toBeNaN()
expect(mathMod(Symbol(), 2)).toBeNaN()
})
max<T extends Ord>(x: T, y: T): T
It returns the greater value between x and y.
const result = [
R.max(5, 7),
R.max('bar', 'foo'),
]
// => [7, 'foo']
Try this R.max example in Rambda REPL
max<T extends Ord>(x: T, y: T): T;
max<T extends Ord>(x: T): (y: T) => T;
export function max(x, y){
if (arguments.length === 1) return _y => max(x, _y)
return y > x ? y : x
}
import { max } from './max'
test('with number', () => {
expect(max(2, 1)).toBe(2)
})
test('with string', () => {
expect(max('foo')('bar')).toBe('foo')
expect(max('bar')('baz')).toBe('baz')
})
maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T
It returns the greater value between x and y according to compareFn function.
const compareFn = Math.abs
R.maxBy(compareFn, 5, -7) // => -7
Try this R.maxBy example in Rambda REPL
maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T;
maxBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;
maxBy<T>(compareFn: (input: T) => Ord): FunctionToolbelt.Curry<(x: T, y: T) => T>;
import { curry } from './curry'
export function maxByFn(
compareFn, x, y
){
return compareFn(y) > compareFn(x) ? y : x
}
export const maxBy = curry(maxByFn)
import { maxBy } from './maxBy'
test('happy', () => {
expect(maxBy(
Math.abs, -5, 2
)).toEqual(-5)
})
test('curried', () => {
expect(maxBy(Math.abs)(2, -5)).toEqual(-5)
expect(maxBy(Math.abs)(2)(-5)).toEqual(-5)
})
mean(list: readonly number[]): number
It returns the mean value of list input.
R.mean([ 2, 7 ])
// => 4.5
Try this R.mean example in Rambda REPL
mean(list: readonly number[]): number;
import { 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()
})
median(list: readonly number[]): number
It returns the median value of list input.
R.median([ 7, 2, 10, 9 ]) // => 8
Try this R.median example in Rambda REPL
median(list: readonly number[]): number;
import { 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()
})
merge<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>
It creates a copy of target object with overidden newProps properties.
const target = { 'foo': 0, 'bar': 1 }
const newProps = { 'foo': 7 }
const result = R.merge(target, newProps)
// => { 'foo': 7, 'bar': 1 }
Try this R.merge example in Rambda REPL
merge<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>;
merge<O1 extends object>(target: O1): <O2 extends object>(newProps: O2) => Merge<O2, O1, 'flat'>;
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)
})
mergeAll<T>(list: readonly object[]): T
It merges all objects of list array sequentially and returns the result.
const list = [
{a: 1},
{b: 2},
{c: 3}
]
const result = R.mergeAll(list)
const expected = {
a: 1,
b: 2,
c: 3
}
// => `result` is equal to `expected`
Try this R.mergeAll example in Rambda REPL
mergeAll<T>(list: readonly object[]): T;
mergeAll(list: readonly 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,
})
})
mergeDeepRight<O1 extends object, O2 extends object>(x: O1, y: O2): Merge<O2, O1, 'deep'>
Creates a new object with the own properties of the first object merged with the own properties of the second object. If a key exists in both objects:
mergeDeepRight<O1 extends object, O2 extends object>(x: O1, y: O2): Merge<O2, O1, 'deep'>;
mergeDeepRight<O1 extends object>(x: O1): <O2 extends object>(y: O2) => Merge<O2, O1, 'deep'>;
import { 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)
})
mergeLeft<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>
Same as R.merge, but in opposite direction.
const result = R.mergeLeft(
{a: 10},
{a: 1, b: 2}
)
// => {a:10, b: 2}
Try this R.mergeLeft example in Rambda REPL
mergeLeft<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>;
mergeLeft<O1 extends object>(target: O1): <O2 extends object>(newProps: O2) => Merge<O2, O1, 'flat'>;
import { 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)
})
min<T extends Ord>(x: T, y: T): T
It returns the lesser value between x and y.
const result = [
R.min(5, 7),
R.min('bar', 'foo'),
]
// => [5, 'bar']
Try this R.min example in Rambda REPL
min<T extends Ord>(x: T, y: T): T;
min<T extends Ord>(x: T): (y: T) => T;
export function min(x, y){
if (arguments.length === 1) return _y => min(x, _y)
return y < x ? y : x
}
import { min } from './min'
test('happy', () => {
expect(min(2, 1)).toBe(1)
expect(min(1)(2)).toBe(1)
})
minBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T
It returns the lesser value between x and y according to compareFn function.
const compareFn = Math.abs
R.minBy(compareFn, -5, 2) // => -5
Try this R.minBy example in Rambda REPL
minBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T;
minBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;
minBy<T>(compareFn: (input: T) => Ord): FunctionToolbelt.Curry<(x: T, y: T) => T>;
import { curry } from './curry'
export function minByFn(
compareFn, x, y
){
return compareFn(y) < compareFn(x) ? y : x
}
export const minBy = curry(minByFn)
import { minBy } from './minBy'
test('happy', () => {
expect(minBy(
Math.abs, -5, 2
)).toEqual(2)
})
test('curried', () => {
expect(minBy(Math.abs)(2, -5)).toEqual(2)
expect(minBy(Math.abs)(2)(-5)).toEqual(2)
})
modulo(x: number, y: number): number
Curried version of x%y.
R.modulo(17, 3) // => 2
Try this R.modulo example in Rambda REPL
modulo(x: number, y: number): number;
modulo(x: number): (y: number) => number;
export function modulo(x, y){
if (arguments.length === 1) return _y => modulo(x, _y)
return x % y
}
import { modulo } from './modulo'
test('happy', () => {
expect(modulo(17, 3)).toEqual(2)
expect(modulo(15)(6)).toEqual(3)
})
move<T>(fromIndex: number, toIndex: number, list: readonly T[]): readonly T[]
It returns a copy of list with exchanged fromIndex and toIndex elements.
:boom: Rambda.move doesn't support negative indexes - it throws an error.
const list = [1, 2, 3]
const result = R.move(0, 1, list)
// => [2, 1, 3]
Try this R.move example in Rambda REPL
move<T>(fromIndex: number, toIndex: number, list: readonly T[]): readonly T[];
move(fromIndex: number, toIndex: number): <T>(list: readonly T[]) => readonly T[];
move(fromIndex: number): {
<T>(toIndex: number, list: readonly T[]): readonly T[];
(toIndex: number): <T>(list: readonly T[]) => readonly T[];
};
import { curry } from './curry'
function moveFn(
fromIndex, toIndex, list
){
if (fromIndex < 0 || toIndex < 0){
throw new Error('Rambda.move does not support negative indexes')
}
if (fromIndex > list.length - 1 || toIndex > list.length - 1) return list
const clone = list.slice()
clone[ fromIndex ] = list[ toIndex ]
clone[ toIndex ] = list[ fromIndex ]
return clone
}
export const move = curry(moveFn)
import { move } from './move'
const list = [ 1, 2, 3, 4 ]
test('happy', () => {
const result = move(
0, 1, list
)
expect(result).toEqual([ 2, 1, 3, 4 ])
})
test('with negative index', () => {
const errorMessage = 'Rambda.move does not support negative indexes'
expect(() => move(
0, -1, list
)).toThrowWithMessage(Error, errorMessage)
expect(() => move(
-1, 0, list
)).toThrowWithMessage(Error, errorMessage)
})
test('when indexes are outside the list outbounds', () => {
const result1 = move(
10, 1, list
)
const result2 = move(
1, 10, list
)
expect(result1).toEqual(list)
expect(result2).toEqual(list)
})
2 failed Ramda.move specs
:boom: Reason for the failure: Ramda method does not support negative indexes
multiply(x: number, y: number): number
Curried version of x*y.
R.multiply(2, 4) // => 8
Try this R.multiply example in Rambda REPL
multiply(x: number, y: number): number;
multiply(x: number): (y: number) => number;
export function multiply(x, y){
if (arguments.length === 1) return _y => multiply(x, _y)
return x * y
}
import { multiply } from './multiply'
test('happy', () => {
expect(multiply(2, 4)).toEqual(8)
expect(multiply(2)(4)).toEqual(8)
})
negate(x: number): number
R.negate(420)// => -420
Try this R.negate example in Rambda REPL
negate(x: number): number;
export function negate(x){
return -x
}
import { negate } from './negate'
test('negate', () => {
expect(negate(420)).toEqual(-420)
expect(negate(-13)).toEqual(13)
})
none<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean
It returns true, if all members of array list returns false, when applied as argument to predicate function.
const list = [ 0, 1, 2, 3, 4 ]
const predicate = x => x > 6
const result = R.none(predicate, arr)
// => true
Try this R.none example in Rambda REPL
none<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean;
none<T>(predicate: (x: T) => boolean): (list: readonly T[]) => boolean;
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 true
}
return false
}
import { none } from './none'
const isEven = n => n % 2 === 0
const isOdd = n => n % 2 === 1
const arr = [ 1, 3, 5, 7, 9, 11 ]
test('when true', () => {
expect(none(isEven, arr)).toBeTrue()
})
test('when false curried', () => {
expect(none(isOdd)(arr)).toBeFalse()
})
not(input: any): boolean
It returns a boolean negated version of input.
R.not(false) // true
Try this R.not example in Rambda REPL
not(input: any): boolean;
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)
})
nth<T>(index: number, list: readonly T[]): T | undefined
Curried version of list[index].
const list = [1, 2, 3]
const str = 'foo'
const result = [
R.nth(2, list),
R.nth(6, list),
R.nth(0, str),
]
// => [3, undefined, 'f']
Try this R.nth example in Rambda REPL
nth<T>(index: number, list: readonly T[]): T | undefined;
nth(index: number): <T>(list: readonly T[]) => T | undefined;
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)
})
of<T>(x: T): readonly T[]
R.of(null); // => [null]
R.of([42]); // => [[42]]
Try this R.of example in Rambda REPL
of<T>(x: T): readonly T[];
export function of(value){
return [ value ]
}
import { of } from './of'
test('happy', () => {
expect(of(3)).toEqual([ 3 ])
expect(of(null)).toEqual([ null ])
})
omit<T, K extends string>(propsToOmit: readonly K[], obj: T): Omit<T, K>
It returns a partial copy of an obj without propsToOmit properties.
:boom: When using this method with
TypeScript, it is much easier to passpropsToOmitas an array. If passing a string, you will need to explicitly declare the output type.
const obj = {a: 1, b: 2, c: 3}
const propsToOmit = 'a,c,d'
const propsToOmitList = ['a', 'c', 'd']
const result = [
R.omit(propsToOmit, obj),
R.omit(propsToOmitList, obj)
]
// => [{b: 2}, {b: 2}]
Try this R.omit example in Rambda REPL
omit<T, K extends string>(propsToOmit: readonly K[], obj: T): Omit<T, K>;
omit<K extends string>(propsToOmit: readonly K[]): <T>(obj: T) => Omit<T, K>;
omit<T, U>(propsToOmit: string, obj: T): U;
omit<T, U>(propsToOmit: string): (obj: T) => U;
omit<T>(propsToOmit: string, obj: object): T;
omit<T>(propsToOmit: string): (obj: object) => T;
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' })
})
once<T extends (...args: readonly any[]) => any>(func: T): T
It returns a function, which invokes only once fn function.
let result = 0
const addOnce = R.once((x) => result = result + x)
addOnce(1)
addOnce(1)
// => 1
Try this R.once example in Rambda REPL
once<T extends (...args: readonly 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)
})
1 failed Ramda.once specs
:boom: Reason for the failure: Ramda method retains arity
or<T, U>(a: T, b: U): T | U
Logical OR
R.or(false, true); // => true
R.or(false, false); // => false
R.or(false, 'foo'); // => 'foo'
Try this R.or example in Rambda REPL
or<T, U>(a: T, b: U): T | U;
or<T>(a: T): <U>(b: U) => T | U;
export function or(a, b){
if (arguments.length === 1) return _b => or(a, _b)
return a || b
}
import { or } from './or'
test('happy', () => {
expect(or(0, 'foo')).toBe('foo')
expect(or(true, true)).toBeTrue()
expect(or(false)(true)).toBeTrue()
expect(or(false, false)).toBeFalse()
})
over<T>(lens: Lens, fn: Arity1Fn, value: T): T
It returns a copied Object or Array with modified value received by applying function fn to lens focus.
const headLens = R.lensIndex(0)
R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']) // => ['FOO', 'bar', 'baz']
Try this R.over example in Rambda REPL
over<T>(lens: Lens, fn: Arity1Fn, value: T): T;
over<T>(lens: Lens, fn: Arity1Fn, value: readonly T[]): readonly T[];
over(lens: Lens, fn: Arity1Fn): <T>(value: T) => T;
over(lens: Lens, fn: Arity1Fn): <T>(value: readonly T[]) => readonly T[];
over(lens: Lens): <T>(fn: Arity1Fn, value: T) => T;
over(lens: Lens): <T>(fn: Arity1Fn, value: readonly T[]) => readonly 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' ])
})
partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: readonly [V0]): (x1: V1) => T
It is very similar to R.curry, but you can pass initial arguments when you create the curried function.
R.partial will keep returning a function until all the arguments that the function fn expects are passed.
The name comes from the fact that you partially inject the inputs.
:boom: Rambda's partial doesn't need the input arguments to be wrapped as array.
const fn = (title, firstName, lastName) => {
return title + ' ' + firstName + ' ' + lastName + '!'
}
const canPassAnyNumberOfArguments = R.partial(fn, 'Hello')
const ramdaStyle = R.partial(fn, ['Hello'])
const finalFn = canPassAnyNumberOfArguments('Foo')
finalFn('Bar') // => 'Hello, Foo Bar!'
Try this R.partial example in Rambda REPL
partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: readonly [V0]): (x1: V1) => T;
partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: readonly [V0, V1]): (x2: V2) => T;
partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: readonly [V0]): (x1: V1, x2: V2) => T;
partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: readonly [V0, V1, V2]): (x2: V3) => T;
partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: readonly [V0, V1]): (x2: V2, x3: V3) => T;
partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: readonly [V0]): (x1: V1, x2: V2, x3: V3) => T;
partial<T>(fn: (...a: readonly any[]) => T, args: readonly any[]): (...x: readonly 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!')
})
partition<T>(
predicate: Predicate<T>,
input: readonly T[]
): readonly [readonly T[], readonly T[]]
It will return array of two objects/arrays according to predicate function. The first member holds all instanses of input that pass the predicate function, while the second member - those who doesn't.
const list = [1, 2, 3]
const obj = {a: 1, b: 2, c: 3}
const predicate = x => x > 2
const result = [
R.partition(predicate, list),
R.partition(predicate, obj)
]
const expected = [
[[3], [1, 2]],
[{c: 3}, {a: 1, b: 2}],
]
// `result` is equal to `expected`
Try this R.partition example in Rambda REPL
partition<T>(
predicate: Predicate<T>,
input: readonly T[]
): readonly [readonly T[], readonly T[]];
partition<T>(
predicate: Predicate<T>
): (input: readonly T[]) => readonly [readonly T[], readonly T[]];
partition<T>(
predicate: (x: T, prop?: string) => boolean,
input: { readonly [key: string]: T}
): readonly [{ readonly [key: string]: T}, { readonly [key: string]: T}];
partition<T>(
predicate: (x: T, prop?: string) => boolean
): (input: { readonly [key: string]: T}) => readonly [{ readonly [key: string]: T}, { readonly [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){
const yes = []
const no = []
let counter = -1
while (counter++ < list.length - 1){
if (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)
})
1 failed Ramda.partition specs
:boom: Reason for the failure: Ramda library supports fantasy-land
path<Input, T>(pathToSearch: Path, obj: Input): T | undefined
If pathToSearch is 'a.b' then it will return 1 if obj is {a:{b:1}}.
It will return undefined, if such path is not found.
:boom: String anotation of
pathToSearchis one of the differences betweenRambdaandRamda.
const obj = {a: {b: 1}}
const pathToSearch = 'a.b'
const pathToSearchList = ['a', 'b']
const result = [
R.path(pathToSearch, obj),
R.path(pathToSearchList, obj),
R.path('a.b.c.d', obj)
]
// => [1, 1, undefined]
Try this R.path example in Rambda REPL
path<Input, T>(pathToSearch: Path, obj: Input): T | undefined;
path<T>(pathToSearch: Path, obj: any): T | undefined;
path<T>(pathToSearch: Path): (obj: any) => T | undefined;
path<Input, T>(pathToSearch: Path): (obj: Input) => T | undefined;
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
}
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()
})
:boom: Reason for the failure: Ramda method supports negative indexes
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('path', function() {
var deepObject = {a: {b: {c: 'c'}}, falseVal: false, nullVal: null, undefinedVal: undefined, arrayVal: ['arr']};
it('takes a path that contains negative indices into arrays', function() {
eq(R.path(['x', -2], {x: ['a', 'b', 'c', 'd']}), 'c');
eq(R.path([-1, 'y'], [{x: 1, y: 99}, {x: 2, y: 98}, {x: 3, y: 97}]), 97);
});
});
pathEq(pathToSearch: Path, target: any, input: any): boolean
It returns true if pathToSearch of input object is equal to target value.
pathToSearch is passed to R.path, which means that it can be either a string or an array. Also equality between target and the found value is determined by R.equals.
const path = 'a.b'
const target = {c: 1}
const input = {a: {b: {c: 1}}}
const result = R.pathEq(
path,
target,
input
)
// => true
Try this R.pathEq example in Rambda REPL
pathEq(pathToSearch: Path, target: any, input: any): boolean;
pathEq(pathToSearch: Path, target: any): (input: any) => boolean;
pathEq(pathToSearch: Path): FunctionToolbelt.Curry<(a: any, b: any) => boolean>;
import { 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()
})
1 failed Ramda.pathEq specs
:boom: Reason for the failure: Ramda library supports fantasy-land
pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T
It reads obj input and returns either R.path(pathToSearch, obj) result or defaultValue input.
const defaultValue = 'DEFAULT_VALUE'
const pathToSearch = 'a.b'
const pathToSearchList = ['a', 'b']
const obj = {
a : {
b : 1
}
}
const result = [
R.pathOr(DEFAULT_VALUE, pathToSearch, obj)
R.pathOr(DEFAULT_VALUE, pathToSearchList, obj)
R.pathOr(DEFAULT_VALUE, 'a.b.c', obj)
]
// => [1, 1, 'DEFAULT_VALUE']
Try this R.pathOr example in Rambda REPL
pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T;
pathOr<T>(defaultValue: T, pathToSearch: Path): (obj: any) => T;
pathOr<T>(defaultValue: T): FunctionToolbelt.Curry<(a: Path, b: any) => T>;
import { curry } from './curry'
import { defaultTo } from './defaultTo'
import { path } from './path'
function pathOrFn(
defaultValue, list, obj
){
return defaultTo(defaultValue, path(list, 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')
})
paths<Input, T>(pathsToSearch: readonly Path[], obj: Input): readonly (T | undefined)[]
It loops over members of pathsToSearch as singlePath and returns the array produced by R.path(singlePath, obj).
Because it calls R.path, then singlePath can be either string or a list.
const obj = {
a : {
b : {
c : 1,
d : 2
}
}
}
const result = R.paths([
'a.b.c',
'a.b.c.d',
'a.b.c.d.e',
], obj)
// => [1, 2, undefined]
Try this R.paths example in Rambda REPL
paths<Input, T>(pathsToSearch: readonly Path[], obj: Input): readonly (T | undefined)[];
paths<Input, T>(pathsToSearch: readonly Path[]): (obj: Input) => readonly (T | undefined)[];
paths<T>(pathsToSearch: readonly Path[], obj: any): readonly (T | undefined)[];
paths<T>(pathsToSearch: readonly Path[]): (obj: any) => readonly (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 ])
})
:boom: Reason for the failure: Ramda method supports negative indexes
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('paths', function() {
var obj = {
a: {
b: {
c: 1,
d: 2
}
},
p: [{q: 3}, 'Hi'],
x: {
y: 'Alice',
z: [[{}]]
}
};
it('takes a path that contains negative indices into arrays', function() {
eq(R.paths([['p', -2, 'q'], ['p', -1]], obj), [3, 'Hi']);
eq(R.paths([['p', -4, 'q'], ['x', 'z', -1, 0]], obj), [undefined, {}]);
});
});
pick<T, K extends string | number | symbol>(propsToPick: readonly K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>
It returns a partial copy of an input containing only propsToPick properties.
input can be either an object or an array.
String anotation of propsToPick is one of the differences between Rambda and Ramda.
:boom: When using this method with
TypeScript, it is much easier to passpropsToPickas an array. If passing a string, you will need to explicitly declare the output type.
const obj = {
a : 1,
b : false,
foo: 'cherry'
}
const list = [1, 2, 3, 4]
const propsToPick = 'a,foo'
const propsToPickList = ['a', 'foo']
const result = [
R.pick(propsToPick, obj),
R.pick(propsToPickList, obj),
R.pick('a,bar', obj),
R.pick('bar', obj),
R.pick([0, 3], list),
R.pick('0,3', list),
]
const expected = [
{a:1, foo: 'cherry'},
{a:1, foo: 'cherry'},
{a:1},
{},
[1,4],
[1,4]
]
// => `result` is equal to `expected`
Try this R.pick example in Rambda REPL
pick<T, K extends string | number | symbol>(propsToPick: readonly K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;
pick<K extends string | number | symbol>(propsToPick: readonly K[]): <T>(input: T) => Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;
pick<T, U>(propsToPick: string, input: T): U;
pick<T, U>(propsToPick: string): (input: T) => U;
pick<T>(propsToPick: string, input: object): T;
pick<T>(propsToPick: string): (input: object) => T;
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('props to pick is an array', () => {
expect(pick([ 'a', 'c' ])({
a : 'foo',
b : 'bar',
c : 'baz',
})).toEqual({
a : 'foo',
c : 'baz',
})
expect(pick([ 'a', 'd', 'e', 'f' ])({
a : 'foo',
b : 'bar',
c : 'baz',
})).toEqual({ a : 'foo' })
expect(pick('a,d,e,f')(null)).toEqual(undefined)
})
test('works with list as input and number as props - props to pick is an array', () => {
const result = pick([ 1, 2 ], [ 'a', 'b', 'c', 'd' ])
expect(result).toEqual({
1 : 'b',
2 : 'c',
})
})
test('works with list as input and number as props - props to pick is a string', () => {
const result = pick('1,2', [ 'a', 'b', 'c', 'd' ])
expect(result).toEqual({
1 : 'b',
2 : 'c',
})
})
test('with symbol', () => {
const symbolProp = Symbol('s')
expect(pick([ symbolProp ], { [ symbolProp ] : 'a' })).toMatchInlineSnapshot(`
Object {
Symbol(s): "a",
}
`)
})
pickAll<T, U>(propsToPick: readonly string[], input: T): U
Same as R.pick but it won't skip the missing props, i.e. it will assign them to undefined.
:boom: When using this method with
TypeScript, it is much easier to passpropsToPickas an array. If passing a string, you will need to explicitly declare the output type.
const obj = {
a : 1,
b : false,
foo: 'cherry'
}
const propsToPick = 'a,foo,bar'
const propsToPickList = ['a', 'foo', 'bar']
const result = [
R.pickAll(propsToPick, obj),
R.pickAll(propsToPickList, obj),
R.pickAll('a,bar', obj),
R.pickAll('bar', obj),
]
const expected = [
{a:1, foo: 'cherry', bar: undefined},
{a:1, foo: 'cherry', bar: undefined},
{a:1, bar: undefined},
{bar: undefined}
]
// => `result` is equal to `expected`
Try this R.pickAll example in Rambda REPL
pickAll<T, U>(propsToPick: readonly string[], input: T): U;
pickAll<T, U>(propsToPick: readonly string[]): (input: T) => U;
pickAll<T, U>(propsToPick: string, input: T): U;
pickAll<T, U>(propsToPick: string): (input: T) => U;
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',
})
})
pipe<T1>(fn0: () => T1): () => T1
It performs left-to-right function composition.
const result = R.pipe(
R.filter(val => val > 2),
R.map(a => a * 2)
)([1, 2, 3, 4])
// => [6, 8]
Try this R.pipe example in Rambda REPL
pipe<T1>(fn0: () => T1): () => T1;
pipe<V0, T1>(fn0: (x0: V0) => T1): (x0: V0) => T1;
pipe<V0, V1, T1>(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1;
pipe<V0, V1, V2, T1>(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1;
pipe<T1, T2>(fn0: () => T1, fn1: (x: T1) => T2): () => T2;
pipe<V0, T1, T2>(fn0: (x0: V0) => T1, fn1: (x: T1) => T2): (x0: V0) => T2;
pipe<V0, V1, T1, T2>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1) => T2;
pipe<V0, V1, V2, T1, T2>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1, x2: V2) => T2;
pipe<T1, T2, T3>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): () => T3;
pipe<V0, T1, T2, T3>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x: V0) => T3;
pipe<V0, V1, T1, T2, T3>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1) => T3;
pipe<V0, V1, V2, T1, T2, T3>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1, x2: V2) => T3;
pipe<T1, T2, T3, T4>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): () => T4;
pipe<V0, T1, T2, T3, T4>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x: V0) => T4;
pipe<V0, V1, T1, T2, T3, T4>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1) => T4;
pipe<V0, V1, V2, T1, T2, T3, T4>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1, x2: V2) => T4;
pipe<T1, T2, T3, T4, T5>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): () => T5;
pipe<V0, T1, T2, T3, T4, T5>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x: V0) => T5;
pipe<V0, V1, T1, T2, T3, T4, T5>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1) => T5;
pipe<V0, V1, V2, T1, T2, T3, T4, T5>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1, x2: V2) => T5;
pipe<T1, T2, T3, T4, T5, T6>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): () => T6;
pipe<V0, T1, T2, T3, T4, T5, T6>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x: V0) => T6;
pipe<V0, V1, T1, T2, T3, T4, T5, T6>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x0: V0, x1: V1) => T6;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6): (x0: V0, x1: V1, x2: V2) => T6;
pipe<T1, T2, T3, T4, T5, T6, T7>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn: (x: T6) => T7): () => T7;
pipe<V0, T1, T2, T3, T4, T5, T6, T7>(
fn0: (x: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn: (x: T6) => T7): (x: V0) => T7;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7): (x0: V0, x1: V1) => T7;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7): (x0: V0, x1: V1, x2: V2) => T7;
pipe<T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn: (x: T7) => T8): () => T8;
pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: (x: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn: (x: T7) => T8): (x: V0) => T8;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8): (x0: V0, x1: V1) => T8;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8): (x0: V0, x1: V1, x2: V2) => T8;
pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): () => T9;
pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: (x0: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): (x0: V0) => T9;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): (x0: V0, x1: V1) => T9;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9): (x0: V0, x1: V1, x2: V2) => T9;
pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: () => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): () => T10;
pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: (x0: V0) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): (x0: V0) => T10;
pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: (x0: V0, x1: V1) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): (x0: V0, x1: V1) => T10;
pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
fn0: (x0: V0, x1: V1, x2: V2) => T1,
fn1: (x: T1) => T2,
fn2: (x: T2) => T3,
fn3: (x: T3) => T4,
fn4: (x: T4) => T5,
fn5: (x: T5) => T6,
fn6: (x: T6) => T7,
fn7: (x: T7) => T8,
fn8: (x: T8) => T9,
fn9: (x: T9) => T10): (x0: V0, x1: V1, x2: V2) => T10;
export function pipe(...fns){
if (fns.length === 0)
throw new Error('pipe requires at least one argument')
return (...args) => {
const list = fns.slice()
if (list.length > 0){
const fn = list.shift()
let result = fn(...args)
while (list.length > 0){
result = list.shift()(result)
}
return result
}
}
}
import { add, last, map } from '../rambda'
import { pipe } from './pipe'
test('happy', () => {
const list = [ 1, 2, 3 ]
const result = pipe(
map(add(1)), map(add(10)), last
)(list)
expect(result).toEqual(14)
})
test('with bad input', () => {
expect(() => pipe()).toThrowWithMessage(Error,
'pipe requires at least one argument')
})
:boom: Reason for the failure: Ramda method passes context to functions | Rambda composed functions have no length
var assert = require('assert');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('pipe', function() {
it('performs left-to-right function composition', function() {
// f :: (String, Number?) -> ([Number] -> [Number])
var f = R.pipe(parseInt, R.multiply, R.map);
eq(f.length, 2);
eq(f('10')([1, 2, 3]), [10, 20, 30]);
eq(f('10', 2)([1, 2, 3]), [2, 4, 6]);
});
it('passes context to functions', function() {
function x(val) {
return this.x * val;
}
function y(val) {
return this.y * val;
}
function z(val) {
return this.z * val;
}
var context = {
a: R.pipe(x, y, z),
x: 4,
y: 2,
z: 1
};
eq(context.a(5), 40);
});
it('can be applied to one argument', function() {
var f = function(a, b, c) { return [a, b, c]; };
var g = R.pipe(f);
eq(g.length, 3);
eq(g(1, 2, 3), [1, 2, 3]);
});
});
pluck<K extends keyof T, T>(property: K, list: readonly T[]): ReadonlyArray<T[K]>
It returns list of the values of property taken from the all objects inside list.
const list = [{a: 1}, {a: 2}, {b: 3}]
const property = 'a'
R.pluck(list, property)
// => [1, 2]
Try this R.pluck example in Rambda REPL
pluck<K extends keyof T, T>(property: K, list: readonly T[]): ReadonlyArray<T[K]>;
pluck<T>(property: number, list: ReadonlyArray<{ readonly [k: number]: T }>): readonly T[];
pluck<P extends string>(property: P): <T>(list: ReadonlyArray<Record<P, T>>) => readonly T[];
pluck(property: number): <T>(list: ReadonlyArray<{ readonly [k: number]: T }>) => readonly 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 ])
})
:boom: Reason for the failure: Ramda method behaves as a transducer
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('pluck', function() {
var people = [
{name: 'Fred', age: 23},
{name: 'Wilma', age: 21},
{name: 'Pebbles', age: 2}
];
it('behaves as a transducer when given a transducer in list position', function() {
var numbers = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
var transducer = R.compose(R.pluck('a'), R.map(R.add(1)), R.take(2));
eq(R.transduce(transducer, R.flip(R.append), [], numbers), [2, 3]);
});
});
prepend<T>(x: T, input: readonly T[]): readonly T[]
It adds element x at the beginning of list.
const result = R.prepend('foo', ['bar', 'baz'])
// => ['foo', 'bar', 'baz']
Try this R.prepend example in Rambda REPL
prepend<T>(x: T, input: readonly T[]): readonly T[];
prepend<T>(x: T): (input: readonly T[]) => readonly 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' ])
})
product(list: readonly number[]): number
R.product([ 2, 3, 4 ])
// => 24)
Try this R.product example in Rambda REPL
product(list: readonly number[]): number;
import { 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)
})
prop<P extends keyof T, T>(propToFind: P, obj: T): T[P]
It returns the value of property propToFind in obj.
If there is no such property, it returns undefined.
const result = [
R.prop('x', {x: 100}),
R.prop('x', {a: 1})
]
// => [100, undefined]
Try this R.prop example in Rambda REPL
prop<P extends keyof T, T>(propToFind: P, obj: T): T[P];
prop<P extends string | number>(p: P): <T>(propToFind: Record<P, T>) => T;
prop<P extends keyof T, T>(p: P): (propToFind: 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)
})
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.
const obj = { foo: 'bar' }
const secondObj = { foo: 1 }
const propToFind = 'foo'
const valueToMatch = 'bar'
const result = [
R.propEq(propToFind, valueToMatch, obj),
R.propEq(propToFind, valueToMatch, secondObj)
]
// => [true, false]
Try this R.propEq example in Rambda REPL
propEq<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()
})
:boom: Reason for the failure: Ramda method pass to
equalsmethod if available
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('propEq', function() {
var obj1 = {name: 'Abby', age: 7, hair: 'blond'};
var obj2 = {name: 'Fred', age: 12, hair: 'brown'};
it('handles number as property', function() {
var deities = ['Cthulhu', 'Dagon', 'Yog-Sothoth'];
eq(R.propEq(0, 'Cthulhu', deities), true);
eq(R.propEq(1, 'Dagon', deities), true);
eq(R.propEq(2, 'Yog-Sothoth', deities), true);
eq(R.propEq(-1, 'Yog-Sothoth', deities), true);
eq(R.propEq(3, undefined, deities), true);
});
it('has R.equals semantics', function() {
function Just(x) { this.value = x; }
Just.prototype.equals = function(x) {
return x instanceof Just && R.equals(x.value, this.value);
};
eq(R.propEq('value', 0, {value: -0}), false);
eq(R.propEq('value', -0, {value: 0}), false);
eq(R.propEq('value', NaN, {value: NaN}), true);
eq(R.propEq('value', new Just([42]), {value: new Just([42])}), true);
});
});
propIs(type: any, name: string, obj: any): boolean
It returns true if property of obj is from target type.
const obj = {a:1, b: 'foo'}
const property = 'foo'
const result = [
R.propIs(String, property, obj),
R.propIs(Number, property, obj)
]
// => [true, false]
Try this R.propIs example in Rambda REPL
propIs(type: any, name: string, obj: any): boolean;
propIs(type: any, name: string): (obj: any) => boolean;
propIs(type: any): {
(name: string, obj: any): boolean;
(name: string): (obj: any) => boolean;
};
import { 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 = { value : 1 }
const property = 'value'
test('when true', () => {
expect(propIs(
Number, property, obj
)).toBeTrue()
})
test('when false', () => {
expect(propIs(
String, property, obj
)).toBeFalse()
expect(propIs(
String, property, {}
)).toBeFalse()
})
propOr<T, 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.
const obj = {a: 1}
const defaultValue = 'DEFAULT_VALUE'
const property = 'a'
const result = [
R.propOr(defaultValue, property, obj),
R.propOr(defaultValue, 'foo', obj)
]
// => [1, 'DEFAULT_VALUE']
Try this R.propOr example in Rambda REPL
propOr<T, 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')
})
props<P extends string, T>(propsToPick: readonly P[], obj: Record<P, T>): readonly T[]
It takes list with properties propsToPick and returns a list with property values in obj.
const result = [
R.props(['a', 'b'], {a:1, c:3})
// => [1, undefined]
Try this R.props example in Rambda REPL
props<P extends string, T>(propsToPick: readonly P[], obj: Record<P, T>): readonly T[];
props<P extends string>(propsToPick: readonly P[]): <T>(obj: Record<P, T>) => readonly T[];
props<P extends string, T>(propsToPick: readonly P[]): (obj: Record<P, T>) => readonly 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()
})
range(startInclusive: number, endExclusive: number): readonly number[]
It returns list of numbers between startInclusive to endExclusive markers.
R.range(0, 5)
// => [0, 1, 2, 3, 4]
Try this R.range example in Rambda REPL
range(startInclusive: number, endExclusive: number): readonly number[];
range(startInclusive: number): (endExclusive: number) => readonly 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 ])
})
reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: readonly T[]): TResult
:boom: It passes index of the list as third argument to
reducerfunction.
const list = [1, 2, 3]
const initialValue = 10
const reducer = (prev, current) => prev * current
const result = R.reduce(reducer, initialValue, list)
// => 60
Try this R.reduce example in Rambda REPL
reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: readonly T[]): TResult;
reduce<T, TResult>(reducer: (prev: TResult, current: T) => TResult, initialValue: TResult, list: readonly T[]): TResult;
reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult): (initialValue: TResult, list: readonly T[]) => TResult;
reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult, initialValue: TResult): (list: readonly 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 ]
test('happy', () => {
expect(reduce(
reducer, initialValue, list
)).toEqual(7)
})
test('with object as iterable', () => {
expect(() =>
reduce(
reducer, initialValue, {
a : 1,
b : 2,
}
)).toThrowWithMessage(TypeError, 'reduce: list must be array or iterable')
})
test('with undefined as iterable', () => {
expect(() => reduce(
reducer, initialValue, undefined
)).toThrowWithMessage(TypeError,
'reduce: list must be array or iterable')
})
:boom: Reason for the failure: Rambda library doesn't have
R.reducedmethod | Ramda method pass toreducemethod
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('reduce', function() {
var add = function(a, b) {return a + b;};
var mult = function(a, b) {return a * b;};
it('Prefers the use of the iterator of an object over reduce (and handles short-circuits)', function() {
var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';
function Reducible(arr) {
this.arr = arr;
}
Reducible.prototype.reduce = function(f, init) {
var acc = init;
for (var i = 0; i < this.arr.length; i += 1) {
acc = f(acc, this.arr[i]);
}
return acc;
};
Reducible.prototype[symIterator] = function() {
var a = this.arr;
return {
_pos: 0,
next: function() {
if (this._pos < a.length) {
var v = a[this._pos];
this._pos += 1;
return {
value: v,
done: false
};
} else {
return {
done: true
};
}
}
};
};
var xf = R.take(2);
var apendingT = { };
apendingT['@@transducer/result'] = R.identity;
apendingT['@@transducer/step'] = R.flip(R.append);
var rfn = xf(apendingT);
var list = new Reducible([1, 2, 3, 4, 5, 6]);
eq(R.reduce(rfn, [], list), [1, 2]);
});
it('short circuits with reduced', function() {
var addWithMaxOf10 = function(acc, val) {return acc + val > 10 ? R.reduced(acc) : acc + val;};
eq(R.reduce(addWithMaxOf10, 0, [1, 2, 3, 4]), 10);
eq(R.reduce(addWithMaxOf10, 0, [2, 4, 6, 8]), 6);
});
});
reject<T>(predicate: Predicate<T>, list: readonly T[]): readonly T[]
It has the opposite effect of R.filter.
const list = [1, 2, 3, 4]
const obj = {a: 1, b: 2}
const predicate = x => x > 1
const result = [
R.reject(predicate, list)
R.reject(predicate, obj)
]
// => [[1, 2], {a: 1}]
Try this R.reject example in Rambda REPL
reject<T>(predicate: Predicate<T>, list: readonly T[]): readonly T[];
reject<T>(predicate: Predicate<T>): (list: readonly T[]) => readonly 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,
})
})
:boom: Reason for the failure: Ramda method dispatches to
filtermethod
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('reject', function() {
var even = function(x) {return x % 2 === 0;};
it('dispatches to `filter` method', function() {
function Nothing() {}
Nothing.value = new Nothing();
Nothing.prototype.filter = function() {
return this;
};
function Just(x) { this.value = x; }
Just.prototype.filter = function(pred) {
return pred(this.value) ? this : Nothing.value;
};
var m = new Just(42);
eq(R.filter(R.T, m), m);
eq(R.filter(R.F, m), Nothing.value);
eq(R.reject(R.T, m), Nothing.value);
eq(R.reject(R.F, m), m);
});
});
repeat<T>(x: T): (timesToRepeat: number) => readonly T[]
R.repeat('foo', 3)
// => ['foo', 'foo', 'foo']
Try this R.repeat example in Rambda REPL
repeat<T>(x: T): (timesToRepeat: number) => readonly T[];
repeat<T>(x: T, timesToRepeat: number): readonly 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()
})
replace(strOrRegex: RegExp | string, replacer: string, str: string): string
It replaces strOrRegex found in str with replacer.
const strOrRegex = /o/g
const result = R.replace(strOrRegex, '|0|', 'foo')
// => 'f|0||0|'
Try this R.replace example in Rambda REPL
replace(strOrRegex: RegExp | string, replacer: string, str: string): string;
replace(strOrRegex: RegExp | string, replacer: string): (str: string) => string;
replace(strOrRegex: RegExp | string): (replacer: string) => (str: string) => string;
import { 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')
})
reverse<T>(input: readonly T[]): readonly T[]
It returns a reversed copy of list or string input.
const result = [
R.reverse('foo'),
R.reverse([1, 2, 3])
]
// => ['oof', [3, 2, 1]
Try this R.reverse example in Rambda REPL
reverse<T>(input: readonly T[]): readonly 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 ])
})
set<T, U>(lens: Lens, replacer: U, obj: T): T
It returns a copied Object or Array with modified lens focus set to replacer value.
const input = {x: 1, y: 2}
const xLens = R.lensProp('x')
R.set(xLens, 4, input) // => {x: 4, y: 2}
R.set(xLens, 8, input) // => {x: 8, y: 2}
Try this R.set example in Rambda REPL
set<T, U>(lens: Lens, replacer: U, obj: T): T;
set<U>(lens: Lens, replacer: U): <T>(obj: T) => T;
set(lens: Lens): <T, U>(replacer: U, obj: T) => T;
import { 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 ])
})
slice(from: number, to: number, input: string): string
const list = [0, 1, 2, 3, 4, 5]
const str = 'FOO_BAR'
const from = 1
const to = 4
const result = [
R.slice(str, to, list),
R.slice(from, to, list)
]
// => ['OO_', [1, 2, 3]]
Try this R.slice example in Rambda REPL
slice(from: number, to: number, input: string): string;
slice<T>(from: number, to: number, input: readonly T[]): readonly T[];
slice(from: number, to: number): {
(input: string): string;
<T>(input: readonly T[]): readonly T[];
};
slice(from: number): {
(to: number, input: string): string;
<T>(to: number, input: readonly T[]): readonly 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')
})
sort<T>(sortFn: (a: T, b: T) => number, list: readonly T[]): readonly T[]
It returns copy of list sorted by sortFn function.
:boom:
sortFnfunction must return a number.
const list = [
{a: 2},
{a: 3},
{a: 1}
]
const sortFn = (x, y) => {
return x.a > y.a ? 1 : -1
}
const result = R.sort(sortFn, list)
const expected = [
{a: 1},
{a: 2},
{a: 3}
]
// => `result` is equal to `expected`
Try this R.sort example in Rambda REPL
sort<T>(sortFn: (a: T, b: T) => number, list: readonly T[]): readonly T[];
sort<T>(sortFn: (a: T, b: T) => number): (list: readonly T[]) => readonly T[];
export function sort(sortFn, list){
if (arguments.length === 1) return _list => sort(sortFn, _list)
const clone = list.slice()
return clone.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')
})
sortBy<T>(sortFn: (a: T) => Ord, list: readonly T[]): readonly T[]
It returns copy of list sorted by sortFn function.
:boom:
sortFnfunction must return a value to compare.
const list = [
{a: 2},
{a: 3},
{a: 1}
]
const sortFn = x => x.a
const result = R.sortBy(sortFn, list)
const expected = [
{a: 1},
{a: 2},
{a: 3}
]
// => `result` is equal to `expected`
Try this R.sortBy example in Rambda REPL
sortBy<T>(sortFn: (a: T) => Ord, list: readonly T[]): readonly T[];
sortBy(sortFn: (a: any) => Ord): <T>(list: readonly T[]) => readonly T[];
export function sortBy(sortFn, list){
if (arguments.length === 1) return _list => sortBy(sortFn, _list)
const clone = list.slice()
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 ])
})
:boom: Reason for the failure: Ramda method works with array-like objects
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
var albums = [
{title: 'Art of the Fugue', artist: 'Glenn Gould', genre: 'Baroque'},
{title: 'A Farewell to Kings', artist: 'Rush', genre: 'Rock'},
{title: 'Timeout', artist: 'Dave Brubeck Quartet', genre: 'Jazz'},
{title: 'Fly By Night', artist: 'Rush', genre: 'Rock'},
{title: 'Goldberg Variations', artist: 'Daniel Barenboim', genre: 'Baroque'},
{title: 'New World Symphony', artist: 'Leonard Bernstein', genre: 'Romantic'},
{title: 'Romance with the Unseen', artist: 'Don Byron', genre: 'Jazz'},
{title: 'Somewhere In Time', artist: 'Iron Maiden', genre: 'Metal'},
{title: 'In Times of Desparation', artist: 'Danny Holt', genre: 'Modern'},
{title: 'Evita', artist: 'Various', genre: 'Broadway'},
{title: 'Five Leaves Left', artist: 'Nick Drake', genre: 'Folk'},
{title: 'The Magic Flute', artist: 'John Eliot Gardiner', genre: 'Classical'}
];
describe('sortBy', function() {
it('sorts array-like object', function() {
var args = (function() { return arguments; }('c', 'a', 'b'));
var result = R.sortBy(R.identity, args);
eq(result[0], 'a');
eq(result[1], 'b');
eq(result[2], 'c');
});
});
split(separator: string | RegExp): (str: string) => readonly string[]
Curried version of String.prototype.split
const str = 'foo|bar|baz'
const separator = |'
const result = R.split(separator, str))
// => [ 'foo', 'bar', 'baz' ]
Try this R.split example in Rambda REPL
split(separator: string | RegExp): (str: string) => readonly string[];
split(separator: string | RegExp, str: string): readonly 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)
})
splitAt<T>(index: number, input: readonly T[]): readonly [readonly T[], readonly T[]]
It splits string or array at a given index.
const list = [ 1, 2, 3 ]
const result = splitAt(2, list)
// => [[ 1, 2 ], [ 3 ]]
Try this R.splitAt example in Rambda REPL
splitAt<T>(index: number, input: readonly T[]): readonly [readonly T[], readonly T[]];
splitAt(index: number, input: string): readonly [string, string];
splitAt(index: number): {
<T>(input: readonly T[]): readonly [readonly T[], readonly T[]];
(input: string): readonly [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 property 'slice' of ${ badInput }`)
})
badInputs.forEach(badInput => {
const result = splitAt(1, badInput)
const ramdaResult = splitAtRamda(1, badInput)
expect(result).toEqual(ramdaResult)
})
})
splitEvery<T>(sliceLength: number, input: readonly T[]): readonly (readonly T[])[]
It splits input into slices of sliceLength.
const result = [
R.splitEvery(2, [1, 2, 3]),
R.splitEvery(3, 'foobar')
]
const expected = [
[[1, 2], [3]],
['foo', 'bar']
]
// => `result` is equal to `expected`
Try this R.splitEvery example in Rambda REPL
splitEvery<T>(sliceLength: number, input: readonly T[]): readonly (readonly T[])[];
splitEvery(sliceLength: number, input: string): readonly string[];
splitEvery(sliceLength: number): {
(input: string): readonly string[];
<T>(input: readonly T[]): readonly (readonly 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')
})
splitWhen<T, U>(predicate: Predicate<T>, list: readonly U[]): readonly (readonly U[])[]
It splits list to two arrays according to a predicate function.
The first array contains all members of list before predicate returns true.
const list = [1, 2, 1, 2]
const result = R.splitWhen(R.equals(2), list)
// => [[1], [2, 1, 2]]
Try this R.splitWhen example in Rambda REPL
splitWhen<T, U>(predicate: Predicate<T>, list: readonly U[]): readonly (readonly U[])[];
splitWhen<T>(predicate: Predicate<T>): <U>(list: readonly U[]) => readonly (readonly 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 property 'length' of ${ badInput }`)
})
badInputs.forEach(badInput => {
const result = splitWhen(equals(2), badInput)
const ramdaResult = splitWhenRamda(equals(2), badInput)
expect(result).toEqual(ramdaResult)
})
})
startsWith(target: string, str: string): boolean
Curried version of String.prototype.startsWith
:boom: It doesn't work with arrays unlike its corresponding Ramda method.
const str = 'foo-bar'
const result = [
R.startsWith('foo', str),
R.startsWith('bar', str)
]
// => [true, false]
Try this R.startsWith example in Rambda REPL
startsWith(target: string, str: string): boolean;
startsWith(target: string): (str: string) => boolean;
export function startsWith(target, str){
if (arguments.length === 1) return _str => startsWith(target, _str)
return str.startsWith(target)
}
import { startsWith } from './startsWith'
test('true', () => {
const result = startsWith('foo', 'foo-bar')
expect(result).toBeTrue()
})
test('false', () => {
const result = startsWith('baz')('foo-bar')
expect(result).toBeFalse()
})
:boom: Reason for the failure: Rambda method doesn't support arrays
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('startsWith', function() {
it('should return true when an array starts with the provided value', function() {
eq(R.startsWith(['a'], ['a', 'b', 'c']), true);
});
it('should return true when an array starts with the provided values', function() {
eq(R.startsWith(['a', 'b'], ['a', 'b', 'c']), true);
});
it('should return false when an array does not start with the provided value', function() {
eq(R.startsWith(['b'], ['a', 'b', 'c']), false);
});
it('should return false when an array does not start with the provided values', function() {
eq(R.startsWith(['b', 'c'], ['a', 'b', 'c']), false);
});
});
subtract(x: number, y: number): number
Curried version of x - y
const x = 3
const y = 1
R.subtract(x, y)
// => 2
Try this R.subtract example in Rambda REPL
subtract(x: number, y: number): number;
subtract(x: number): (y: number) => number;
export function subtract(a, b){
if (arguments.length === 1) return _b => subtract(a, _b)
return a - b
}
import { subtract } from './subtract'
test('happy', () => {
expect(subtract(2, 1)).toEqual(1)
expect(subtract(2)(1)).toEqual(1)
})
sum(list: readonly number[]): number
R.sum([1, 2, 3, 4, 5])
// => 15
Try this R.sum example in Rambda REPL
sum(list: readonly number[]): number;
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: readonly T[], y: readonly T[]): readonly T[]
It returns a merged list of x and y with all equal elements removed.
R.equals is used to determine equality.
const x = [ 1, 2, 3, 4 ]
const y = [ 3, 4, 5, 6 ]
const result = symmetricDifference(x, y)
// => [ 1, 2, 5, 6 ]
Try this R.symmetricDifference example in Rambda REPL
symmetricDifference<T>(x: readonly T[], y: readonly T[]): readonly T[];
symmetricDifference<T>(x: readonly T[]): <T>(y: readonly T[]) => readonly 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 },
])
})
T(): boolean
R.T()
// => true
Try this R.T example in Rambda REPL
T(): boolean;
export function T(){
return true
}
tail<T>(input: readonly T[]): readonly T[]
It returns all but the first element of input.
const result = [
R.tail([1, 2, 3]),
R.tail('foo')
]
// => [[2, 3], 'oo']
Try this R.tail example in Rambda REPL
tail<T>(input: readonly T[]): readonly 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('')
})
take<T>(howMany: number, input: readonly T[]): readonly T[]
It returns the first howMany elements of input.
const howMany = 2
const result = [
R.take(howMany, [1, 2, 3]),
R.take(howMany, 'foobar'),
]
// => [[1, 2], 'fo']
Try this R.take example in Rambda REPL
take<T>(howMany: number, input: readonly T[]): readonly T[];
take(howMany: number, input: string): string;
take<T>(howMany: number): {
<T>(input: readonly T[]): readonly 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([])
})
:boom: Reason for the failure: Rambda library doesn't have 'R.into` method
var assert = require('assert');
var sinon = require('sinon');
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('take', function() {
it('handles zero correctly (#1224)', function() {
eq(R.into([], R.take(0), [1, 2, 3]), []);
});
it('steps correct number of times', function() {
var spy = sinon.spy();
R.into([], R.compose(R.map(spy), R.take(2)), [1, 2, 3]);
sinon.assert.calledTwice(spy);
});
it('transducer called for every member of list if `n` is < 0', function() {
var spy = sinon.spy();
R.into([], R.compose(R.map(spy), R.take(-1)), [1, 2, 3]);
sinon.assert.calledThrice(spy);
});
});
takeLast<T>(howMany: number, input: readonly T[]): readonly T[]
It returns the last howMany elements of input.
const howMany = 2
const result = [
R.takeLast(howMany, [1, 2, 3]),
R.takeLast(howMany, 'foobar'),
]
// => [[2, 3], 'ar']
Try this R.takeLast example in Rambda REPL
takeLast<T>(howMany: number, input: readonly T[]): readonly T[];
takeLast(howMany: number, input: string): string;
takeLast<T>(howMany: number): {
<T>(input: readonly T[]): readonly 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 ])
})
takeLastWhile(predicate: (x: string) => boolean, input: string): string
const result = R.takeLastWhile(
x => x > 2,
[1, 2, 3, 4]
)
// => [3, 4]
Try this R.takeLastWhile example in Rambda REPL
takeLastWhile(predicate: (x: string) => boolean, input: string): string;
takeLastWhile(predicate: (x: string) => boolean): (input: string) => string;
takeLastWhile<T>(predicate: (x: T) => boolean, input: readonly T[]): readonly T[];
takeLastWhile<T>(predicate: (x: T) => boolean): <T>(input: readonly T[]) => readonly 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')
})
takeWhile(fn: Predicate<string>, iterable: string): string
const list = [1, 2, 3, 4]
const predicate = x => x < 3
const result = R.takeWhile(predicate, list)
// => [1, 2]
Try this R.takeWhile example in Rambda REPL
takeWhile(fn: Predicate<string>, iterable: string): string;
takeWhile(fn: Predicate<string>): (iterable: string) => string;
takeWhile<T>(fn: Predicate<T>, iterable: readonly T[]): readonly T[];
takeWhile<T>(fn: Predicate<T>): (iterable: readonly T[]) => readonly T[];
import { _isArray } from '../src/_internals/_isArray'
export function takeWhile(predicate, iterable){
if (arguments.length === 1){
return _iterable => takeWhile(predicate, _iterable)
}
const isArray = _isArray(iterable)
if (!isArray && typeof iterable !== 'string'){
throw new Error('`iterable` is neither list nor a string')
}
let flag = true
const holder = []
let counter = -1
while (counter++ < iterable.length - 1){
if (!predicate(iterable[ counter ])){
if (flag) flag = false
} else if (flag){
holder.push(iterable[ counter ])
}
}
holder
return isArray ? holder : holder.join('')
}
import { takeWhile as takeWhileRamda } from 'ramda'
import { compareCombinations } from './_internals/testUtils'
import { takeWhile } from './takeWhile'
const list = [ 1, 2, 3, 4, 5 ]
test('happy', () => {
const result = takeWhile(x => x < 3, list)
expect(result).toEqual([ 1, 2 ])
})
test('always true', () => {
const result = takeWhile(x => true)(list)
expect(result).toEqual(list)
})
test('always false', () => {
const result = takeWhile(x => 0, list)
expect(result).toEqual([])
})
test('with string', () => {
const result = takeWhile(x => x !== 'b', 'foobar')
expect(result).toBe('foo')
})
const possiblePredicates = [
null,
undefined,
() => 0,
() => true,
x => x !== 'b',
/foo/g,
{},
[],
]
const possibleIterables = [
null,
undefined,
[],
{},
1,
'',
'foobar',
[ '' ],
[ 1, 2, 3, 4, 5 ],
]
describe('brute force', () => {
compareCombinations({
firstInput : possiblePredicates,
callback : errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 15,
"ERRORS_TYPE_MISMATCH": 16,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 16,
"SHOULD_THROW": 0,
}
`)
},
secondInput : possibleIterables,
fn : takeWhile,
fnRamda : takeWhileRamda,
})
})
2 failed Ramda.takeWhile specs
:boom: Reason for the failure: Ramda method works with strings not only arrays
tap<T>(fn: (x: T) => void, input: T): T
It applies function fn to input x and returns x.
One use case is debuging in the middle of R.compose.
const list = [1, 2, 3]
R.compose(
R.map(x => x * 2)
R.tap(console.log),
R.filter(x => x > 1)
)(list)
// => `2` and `3` will be logged
Try this R.tap example in Rambda REPL
tap<T>(fn: (x: T) => void, input: T): T;
tap<T>(fn: (x: T) => void): (input: T) => T;
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)
})
:boom: Reason for the failure: Ramda method can act as a transducer
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
var listXf = require('./helpers/listXf');
var _curry2 = require('rambda/internal/_curry2');
describe('tap', function() {
var pushToList = _curry2(function(lst, x) { lst.push(x); });
it('can act as a transducer', function() {
var sideEffect = [];
var numbers = [1,2,3,4,5];
var xf = R.compose(R.map(R.identity), R.tap(pushToList(sideEffect)));
eq(R.into([], xf, numbers), numbers);
eq(sideEffect, numbers);
});
it('dispatches to transformer objects', function() {
var sideEffect = [];
var pushToSideEffect = pushToList(sideEffect);
eq(R.tap(pushToSideEffect, listXf), {
f: pushToSideEffect,
xf: listXf
});
});
});
test(regExpression: RegExp): (str: string) => boolean
It determines whether str matches regExpression.
R.test(/^f/, 'foo')
// => true
Try this R.test example in Rambda REPL
test(regExpression: RegExp): (str: string) => boolean;
test(regExpression: RegExp, str: string): boolean;
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"')
})
times<T>(fn: (i: number) => T, howMany: number): readonly T[]
It returns the result of applying function fn over members of range array.
The range array includes numbers between 0 and howMany(exclusive).
const fn = x => x * 2
const howMany = 5
R.times(fn, howMany)
// => [0, 2, 4, 6, 8]
Try this R.times example in Rambda REPL
times<T>(fn: (i: number) => T, howMany: number): readonly T[];
times<T>(fn: (i: number) => T): (howMany: number) => readonly 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 ])
})
toLower(str: string): string
R.toLower('FOO')
// => 'foo'
Try this R.toLower example in Rambda REPL
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<S>(obj: { readonly [k: string]: S } | { readonly [k: number]: S }): readonly (readonly [string, S])[]
It transforms an object to a list.
const list = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
const expected = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ] ]
const result = R.toPairs(list)
// => `result` is equal to `expected`
Try this R.toPairs example in Rambda REPL
toPairs<S>(obj: { readonly [k: string]: S } | { readonly [k: number]: S }): readonly (readonly [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)
})
toString<T>(x: T): string
R.toString([1, 2])
// => '1,2'
Try this R.toString example in Rambda REPL
toString<T>(x: T): string;
export function toString(x){
return x.toString()
}
import { toString } from './toString'
test('happy', () => {
expect(toString([ 1, 2, 3 ])).toEqual('1,2,3')
})
toUpper(str: string): string
R.toUpper('foo')
// => 'FOO'
Try this R.toUpper example in Rambda REPL
toUpper(str: string): string;
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: readonly (readonly T[])[]): readonly (readonly T[])[]
const list = [[10, 11], [20], [], [30, 31, 32]]
const expected = [[10, 20, 30], [11, 31], [32]]
const result = R.transpose(list)
// => `result` is equal to `expected`
Try this R.transpose example in Rambda REPL
transpose<T>(list: readonly (readonly T[])[]): readonly (readonly 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)
})
trim(str: string): string
R.trim(' foo ')
// => 'foo'
Try this R.trim example in Rambda REPL
trim(str: string): string;
export function trim(str){
return str.trim()
}
import { trim } from './trim'
test('trim', () => {
expect(trim(' foo ')).toEqual('foo')
})
:boom: Reason for the failure: Ramda method trims all ES5 whitespace
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('trim', function() {
var test = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFFHello, World!\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
it('trims all ES5 whitespace', function() {
eq(R.trim(test), 'Hello, World!');
eq(R.trim(test).length, 13);
});
if (typeof String.prototype.trim !== 'function') {
it('falls back to a shim if String.prototype.trim is not present', function() {
eq(R.trim(' xyz '), 'xyz');
eq(R.trim(test), 'Hello, World!');
eq(R.trim(test).length, 13);
eq(R.trim('\u200b'), '\u200b');
eq(R.trim('\u200b').length, 1);
});
}
});
tryCatch<T, U>(
fn: (input: T) => U,
fallback: U
): (input: T) => U
It returns function that runs fn in try/catch block. If there was an error, then fallback is used to return the result. Note that fn can be value or asynchronous/synchronous function(unlike Ramda where fallback can only be a synchronous function).
:boom: Please check the tests of
R.tryCatchto fully understand how this method works.
const fn = x => x.foo
const result = [
R.tryCatch(fn, false)(null),
R.tryCatch(fn, false)({foo: 'bar'})
]
// => [false, 'bar']
Try this R.tryCatch example in Rambda REPL
tryCatch<T, U>(
fn: (input: T) => U,
fallback: U
): (input: T) => U;
tryCatch<T, U>(
fn: (input: T) => U,
fallback: (input: T) => U
): (input: T) => U;
tryCatch<T>(
fn: (input: any) => Promise<any>,
fallback: T
): (input: any) => Promise<T>;
tryCatch<T>(
fn: (input: any) => Promise<any>,
fallback: (input: any) => Promise<any>,
): (input: any) => Promise<T>;
import { isFunction } from './isFunction'
export function tryCatch(fn, fallback){
if (!isFunction(fn)){
throw new Error(`R.tryCatch | fn '${ fn }'`)
}
const passFallback = isFunction(fallback)
return (...inputs) => {
try {
return fn(...inputs)
} catch (e){
return passFallback ? fallback(e, ...inputs) : fallback
}
}
}
import { tryCatch as tryCatchRamda } from 'ramda'
import { compareCombinations } from './_internals/testUtils'
import { prop } from './prop'
import { tryCatch } from './tryCatch'
test('happy', () => {
const fn = () => {
throw new Error('foo')
}
const result = tryCatch(fn, () => true)()
expect(result).toBeTrue()
})
test('when fallback is used', () => {
const fn = x => x.x
expect(tryCatch(fn, false)(null)).toBeFalse()
})
test('with json parse', () => {
const good = () => JSON.parse(JSON.stringify({ a : 1 }))
const bad = () => JSON.parse('a{a')
expect(tryCatch(good, 1)()).toEqual({ a : 1 })
expect(tryCatch(bad, 1)()).toBe(1)
})
test('when fallback is function', () => {
const fn = x => x.x
expect(tryCatch(fn, () => 1)(null)).toBe(1)
})
test('when fn is used', () => {
const fn = prop('x')
expect(tryCatch(fn, false)({})).toBe(undefined)
expect(tryCatch(fn, false)({ x : 1 })).toBe(1)
})
test('fallback receives error object and all initial inputs', () => {
function thrower(
a, b, c
){
void c
throw new Error('throwerError')
}
function catchFn(
e, a, b, c
){
return [ e.message, a, b, c ].join('|')
}
const willThrow = tryCatch(thrower, catchFn)
const result = willThrow(
'A', 'B', 'C'
)
expect(result).toBe('throwerError|A|B|C')
})
test('fallback receives error object', () => {
function throwFn(){
throw new Error(10)
}
function eCatcher(
e, a, b
){
return e.message
}
const willThrow = tryCatch(throwFn, eCatcher)
expect(willThrow([])).toBe('10')
expect(willThrow([ {}, {}, {} ])).toBe('10')
})
const possibleFns = [
null,
() => 1,
() => 0,
() => JSON.parse('{a:1'),
() => {
const x = {}
return x.x
},
x => x.foo,
() => {
throw new Error('foo')
},
]
const possibleCatchers = [
null,
e => e.message.length,
(e, ...inputs) => `${ e.message.length } ${ inputs.length }`,
() => {
throw new Error('bar')
},
]
const possibleInputs = [ null, {}, { foo : 1 } ]
describe('brute force', () => {
compareCombinations({
returnsFunctionFlag : true,
firstInput : possibleFns,
callback : errorsCounters => {
expect(errorsCounters).toMatchInlineSnapshot(`
Object {
"ERRORS_MESSAGE_MISMATCH": 0,
"ERRORS_TYPE_MISMATCH": 12,
"RESULTS_MISMATCH": 0,
"SHOULD_NOT_THROW": 0,
"SHOULD_THROW": 7,
}
`)
},
secondInput : possibleCatchers,
thirdInput : possibleInputs,
fn : tryCatch,
fnRamda : tryCatchRamda,
})
})
1 failed Ramda.tryCatch specs
:boom: Reason for the failure: Ramda method returns a function with the same arity
type(x: any): RambdaTypes
It accepts any input and it returns its type.
:boom:
NaN,PromiseandAsyncare types specific for Rambda.
R.type(() => {}) // => 'Function'
R.type(async () => {}) // => 'Async'
R.type([]) // => 'Array'
R.type({}) // => 'Object'
R.type('foo') // => 'String'
R.type(1) // => 'Number'
R.type(true) // => 'Boolean'
R.type(null) // => 'Null'
R.type(/[A-z]/) // => 'RegExp'
R.type('foo'*1) // => 'NaN'
const delay = ms => new Promise(resolve => {
setTimeout(function () {
resolve()
}, ms)
})
R.type(delay) // => 'Promise'
Try this R.type example in Rambda REPL
type(x: any): RambdaTypes;
import { _isArray } from './_internals/_isArray'
export function type(input){
const typeOf = typeof input
if (input === null){
return 'Null'
} else if (input === undefined){
return 'Undefined'
} else if (typeOf === 'boolean'){
return 'Boolean'
} else if (typeOf === 'number'){
return Number.isNaN(input) ? 'NaN' : 'Number'
} else if (typeOf === 'string'){
return 'String'
} else if (_isArray(input)){
return 'Array'
} else if (typeOf === 'symbol'){
return 'Symbol'
} else if (input instanceof RegExp){
return 'RegExp'
}
const asStr = input && input.toString ? input.toString() : ''
if ([ 'true', 'false' ].includes(asStr)) return 'Boolean'
if (!Number.isNaN(Number(asStr))) return 'Number'
if (asStr.startsWith('async')) return 'Async'
if (asStr === '[object Promise]') return 'Promise'
if (typeOf === 'function') return 'Function'
if (input instanceof String) return 'String'
return 'Object'
}
import { type as ramdaType } from 'ramda'
import { type } from './type'
test('with symbol', () => {
expect(type(Symbol())).toBe('Symbol')
})
test('with simple promise', () => {
expect(type(Promise.resolve(1))).toBe('Promise')
})
test('with new Boolean', () => {
expect(type(new Boolean(true))).toBe('Boolean')
})
test('with new String', () => {
expect(type(new String('I am a String object'))).toEqual('String')
})
test('with new Number', () => {
expect(type(new Number(1))).toBe('Number')
})
test('with new promise', () => {
const delay = ms =>
new Promise(resolve => {
setTimeout(() => {
resolve(ms + 110)
}, ms)
})
expect(type(delay(10))).toEqual('Promise')
})
test('async function', () => {
expect(type(async () => {})).toEqual('Async')
})
test('async arrow', () => {
const asyncArrow = async () => {}
expect(type(asyncArrow)).toBe('Async')
})
test('function', () => {
const fn1 = () => {}
const fn2 = function (){}
function fn3(){}
;[ () => {}, fn1, fn2, fn3 ].map(val => {
expect(type(val)).toEqual('Function')
})
})
test('object', () => {
expect(type({})).toEqual('Object')
})
test('number', () => {
expect(type(1)).toEqual('Number')
})
test('boolean', () => {
expect(type(false)).toEqual('Boolean')
})
test('string', () => {
expect(type('foo')).toEqual('String')
})
test('null', () => {
expect(type(null)).toEqual('Null')
})
test('array', () => {
expect(type([])).toEqual('Array')
expect(type([ 1, 2, 3 ])).toEqual('Array')
})
test('regex', () => {
expect(type(/\s/g)).toEqual('RegExp')
})
test('undefined', () => {
expect(type(undefined)).toEqual('Undefined')
})
test('not a number', () => {
expect(type(Number('s'))).toBe('NaN')
})
test('function inside object 1', () => {
const obj = {
f(){
return 4
},
}
expect(type(obj.f)).toBe('Function')
expect(ramdaType(obj.f)).toBe('Function')
})
test('function inside object 2', () => {
const name = 'f'
const obj = {
[ name ](){
return 4
},
}
expect(type(obj.f)).toBe('Function')
expect(ramdaType(obj.f)).toBe('Function')
})
:boom: Reason for the failure: Ramda method returns 'Number' type to NaN input, while Rambda method returns 'NaN'
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('type', function() {
// it('"Arguments" if given an arguments object', function() {
// var args = (function() { return arguments; }());
// eq(R.type(args), 'Arguments');
// });
it('"Number" if given the NaN value', function() {
eq(R.type(NaN), 'Number');
});
});
union<T>(x: readonly T[], y: readonly T[]): readonly 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.
const result = R.union([1,2,3], [3,4,5]);
// => [1, 2, 3, 4, 5]
Try this R.union example in Rambda REPL
union<T>(x: readonly T[], y: readonly T[]): readonly T[];
union<T>(x: readonly T[]): (y: readonly T[]) => readonly T[];
import { includes } from './includes'
export function union(x, y){
if (arguments.length === 1) return _y => union(x, _y)
const toReturn = x.slice()
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)
})
1 failed Ramda.union specs
:boom: Reason for the failure: Ramda library supports fantasy-land
uniq<T>(list: readonly T[]): readonly T[]
It returns a new array containing only one copy of each element of list.
R.equals is used to determine equality.
const list = [1, 1, {a: 1}, {a: 2}, {a:1}]
R.uniq(list)
// => [1, {a: 1}, {a: 2}]
Try this R.uniq example in Rambda REPL
uniq<T>(list: readonly T[]): readonly T[];
import { includes } from './includes'
export function uniq(list){
let index = -1
const willReturn = []
while (++index < list.length){
const value = list[ index ]
if (!includes(value, willReturn)){
willReturn.push(value)
}
}
return willReturn
}
import { uniq } from './uniq'
test('uniq', () => {
expect(uniq([ 1, 2, 3, 3, 3, 1, 2, 0 ])).toEqual([ 1, 2, 3, 0 ])
expect(uniq([ 1, 1, 2, 1 ])).toEqual([ 1, 2 ])
expect([ 1, '1' ]).toEqual([ 1, '1' ])
expect(uniq([ [ 42 ], [ 42 ] ])).toEqual([ [ 42 ] ])
})
:boom: Reason for the failure: Ramda method pass to
uniqmethod | Ramda method uses reference equality for functions
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('uniq', function() {
it('has R.equals semantics', function() {
function Just(x) { this.value = x; }
Just.prototype.equals = function(x) {
return x instanceof Just && R.equals(x.value, this.value);
};
eq(R.uniq([-0, -0]).length, 1);
eq(R.uniq([0, -0]).length, 2);
eq(R.uniq([NaN, NaN]).length, 1);
eq(R.uniq([[1], [1]]).length, 1);
eq(R.uniq([new Just([42]), new Just([42])]).length, 1);
it('handles null and undefined elements', function() {
eq(R.uniq([void 0, null, void 0, null]), [void 0, null]);
it('uses reference equality for functions', function() {
eq(R.uniq([R.add, R.identity, R.add, R.identity, R.add, R.identity]).length, 2);
});
uniqWith<T, U>(predicate: (x: T, y: T) => boolean, list: readonly T[]): readonly 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.
const list = [
{id: 0, title:'foo'},
{id: 1, title:'bar'},
{id: 2, title:'baz'},
{id: 3, title:'foo'},
{id: 4, title:'bar'},
]
const expected = [
{id: 0, title:'foo'},
{id: 1, title:'bar'},
{id: 2, title:'baz'},
]
const predicate = (x,y) => x.title === y.title
const result = R.uniqWith(predicate, list)
// => `result` is equal to `expected`
Try this R.uniqWith example in Rambda REPL
uniqWith<T, U>(predicate: (x: T, y: T) => boolean, list: readonly T[]): readonly T[];
uniqWith<T, U>(predicate: (x: T, y: T) => boolean): (list: readonly T[]) => readonly T[];
import { any } from './any'
export function uniqWith(predicate, list){
if (arguments.length === 1) return _list => uniqWith(predicate, _list)
let index = -1
const len = list.length
const willReturn = []
while (++index < len){
const value = list[ index ]
const flag = any(willReturnInstance => predicate(value, willReturnInstance),
willReturn)
if (!flag){
willReturn.push(value)
}
}
return willReturn
}
import { uniqWith } from './uniqWith'
test('happy', () => {
const input = [
{
id : 0,
title : 'foo',
},
{
id : 1,
title : 'bar',
},
{
id : 2,
title : 'baz',
},
{
id : 3,
title : 'foo',
},
{
id : 4,
title : 'bar',
},
]
const expectedResult = [
{
id : 0,
title : 'foo',
},
{
id : 1,
title : 'bar',
},
{
id : 2,
title : 'baz',
},
]
const fn = (x, y) => x.title === y.title
const result = uniqWith(fn, input)
const curriedResult = uniqWith(fn)(input)
expect(result).toEqual(expectedResult)
expect(curriedResult).toEqual(expectedResult)
})
test('uniqWith', () => {
const input = [
{
id : 0,
title : 'foo',
},
{
id : 1,
title : 'bar',
},
{
id : 2,
title : 'baz',
},
{
id : 3,
title : 'foo',
},
{
id : 4,
title : 'bar',
},
]
const expectedResult = [
{
id : 0,
title : 'foo',
},
{
id : 1,
title : 'bar',
},
{
id : 2,
title : 'baz',
},
]
const fn = (x, y) => x.title === y.title
const result = uniqWith(fn, input)
//const result = uniqWith(Ramda.eqBy(Ramda.prop('title')), input)
expect(result).toEqual(expectedResult)
})
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, obj: T): U
The method returns function that will be called with argument input.
If predicate(input) returns false, then the end result will be the outcome of whenFalse(input).
In the other case, the final output will be the input itself.
const fn = R.unless(
x => x > 2,
x => x + 10
)
const result = [
fn(1),
fn(5)
]
// => [11, 5]
Try this R.unless example in Rambda REPL
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, obj: T): U;
unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U): (obj: T) => U;
export function unless(predicate, whenFalse){
if (arguments.length === 1){
return _whenFalse => unless(predicate, _whenFalse)
}
return input => {
if (predicate(input)) return input
return whenFalse(input)
}
}
import { inc } from './inc'
import { isNil } from './isNil'
import { unless } from './unless'
const safeInc = unless(isNil, inc)
test('happy', () => {
expect(safeInc(null)).toBeNull()
expect(safeInc(1)).toBe(2)
})
test('curried', () => {
const safeIncCurried = unless(isNil)(inc)
expect(safeIncCurried(null)).toBeNull()
expect(safeIncCurried(1)).toBe(2)
})
4 failed Ramda.unless specs
:boom: Reason for the failure: Rambda library doesn't have
R.of
update<T>(index: number, newValue: T, list: readonly T[]): readonly T[]
It returns a copy of list with updated element at index with newValue.
const index = 2
const newValue = 88
const list = [1, 2, 3, 4, 5]
const result = R.update(index, newValue, list)
// => [1, 2, 88, 4, 5]
Try this R.update example in Rambda REPL
update<T>(index: number, newValue: T, list: readonly T[]): readonly T[];
update<T>(index: number, newValue: T): (list: readonly T[]) => readonly T[];
import { curry } from './curry'
function updateFn(
index, newValue, list
){
const arrClone = list.slice()
return arrClone.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)
})
:boom: Reason for the failure: Ramda method accepts an array-like object
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('update', function() {
it('accepts an array-like object', function() {
function args() {
return arguments;
}
eq(R.update(2, 4, args(0, 1, 2, 3)), [0, 1, 4, 3]);
});
});
values<T extends object, K extends keyof T>(obj: T): readonly T[K][]
With correct input, this is nothing more than Object.values(obj). If obj is not an object, then it returns an empty array.
const obj = {a:1, b:2}
R.values(obj)
// => [1, 2]
Try this R.values example in Rambda REPL
values<T extends object, K extends keyof T>(obj: T): readonly 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([])
})
view<T, U>(lens: Lens): (target: T) => U
It returns the value of lens focus over target object.
const lens = R.lensProp('x')
R.view(lens, {x: 1, y: 2}) // => 1
R.view(lens, {x: 4, y: 2}) // => 4
Try this R.view example in Rambda REPL
view<T, U>(lens: Lens): (target: T) => U;
view<T, U>(lens: Lens, target: T): U;
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')
})
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): FunctionToolbelt.Curry<(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')
})
where<T, U>(conditions: T, input: U): boolean
It returns true if all each property in conditions returns true when applied to corresponding property in input object.
const condition = R.where({
a : x => typeof x === "string",
b : x => x === 4
})
const input = {
a : "foo",
b : 4,
c : 11,
}
const result = condition(input)
// => true
Try this R.where example in Rambda REPL
where<T, U>(conditions: T, input: U): boolean;
where<T>(conditions: T): <U>(input: U) => boolean;
where<ObjFunc2, U>(conditions: ObjFunc2, input: U): boolean;
where<ObjFunc2>(conditions: ObjFunc2): <U>(input: U) => boolean;
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)
})
2 failed Ramda.where specs
:boom: Reason for the failure: Ramba method looks inside
prototypeproperty
whereEq<T, U>(condition: T, input: U): boolean
It will return true if all of input object fully or partially include rule object.
const condition = { a : { b : 1 } }
const input = {
a : { b : 1 },
c : 2
}
const result = whereEq(condition, input)
// => true
Try this R.whereEq example in Rambda REPL
whereEq<T, U>(condition: T, input: U): boolean;
whereEq<T>(condition: T): <U>(input: U) => boolean;
import { 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 property \'a\' of null')
})
2 failed Ramda.whereEq specs
:boom: Reason for the failure: Ramba method looks inside
prototypeproperty | Rambda.equals doesn't support equality of functions
without<T>(matchAgainst: readonly T[], source: readonly T[]): readonly 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.
const source = [1, 2, 3, 4]
const matchAgainst = [2, 3]
const result = R.without(matchAgainst, source)
// => [1, 4]
Try this R.without example in Rambda REPL
without<T>(matchAgainst: readonly T[], source: readonly T[]): readonly T[];
without<T>(matchAgainst: readonly T[]): (source: readonly T[]) => readonly T[];
import { includes } from './includes'
import { reduce } from './reduce'
export function without(matchAgainst, source){
if (source === undefined){
return _source => without(matchAgainst, _source)
}
return reduce(
(prev, current) =>
includes(current, matchAgainst) ? prev : prev.concat(current),
[],
source
)
}
import { without } from './without'
test('should return a new list without values in the first argument ', () => {
const itemsToOmit = [ 'A', 'B', 'C' ]
const collection = [ 'A', 'B', 'C', 'D', 'E', 'F' ]
expect(without(itemsToOmit, collection)).toEqual([ 'D', 'E', 'F' ])
expect(without(itemsToOmit)(collection)).toEqual([ 'D', 'E', 'F' ])
})
test('ramda test', () => {
expect(without([ 1, 2 ])([ 1, 2, 1, 3, 4 ])).toEqual([ 3, 4 ])
})
:boom: Reason for the failure: Ramda method act as a transducer | Ramda method pass to
equalsmethod
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('without', function() {
it('can act as a transducer', function() {
eq(R.into([], R.without([1]), [1]), []);
});
it('has R.equals semantics', function() {
function Just(x) { this.value = x; }
Just.prototype.equals = function(x) {
return x instanceof Just && R.equals(x.value, this.value);
};
eq(R.without([0], [-0]).length, 1);
eq(R.without([-0], [0]).length, 1);
eq(R.without([NaN], [NaN]).length, 0);
eq(R.without([[1]], [[1]]).length, 0);
eq(R.without([new Just([42])], [new Just([42])]).length, 0);
});
});
xor(x: boolean, y: boolean): boolean
Logical XOR
const result = [
xor(true, true),
xor(false, false),
xor(false, true),
]
// => [false, false, true]
Try this R.xor example in Rambda REPL
xor(x: boolean, y: boolean): boolean;
xor(y: boolean): (y: boolean) => boolean;
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)
})
:boom: Reason for the failure: Ramda method support empty call of method
var R = require('../../../../dist/rambda.js');
var eq = require('./shared/eq');
describe('xor', function() {
it('returns a curried function', function() {
eq(R.xor()(true)(true), false);
eq(R.xor()(true)(false), true);
eq(R.xor()(false)(true), true);
eq(R.xor()(false)(false), false);
});
});
zip<K, V>(x: readonly K[], y: readonly V[]): readonly KeyValuePair<K, V>[]
It will return a new array containing tuples of equally positions items from both x and y lists.
The returned list will be truncated to match the length of the shortest supplied list.
const x = [1, 2]
const y = ['A', 'B']
R.zip(x, y)
// => [[1, 'A'], [2, 'B']]
// truncates to shortest list
R.zip([...x, 3], ['A', 'B'])
// => [[1, 'A'], [2, 'B']]
Try this R.zip example in Rambda REPL
zip<K, V>(x: readonly K[], y: readonly V[]): readonly KeyValuePair<K, V>[];
zip<K>(x: readonly K[]): <V>(y: readonly V[]) => readonly 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)
})
zipObj<T, K extends string>(keys: readonly K[], values: readonly T[]): { readonly [P in K]: T }
It will return a new object with keys of keys array and values of values array.
const keys = ['a', 'b', 'c']
R.zipObj(keys, [1, 2, 3])
// => {a: 1, b: 2, c: 3}
// truncates to shortest list
R.zipObj(keys, [1, 2])
// => {a: 1, b: 2}
Try this R.zipObj example in Rambda REPL
zipObj<T, K extends string>(keys: readonly K[], values: readonly T[]): { readonly [P in K]: T };
zipObj<K extends string>(keys: readonly K[]): <T>(values: readonly T[]) => { readonly [P in K]: T };
zipObj<T, K extends number>(keys: readonly K[], values: readonly T[]): { readonly [P in K]: T };
zipObj<K extends number>(keys: readonly K[]): <T>(values: readonly T[]) => { readonly [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()
})
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): readonly TResult[]
const list1 = [ 10, 20, 30, 40 ]
const list2 = [ 100, 200 ]
const result = R.zipWith(
R.add, list1, list2
)
// => [110, 220]
Try this R.zipWith example in Rambda REPL
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): readonly TResult[];
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: readonly T[]): (list2: readonly U[]) => readonly TResult[];
zipWith<T, U, TResult>(fn: (x: T, y: U) => TResult): (list1: readonly T[], list2: readonly U[]) => readonly 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 ])
})
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
RubyGems.org has added a new "maintainer" role that allows for publishing new versions of gems. This new permission type is aimed at improving security for gem owners and the service overall.
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.