(property: P):
(propToFind: P, obj: T): T[P]
```
It returns the value of property `propToFind` in `obj`.
If there is no such property, it returns `undefined`.
```javascript
const result = [
R.prop('x', {x: 100}),
R.prop('x', {a: 1})
]
// => [100, undefined]
```
Try the above R.prop example in Rambda REPL
(propToFind: P, obj: T): T[P];
prop (p: P): (p: P): (propToFind: RecordAll Typescript definitions
```typescript
propR.prop source
```javascript
export function prop(propToFind, obj){
if (arguments.length === 1) return _obj => prop(propToFind, _obj)
if (!obj) return undefined
return obj[ propToFind ]
}
```
Tests
```javascript
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)
})
```
All Typescript definitions
```typescript
propEqR.propEq source
```javascript
import { curry } from './curry'
function propEqFn(
propToFind, valueToMatch, obj
){
if (!obj) return false
return obj[ propToFind ] === valueToMatch
}
export const propEq = curry(propEqFn)
```
Tests
```javascript
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()
})
```
1 failed
```javascript
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);
});
});
```
All Typescript definitions
```typescript
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;
};
```
R.propIs source
```javascript
import { curry } from './curry.js'
import { is } from './is'
function propIsFn(
targetPrototype, property, obj
){
return is(targetPrototype, obj[ property ])
}
export const propIs = curry(propIsFn)
```
Tests
```javascript
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()
})
```
Typescript test
```typescript
import {propIs} from 'rambda'
const property = 'a'
const obj = {a: 1}
describe('propIs', () => {
it('happy', () => {
const result = propIs(
Number, property, obj
)
result // $ExpectType boolean
})
it('curried', () => {
const result = propIs(Number, property)(obj)
result // $ExpectType boolean
})
})
```
All Typescript definitions
```typescript
propOrR.propOr source
```javascript
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)
```
Tests
```javascript
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')
})
```
All Typescript definitions
```typescript
range(start: number, end: number): number[];
range(start: number): (end: number) => number[];
```
R.range source
```javascript
export function range(start, end){
if (arguments.length === 1) return _end => range(start, _end)
if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){
throw new TypeError('Both arguments to range must be numbers')
}
if (end < start) return []
const len = end - start
const willReturn = Array(len)
for (let i = 0; i < len; i++){
willReturn[ i ] = start + i
}
return willReturn
}
```
Tests
```javascript
import { range } from './range'
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)).toThrow(throwMessage)
expect(() => range(6, 'z')).toThrow(throwMessage)
})
test('curry', () => {
expect(range(0)(10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ])
})
```
All Typescript definitions
```typescript
reduceR.reduce source
```javascript
import { curry } from './curry'
function reduceFn(
reducer, acc, list
){
const clone = list.slice()
return clone.reduce(reducer, acc)
}
export const reduce = curry(reduceFn)
```
Tests
```javascript
import { reduce } from './reduce'
test('happy', () => {
const reducer = (
prev, current, i
) => {
expect(i).toBeNumber()
return prev + current
}
const initialValue = 1
const list = [ 1, 2, 3 ]
expect(reduce(
reducer, initialValue, list
)).toEqual(7)
})
```
Typescript test
```typescript
import {reduce} from 'rambda'
describe('reduce', () => {
it('happy', () => {
const result = reduce2 failed
```javascript
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);
});
});
```
All Typescript definitions
```typescript
rejectR.reject source
```javascript
import { filter } from './filter'
export function reject(predicate, list){
if (arguments.length === 1) return _list => reject(predicate, _list)
return filter((x, i) => !predicate(x, i), list)
}
```
Tests
```javascript
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', () => {
expect(reject(isOdd, {
a : 1,
b : 2,
c : 3,
d : 4,
})).toEqual({
b : 2,
d : 4,
})
})
test('pass index as second argument', () => {
reject((x, i) => {
expect(typeof x).toBe('number')
expect(typeof i).toBe('number')
},
[ 10, 12, 15 ])
})
```
Typescript test
```typescript
import {reject} from 'rambda'
describe('reject with array', () => {
it('1 curry', () => {
const x = reject1 failed
```javascript
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);
});
});
```
All Typescript definitions
```typescript
repeatR.repeat source
```javascript
export function repeat(x, timesToRepeat){
if (arguments.length === 1){
return _timesToRepeat => repeat(x, _timesToRepeat)
}
return Array(timesToRepeat).fill(x)
}
```
Tests
```javascript
import { repeat } from './repeat'
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()
})
```
All Typescript definitions
```typescript
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;
```
R.replace source
```javascript
export function replace(
pattern, replacer, str
){
if (replacer === undefined){
return (_replacer, _str) => replace(
pattern, _replacer, _str
)
} else if (str === undefined){
return _str => replace(
pattern, replacer, _str
)
}
return str.replace(pattern, replacer)
}
```
Tests
```javascript
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')
})
```
All Typescript definitions
```typescript
reverseR.reverse source
```javascript
export function reverse(listOrString){
if (typeof listOrString === 'string'){
return listOrString.split('').reverse()
.join('')
}
const clone = listOrString.slice()
return clone.reverse()
}
```
Tests
```javascript
import { reverse } from './reverse'
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 ])
})
```
All Typescript definitions
```typescript
setR.set source
```javascript
import { always } from './always'
import { over } from './over'
export function set(
lens, replacer, x
){
if (arguments.length === 1) return (_v, _x) => set(
lens, _v, _x
)
if (arguments.length === 2) return _x => set(
lens, replacer, _x
)
return over(
lens, always(replacer), x
)
}
```
All Typescript definitions
```typescript
slice(from: number, to: number, list: string): string;
sliceR.slice source
```javascript
import { curry } from './curry'
function sliceFn(
from, to, list
){
return list.slice(from, to)
}
export const slice = curry(sliceFn)
```
Tests
```javascript
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')
})
```
All Typescript definitions
```typescript
sortR.sort source
```javascript
export function sort(sortFn, list){
if (arguments.length === 1) return _list => sort(sortFn, _list)
const clone = list.slice()
return clone.sort(sortFn)
}
```
Tests
```javascript
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')
})
```
All Typescript definitions
```typescript
sortByR.sortBy source
```javascript
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
})
}
```
Tests
```javascript
import { compose } from './compose'
import { prop } from './prop'
import { sortBy } from './sortBy'
import { toLower } from './toLower.js'
test('happy', () => {
const input = [ { a : 2 }, { a : 1 }, { a : 1 }, { a : 3 } ]
const expected = [ { a : 1 }, { a : 1 }, { a : 2 }, { a : 3 } ]
const result = sortBy(x => x.a)(input)
expect(result).toEqual(expected)
})
test('with compose', () => {
const alice = {
name : 'ALICE',
age : 101,
}
const bob = {
name : 'Bob',
age : -10,
}
const clara = {
name : 'clara',
age : 314.159,
}
const people = [ clara, bob, alice ]
const sortByNameCaseInsensitive = sortBy(compose(toLower, prop('name')))
expect(sortByNameCaseInsensitive(people)).toEqual([ alice, bob, clara ])
})
```
Typescript test
```typescript
import {sortBy} from 'rambda'
describe('sortBy', () => {
it('happy', () => {
interface Input {
a: number,
}
function fn(x: Input): number {
return x.a
}
const input: Input[] = [{a: 2}, {a: 1}, {a: 0}]
const result = sortBy(fn, input)
result // $ExpectType Input[]
result[0].a // $ExpectType number
})
})
```
1 failed
```javascript
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');
});
});
```
All Typescript definitions
```typescript
split(separator: string | RegExp): (str: string) => string[];
split(separator: string | RegExp, str: string): string[];
```
R.split source
```javascript
export function split(separator, str){
if (arguments.length === 1) return _str => split(separator, _str)
return str.split(separator)
}
```
Tests
```javascript
import { split } from './split'
test('split', () => {
expect(split('|')('foo|bar|baz')).toEqual([ 'foo', 'bar', 'baz' ])
expect(split('.', 'a.b.c.xyz.d')).toEqual([ 'a', 'b', 'c', 'xyz', 'd' ])
})
```
All Typescript definitions
```typescript
splitEveryR.splitEvery source
```javascript
export function splitEvery(sliceLength, listOrString){
if (arguments.length === 1){
return _listOrString => splitEvery(sliceLength, _listOrString)
}
if (sliceLength < 1){
throw new Error('First argument to splitEvery must be a positive integer')
}
const willReturn = []
let counter = 0
while (counter < listOrString.length){
willReturn.push(listOrString.slice(counter, counter += sliceLength))
}
return willReturn
}
```
Tests
```javascript
import { splitEvery } from './splitEvery'
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' ])).toThrow('First argument to splitEvery must be a positive integer')
})
```
All Typescript definitions
```typescript
startsWith(target: string, str: string): boolean;
startsWith(target: string): (str: string) => boolean;
```
R.startsWith source
```javascript
export function startsWith(target, str){
if (arguments.length === 1) return _str => startsWith(target, _str)
return str.startsWith(target)
}
```
Tests
```javascript
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()
})
```
4 failed
```javascript
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);
});
});
```
All Typescript definitions
```typescript
subtract(x: number, y: number): number;
subtract(x: number): (y: number) => number;
```
R.subtract source
```javascript
export function subtract(a, b){
if (arguments.length === 1) return _b => subtract(a, _b)
return a - b
}
```
Tests
```javascript
import { subtract } from './subtract'
test('happy', () => {
expect(subtract(2, 1)).toEqual(1)
expect(subtract(2)(1)).toEqual(1)
})
```
All Typescript definitions
```typescript
sum(list: ReadonlyArrayR.sum source
```javascript
export function sum(list){
return list.reduce((prev, current) => prev + current, 0)
}
```
Tests
```javascript
import { sum } from './sum'
test('happy', () => {
expect(sum([ 1, 2, 3, 4, 5 ])).toBe(15)
})
```
All Typescript definitions
```typescript
symmetricDifferenceR.symmetricDifference source
```javascript
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))
}
```
Tests
```javascript
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 },
])
})
```
All Typescript definitions
```typescript
T(): boolean;
```
R.T source
```javascript
export function T(){
return true
}
```
All Typescript definitions
```typescript
tailR.tail source
```javascript
import { drop } from './drop'
export function tail(listOrString){
return drop(1, listOrString)
}
```
Tests
```javascript
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('')
})
```
All Typescript definitions
```typescript
takeR.take source
```javascript
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
)
}
```
Tests
```javascript
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([])
})
```
3 failed
```javascript
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);
});
});
```
All Typescript definitions
```typescript
takeLastR.takeLast source
```javascript
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
)
}
```
Tests
```javascript
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 ])
})
```
All Typescript definitions
```typescript
tapR.tap source
```javascript
export function tap(fn, x){
if (arguments.length === 1) return _x => tap(fn, _x)
fn(x)
return x
}
```
Tests
```javascript
import { tap } from './tap'
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)
})
```
2 failed
```javascript
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
});
});
});
```
All Typescript definitions
```typescript
test(regExpression: RegExp): (str: string) => boolean;
test(regExpression: RegExp, str: string): boolean;
```
R.test source
```javascript
export function test(pattern, str){
if (arguments.length === 1) return _str => test(pattern, _str)
if (typeof pattern === 'string'){
throw new TypeError(`βtestβ requires a value of type RegExp as its first argument; received "${ pattern }"`)
}
return str.search(pattern) !== -1
}
```
Tests
```javascript
import { test as testMethod } from './test'
test('happy', () => {
expect(testMethod(/^x/, 'xyz')).toBeTrue()
expect(testMethod(/^y/)('xyz')).toBeFalse()
})
test('throws if first argument is not regex', () => {
expect(() => testMethod('foo', 'bar')).toThrow('βtestβ requires a value of type RegExp as its first argument; received "foo"')
})
```
All Typescript definitions
```typescript
timesR.times source
```javascript
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))
}
```
Tests
```javascript
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 ])
})
```
All Typescript definitions
```typescript
toLower(str: string): string;
```
R.toLower source
```javascript
export function toLower(str){
return str.toLowerCase()
}
```
Tests
```javascript
import { toLower } from './toLower'
test('toLower', () => {
expect(toLower('FOO|BAR|BAZ')).toEqual('foo|bar|baz')
})
```
(obj: { [k: string]: S } | { [k: number]: S }): [string, S][]
```
It transforms an object to a list.
```javascript
const list = {
a : 1,
b : 2,
c : [ 3, 4 ],
}
const expected = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ] ]
const result = R.toPairs(list)
// => `result` is equal to `expected`
```
Try the above R.toPairs example in Rambda REPL
All Typescript definitions
```typescript
toPairs(obj: { [k: string]: S } | { [k: number]: S }): [string, S][];
```
R.toPairs source
```javascript
export function toPairs(obj){
return Object.entries(obj)
}
```
Tests
```javascript
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)
})
```
All Typescript definitions
```typescript
toStringR.toString source
```javascript
export function toString(val){
return val.toString()
}
```
Tests
```javascript
import { toString } from './toString'
test('happy', () => {
expect(toString([ 1, 2, 3 ])).toEqual('1,2,3')
})
```
All Typescript definitions
```typescript
toUpper(str: string): string;
```
R.toUpper source
```javascript
export function toUpper(str){
return str.toUpperCase()
}
```
Tests
```javascript
import { toUpper } from './toUpper'
test('toUpper', () => {
expect(toUpper('foo|bar|baz')).toEqual('FOO|BAR|BAZ')
})
```
All Typescript definitions
```typescript
transposeR.transpose source
```javascript
export function transpose(array){
return array.reduce((acc, el) => {
el.forEach((nestedEl, i) =>
Array.isArray(acc[ i ]) ? acc[ i ].push(nestedEl) : acc.push([ nestedEl ]))
return acc
}, [])
}
```
Tests
```javascript
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)
})
```
All Typescript definitions
```typescript
trim(str: string): string;
```
R.trim source
```javascript
export function trim(str){
return str.trim()
}
```
Tests
```javascript
import { trim } from './trim'
test('trim', () => {
expect(trim(' foo ')).toEqual('foo')
})
```
1 failed
```javascript
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);
});
}
});
```
All Typescript definitions
```typescript
type(x: any): "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "Function" | "Undefined" | "Async" | "Promise" | "RegExp" | "NaN";
```
R.type source
```javascript
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 (Array.isArray(input)){
return 'Array'
} 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'
}
```
Tests
```javascript
import { type as ramdaType } from 'ramda'
import { type } from './type'
test('with simple promise', () => {
expect(type(Promise.resolve(1))).toBe('Promise')
})
test('with new Boolean', () => {
expect(type(new Boolean(true))).toBe('Boolean')
})
test('with new String', () => {
expect(type(new String('I am a String object'))).toEqual('String')
})
test('with new Number', () => {
expect(type(new Number(1))).toBe('Number')
})
test('with new promise', () => {
const delay = ms =>
new Promise(resolve => {
setTimeout(() => {
resolve(ms + 110)
}, ms)
})
expect(type(delay(10))).toEqual('Promise')
})
test('async function', () => {
expect(type(async () => {})).toEqual('Async')
})
test('async arrow', () => {
const asyncArrow = async () => {}
expect(type(asyncArrow)).toBe('Async')
})
test('function', () => {
const fn1 = () => {}
const fn2 = function (){}
function fn3(){}
;[ () => {}, fn1, fn2, fn3 ].map(val => {
expect(type(val)).toEqual('Function')
})
})
test('object', () => {
expect(type({})).toEqual('Object')
})
test('number', () => {
expect(type(1)).toEqual('Number')
})
test('boolean', () => {
expect(type(false)).toEqual('Boolean')
})
test('string', () => {
expect(type('foo')).toEqual('String')
})
test('null', () => {
expect(type(null)).toEqual('Null')
})
test('array', () => {
expect(type([])).toEqual('Array')
expect(type([ 1, 2, 3 ])).toEqual('Array')
})
test('regex', () => {
expect(type(/\s/g)).toEqual('RegExp')
})
test('undefined', () => {
expect(type(undefined)).toEqual('Undefined')
})
test('not a number', () => {
expect(type(Number('s'))).toBe('NaN')
})
test('function inside object 1', () => {
const obj = {
f(){
return 4
},
}
expect(type(obj.f)).toBe('Function')
expect(ramdaType(obj.f)).toBe('Function')
})
test('function inside object 2', () => {
const name = 'f'
const obj = {
[ name ](){
return 4
},
}
expect(type(obj.f)).toBe('Function')
expect(ramdaType(obj.f)).toBe('Function')
})
```
1 failed
```javascript
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');
});
});
```
All Typescript definitions
```typescript
uniqR.uniq source
```javascript
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
}
```
Tests
```javascript
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 ] ])
})
```
Typescript test
```typescript
import {uniq} from 'rambda'
describe('uniq', () => {
it('happy', () => {
const result = uniq([1, 2, 3, 3, 3, 1, 2, 0])
result // $ExpectType number[]
})
})
```
2 failed
```javascript
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);
});
```
All Typescript definitions
```typescript
uniqWithR.uniqWith source
```javascript
import { any } from './any'
export function uniqWith(fn, list){
if (arguments.length === 1) return _list => uniqWith(fn, _list)
let index = -1
const len = list.length
const willReturn = []
while (++index < len){
const value = list[ index ]
const flag = any(willReturnInstance => fn(value, willReturnInstance),
willReturn)
if (!flag){
willReturn.push(value)
}
}
return willReturn
}
```
Tests
```javascript
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)
})
```
Typescript test
```typescript
import {uniqWith} from 'rambda'
describe('uniqWith', () => {
it('happy', () => {
const input = [
{
id: 0,
title: 'foo',
},
{
id: 1,
title: 'bar',
},
{
id: 2,
title: 'baz',
},
{
id: 3,
title: 'foo',
},
{
id: 4,
title: 'bar',
},
]
const fn = (x: any, y: any) => x.title === y.title
const result = uniqWith(fn, input)
result // $ExpectType { id: number; title: string; }[]
})
})
```
All Typescript definitions
```typescript
updateR.update source
```javascript
export function update(
idx, val, list
){
if (val === undefined){
return (_val, _list) => update(
idx, _val, _list
)
} else if (list === undefined){
return _list => update(
idx, val, _list
)
}
const arrClone = list.slice()
return arrClone.fill(
val, idx, idx + 1
)
}
```
Tests
```javascript
import { update } from './update'
test('update', () => {
expect(update(1)(0)([ 1, 2, 3 ])).toEqual([ 1, 0, 3 ])
expect(update(
1, 11, [ 0, 1, 2 ]
)).toEqual([ 0, 11, 2 ])
})
```
Typescript test
```typescript
import {update} from 'rambda'
describe('update', () => {
it('happy', () => {
const result = update(1, 0, [1, 2, 3])
result // $ExpectType number[]
})
})
```
1 failed
```javascript
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]);
});
});
```
All Typescript definitions
```typescript
valuesR.values source
```javascript
import { type } from './type.js'
export function values(obj){
if (type(obj) !== 'Object') return []
return Object.values(obj)
}
```
Tests
```javascript
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([])
})
```
Typescript test
```typescript
import {values} from 'rambda'
describe('values', () => {
it('happy', () => {
const result = values({
a: 1,
b: 2,
c: 3,
})
result // $ExpectType number[]
})
})
```
All Typescript definitions
```typescript
viewR.view source
```javascript
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
}
```
All Typescript definitions
```typescript
whenR.when source
```javascript
import { isFunction } from './isFunction'
export function when(rule, resultOrFunction){
if (arguments.length === 1){
return whenTrueHolder => when(rule, whenTrueHolder)
}
return input => {
if (!rule(input)) return input
return isFunction(resultOrFunction) ?
resultOrFunction(input) :
resultOrFunction
}
}
```
Tests
```javascript
import { add } from './add'
import { is } from './is'
import { when } from './when'
const ruleResult = 'RULE_RESULT'
const rule = x => typeof x === 'number'
const fn = when(rule, ruleResult)
const curriedFn = when(rule)(ruleResult)
test('when rule returns true', () => {
const input = 7
expect(fn(input)).toBe(ruleResult)
})
test('when rule returns false', () => {
const input = 'foo'
expect(fn(input)).toBe(input)
expect(curriedFn(input)).toBe(input)
})
test('second argument can be a function', () => {
const fn = when(is(Number), add(1))
expect(fn(10)).toBe(11)
})
```
Typescript test
```typescript
import {when, add} from 'rambda'
const ruleResult = 88
const rule = (x: number) => x > 2
describe('when', () => {
it('without passing type - happy', () => {
const fn = when(rule, ruleResult)
const result = [
fn(1),
fn(2)
]
result[0] // $ExpectType number
result[1] // $ExpectType number
})
it('without passing type - second argument is function', () => {
const fn = when(rule, add(1))
const fnCurried = when(rule)(add(1))
const [result1, result2] = [
fn(1),
fnCurried(2),
]
result1 // $ExpectType number
result2 // $ExpectType unknown
})
it('with passing type', () => {
const fn = whenAll Typescript definitions
```typescript
withoutR.without source
```javascript
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
)
}
```
Tests
```javascript
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 ])
})
```
2 failed
```javascript
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);
});
});
```
All Typescript definitions
```typescript
xor(x: boolean, y: boolean): boolean;
xor(y: boolean): (y: boolean) => boolean;
```
R.xor source
```javascript
export function xor(a, b){
if (arguments.length === 1) return _b => xor(a, _b)
return Boolean(a) && !b || Boolean(b) && !a
}
```
Tests
```javascript
import { xor } from './xor'
test('compares two values with exclusive or', () => {
expect(xor(true, true)).toEqual(false)
expect(xor(true, false)).toEqual(true)
expect(xor(false, true)).toEqual(true)
expect(xor(false, false)).toEqual(false)
})
test('when both values are truthy, it should return false', () => {
expect(xor(true, 'foo')).toEqual(false)
expect(xor(42, true)).toEqual(false)
expect(xor('foo', 42)).toEqual(false)
expect(xor({}, true)).toEqual(false)
expect(xor(true, [])).toEqual(false)
expect(xor([], {})).toEqual(false)
expect(xor(new Date(), true)).toEqual(false)
expect(xor(true, Infinity)).toEqual(false)
expect(xor(Infinity, new Date())).toEqual(false)
})
test('when both values are falsy, it should return false', () => {
expect(xor(null, false)).toEqual(false)
expect(xor(false, undefined)).toEqual(false)
expect(xor(undefined, null)).toEqual(false)
expect(xor(0, false)).toEqual(false)
expect(xor(false, NaN)).toEqual(false)
expect(xor(NaN, 0)).toEqual(false)
expect(xor('', false)).toEqual(false)
})
test('when one argument is truthy and the other is falsy, it should return true', () => {
expect(xor('foo', null)).toEqual(true)
expect(xor(null, 'foo')).toEqual(true)
expect(xor(undefined, 42)).toEqual(true)
expect(xor(42, undefined)).toEqual(true)
expect(xor(Infinity, NaN)).toEqual(true)
expect(xor(NaN, Infinity)).toEqual(true)
expect(xor({}, '')).toEqual(true)
expect(xor('', {})).toEqual(true)
expect(xor(new Date(), 0)).toEqual(true)
expect(xor(0, new Date())).toEqual(true)
expect(xor([], null)).toEqual(true)
expect(xor(undefined, [])).toEqual(true)
})
test.skip('returns a curried function', () => {
expect(xor()(true)(true)).toEqual(false)
expect(xor()(true)(false)).toEqual(true)
expect(xor()(false)(true)).toEqual(true)
expect(xor()(false)(false)).toEqual(false)
})
```
Typescript test
```typescript
import {xor} from 'rambda'
describe('xor', () => {
it('happy', () => {
xor(true, false) // $ExpectType boolean
})
it('curry', () => {
xor(true)(false) // $ExpectType boolean
})
})
```
1 failed
```javascript
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);
});
});
```
All Typescript definitions
```typescript
zipR.zip source
```javascript
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
}
```
Tests
```javascript
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)
})
```
Typescript test
```typescript
import {zip} from 'rambda'
describe('zip', () => {
it('happy', () => {
const array1 = [1, 2, 3]
const array2 = ['A', 'B', 'C']
const result = zip(array1)(array2)
result // $ExpectType KeyValuePairAll Typescript definitions
```typescript
zipObjR.zipObj source
```javascript
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
}, {})
}
```
Tests
```javascript
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()
})
```
Typescript test
```typescript
import {zipObj} from 'rambda'
describe('zipObj', () => {
it('happy', () => {
const result = zipObj(['a', 'b', 'c', 'd', 'e', 'f'], [1, 2, 3])
result // $ExpectType { [index: string]: number; }
})
})
```