(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 this R.prop example in Rambda REPL R.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) }) ``` [](#prop) ### propEq ```typescript propEq(propToFind: K, valueToMatch: any, obj: Record): boolean ``` It returns true if `obj` has property `propToFind` and its value is equal to `valueToMatch`. ```javascript 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 R.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() }) ``` [](#propEq) ### propIs ```typescript propIs(type: any, name: string, obj: any): boolean ``` It returns `true` if `property` of `obj` is from `target` type. ```javascript 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 R.propIs source ```javascript import { curry } from './curry' 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() }) ``` [](#propIs) ### propOr ```typescript propOr(defaultValue: T, property: P, obj: Partial> | undefined): T ``` It returns either `defaultValue` or the value of `property` in `obj`. ```javascript 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 R.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') }) ``` [](#propOr) ### props ```typescript props(propsToPick: readonly P[], obj: Record): readonly T[] ``` It takes list with properties `propsToPick` and returns a list with property values in `obj`. ```javascript const result = [ R.props(['a', 'b'], {a:1, c:3}) // => [1, undefined] ``` Try this R.props example in Rambda REPL R.props source ```javascript import { _isArray } from './_internals/_isArray' 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) } ``` Tests ```javascript 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() }) ``` [](#props) ### random ```typescript random(minInclusive: number, maxInclusive: number): number ``` It returns a random number between `min` inclusive and `max` inclusive. R.random source ```javascript export function random(min, max){ return Math.floor(Math.random() * (max - min + 1)) + min } ``` Tests ```javascript import { random } from './random' import { range } from './range' test('when returns true', () => { range(0, 100).map(() => { const randomResult = random(1, 10) expect(randomResult).toBeLessThanOrEqual(10) expect(randomResult).toBeGreaterThanOrEqual(1) }) }) ``` [](#random) ### range ```typescript range(startInclusive: number, endExclusive: number): readonly number[] ``` It returns list of numbers between `startInclusive` to `endExclusive` markers. ```javascript R.range(0, 5) // => [0, 1, 2, 3, 4] ``` Try this R.range example in Rambda REPL R.range source ```javascript export function range(start, end){ if (arguments.length === 1) return _end => range(start, _end) if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){ throw new TypeError('Both arguments to range must be numbers') } if (end < start) return [] const len = end - start const willReturn = Array(len) for (let i = 0; i < len; i++){ willReturn[ i ] = start + i } return willReturn } ``` Tests ```javascript import { range } from './range' test('happy', () => { expect(range(0, 10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]) }) test('end range is bigger than start range', () => { expect(range(7, 3)).toEqual([]) expect(range(5, 5)).toEqual([]) }) test('with bad input', () => { const throwMessage = 'Both arguments to range must be numbers' expect(() => range('a', 6)).toThrowWithMessage(Error, throwMessage) expect(() => range(6, 'z')).toThrowWithMessage(Error, throwMessage) }) test('curry', () => { expect(range(0)(10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]) }) ``` [](#range) ### reduce ```typescript reduce(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 `reducer` function. ```javascript 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 R.reduce source ```javascript 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) ``` Tests ```javascript 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') }) ``` [](#reduce) ### reject ```typescript reject(predicate: Predicate, list: readonly T[]): readonly T[] ``` It has the opposite effect of `R.filter`. ```javascript const list = [1, 2, 3, 4] const obj = {a: 1, b: 2} const predicate = x => x > 1 const result = [ R.reject(predicate, list) R.reject(predicate, obj) ] // => [[1, 2], {a: 1}] ``` Try this R.reject example in Rambda REPL R.reject source ```javascript import { filter } from './filter' export function reject(predicate, list){ if (arguments.length === 1) return _list => reject(predicate, _list) return filter(x => !predicate(x), list) } ``` Tests ```javascript import { reject } from './reject' const isOdd = n => n % 2 === 1 test('with array', () => { expect(reject(isOdd)([ 1, 2, 3, 4 ])).toEqual([ 2, 4 ]) }) test('with object', () => { const obj = { a : 1, b : 2, c : 3, d : 4, } expect(reject(isOdd, obj)).toEqual({ b : 2, d : 4, }) }) ``` [](#reject) ### remove ```typescript remove( toRemove: string | RegExp | readonly (string | RegExp)[], text: string ): string ``` It will remove all `toRemove` entries from `text` sequentially. `toRemove` argument can be either a list of strings/regular expressions or a single string/regular expression. > :boom: This is the only case where Rambdax exports clashes with Ramda API, as Ramda has `remove` method. If `Rambda.remove` is introduced, then this method will be renamed. ```javascript const result = remove( ['foo','bar'], 'foo bar baz foo' ) // => 'baz foo' ``` Try this R.remove example in Rambda REPL R.remove source ```javascript import { replace } from './replace' import { type } from './type' export function remove(inputs, text){ if (arguments.length === 1){ return textHolder => remove(inputs, textHolder) } if (type(text) !== 'String'){ throw new Error(`R.remove requires string not ${ type(text) }`) } if (type(inputs) !== 'Array'){ return replace( inputs, '', text ) } let textCopy = text inputs.forEach(singleInput => { textCopy = replace( singleInput, '', textCopy ).trim() }) return textCopy } ``` Tests ```javascript import { remove } from './remove' test('happy', () => { const inputs = [ /foo/, /not\shere/, /also/, 'bar' ] const text = 'foo bar baz foo' const result = remove(inputs)(text) const expectedResult = 'baz foo' expect(result).toEqual(expectedResult) }) test('with strings + curry', () => { const inputs = [ 'foo', 'bar' ] const text = 'foo bar baz foo' const result = remove(inputs)(text) const expectedResult = 'baz foo' expect(result).toEqual(expectedResult) }) test('with strings and regex', () => { const inputs = [ /foo/g, 'bar' ] const text = 'foo bar baz foo' const result = remove(inputs, text) const expectedResult = 'baz' expect(result).toEqual(expectedResult) }) test('text is not string', () => { const inputs = [ /foo/g, 'bar' ] const text = null expect(() => remove(inputs, text)).toThrowWithMessage(Error, 'R.remove requires string not Null') }) test('with regexes', () => { const inputs = [ /foo/g, /bar/ ] const text = 'foo bar baz foo' const result = remove(inputs, text) const expectedResult = 'baz' expect(result).toEqual(expectedResult) }) test('with single rule', () => { const inputs = /foo/g const text = 'foo bar baz foo' const result = remove(inputs, text) const expectedResult = ' bar baz ' expect(result).toEqual(expectedResult) }) ``` [](#remove) ### removeIndex ```typescript removeIndex(index: number, list: readonly T[]): readonly T[] ``` It returns a copy of `list` input with removed `index`. ```javascript const list = [1, 2, 3, 4] const result = R.removeIndex(1, list) // => [1, 3, 4] ``` Try this R.removeIndex example in Rambda REPL R.removeIndex source ```javascript export function removeIndex(list, index){ if (arguments.length === 1) return _index => removeIndex(list, _index) if (index <= 0) return list.slice(1) if (index >= list.length - 1) return list.slice(0, list.length - 1) return [ ...list.slice(0, index), ...list.slice(index + 1) ] } ``` Tests ```javascript import { removeIndex } from './removeIndex' const list = [ 1, 2, 3, 4 ] test('first or before first index', () => { expect(removeIndex(list, 0)).toEqual([ 2, 3, 4 ]) expect(removeIndex(list)(-2)).toEqual([ 2, 3, 4 ]) }) test('last or after last index', () => { expect(removeIndex(list, 4)).toEqual([ 1, 2, 3 ]) expect(removeIndex(list, 10)).toEqual([ 1, 2, 3 ]) }) test('middle index', () => { expect(removeIndex(list, 1)).toEqual([ 1, 3, 4 ]) expect(removeIndex(list, 2)).toEqual([ 1, 2, 4 ]) }) ``` [](#removeIndex) ### renameProps ```typescript renameProps(rules: object, input: object): object ``` If property `prop` of `rules` is also a property in `input`, then rename `input` property to `rules[prop]`. R.renameProps source ```javascript import { merge } from './merge' import { omit } from './omit' export function renameProps(conditions, inputObject){ if (arguments.length === 1){ return inputObjectHolder => renameProps(conditions, inputObjectHolder) } const renamed = {} Object.keys(conditions).forEach(condition => { if (Object.keys(inputObject).includes(condition)){ renamed[ conditions[ condition ] ] = inputObject[ condition ] } }) return merge(renamed, omit(Object.keys(conditions), inputObject)) } ``` Tests ```javascript import { renameProps } from './renameProps' test('renameProps', () => { const rules = { f : 'foo', b : 'bar', } const input = { f : 1, b : 2, } const result = renameProps(rules, input) const expectedResult = { foo : 1, bar : 2, } expect(result).toEqual(expectedResult) }) test('curry', () => { const rules = { f : 'foo', b : 'bar', } const input = { f : 1, b : 2, } const result = renameProps(rules)(input) const expectedResult = { foo : 1, bar : 2, } expect(result).toEqual(expectedResult) }) ``` [](#renameProps) ### repeat ```typescript repeat(x: T): (timesToRepeat: number) => readonly T[] ``` ```javascript R.repeat('foo', 3) // => ['foo', 'foo', 'foo'] ``` Try this R.repeat example in Rambda REPL R.repeat source ```javascript export function repeat(x, timesToRepeat){ if (arguments.length === 1){ return _timesToRepeat => repeat(x, _timesToRepeat) } return Array(timesToRepeat).fill(x) } ``` Tests ```javascript import { repeat } from './repeat' test('repeat', () => { expect(repeat('')(3)).toEqual([ '', '', '' ]) expect(repeat('foo', 3)).toEqual([ 'foo', 'foo', 'foo' ]) const obj = {} const arr = repeat(obj, 3) expect(arr).toEqual([ {}, {}, {} ]) expect(arr[ 0 ] === arr[ 1 ]).toBeTrue() }) ``` [](#repeat) ### replace ```typescript replace(strOrRegex: RegExp | string, replacer: string, str: string): string ``` It replaces `strOrRegex` found in `str` with `replacer`. ```javascript const strOrRegex = /o/g const result = R.replace(strOrRegex, '|0|', 'foo') // => 'f|0||0|' ``` Try this R.replace example in Rambda REPL R.replace source ```javascript import { curry } from './curry' function replaceFn( pattern, replacer, str ){ return str.replace(pattern, replacer) } export const replace = curry(replaceFn) ``` 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') }) ``` [](#replace) ### replaceAll ```typescript replaceAll(patterns: ReadonlyArray, replacer: string, input: string): string ``` Same as `R.replace` but it accepts array of string and regular expressions instead of a single value. ```javascript const replacer = '|' const patterns = [ /foo/g, 'bar' ] const input = 'foo bar baz foo bar' const result = replaceAll(patterns, replacer, input) // => '| | baz | bar' ``` Try this R.replaceAll example in Rambda REPL R.replaceAll source ```javascript import { curry } from './curry' import { ok } from './ok' function replaceAllFn( patterns, replacer, input ){ ok( patterns, replacer, input )( Array, String, String ) let text = input patterns.forEach(singlePattern => { text = text.replace(singlePattern, replacer) }) return text } export const replaceAll = curry(replaceAllFn) ``` Tests ```javascript import { replaceAll } from './replaceAll' const replacer = '|' const patterns = [ /foo/g, 'bar' ] const input = 'foo bar baz foo bar' test('happy', () => { const result = replaceAll( patterns, replacer, input ) const expected = '| | baz | bar' expect(result).toEqual(expected) }) test('throws when wrong patterns', () => { expect(() => replaceAll( {}, replacer, input )).toThrow() }) test('throws when wrong input', () => { expect(() => replaceAll( patterns, replacer, [] )).toThrow() }) test('throws when wrong replacer', () => { expect(() => replaceAll( patterns, null, input )).toThrow() }) ``` [](#replaceAll) ### reset ```typescript reset(): void ``` > :boom: `R.getter` method contains explanations, tests and source information of `R.reset`, `R.setter` and `R.getter` methods. [](#reset) ### reverse ```typescript reverse(input: readonly T[]): readonly T[] ``` It returns a reversed copy of list or string `input`. ```javascript const result = [ R.reverse('foo'), R.reverse([1, 2, 3]) ] // => ['oof', [3, 2, 1] ``` Try this R.reverse example in Rambda REPL R.reverse source ```javascript export function reverse(listOrString){ if (typeof listOrString === 'string'){ return listOrString.split('').reverse() .join('') } const clone = listOrString.slice() return clone.reverse() } ``` Tests ```javascript import { reverse } from './reverse' 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 ]) }) ``` [](#reverse) ### set ```typescript set(lens: Lens, replacer: U, obj: T): T ``` It returns a copied **Object** or **Array** with modified `lens` focus set to `replacer` value. ```javascript const input = {x: 1, y: 2} const xLens = R.lensProp('x') 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 R.set source ```javascript 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) ``` Tests ```javascript 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 ]) }) ``` [](#set) ### setter ```typescript setter(keyOrObject: string | object, value?: any): void ``` > :boom: `R.getter` method contains explanations, tests and source information of `R.reset`, `R.setter` and `R.getter` methods. [](#setter) ### shuffle ```typescript shuffle(list: readonly T[]): readonly T[] ``` It returns a randomized copy of array. R.shuffle source ```javascript export function shuffle(arrayRaw){ const array = arrayRaw.concat() let counter = array.length while (counter > 0){ const index = Math.floor(Math.random() * counter) counter-- const temp = array[ counter ] array[ counter ] = array[ index ] array[ index ] = temp } return array } ``` Tests ```javascript import { range } from './range' import { shuffle } from './shuffle' import { uniq } from './uniq' test('happy', () => { const list = range(0, 7) const result = range(0, 300).map(() => shuffle(list)) const allUniq = uniq(result) expect(allUniq.length > 150).toBeTrue() }) ``` [](#shuffle) ### slice ```typescript slice(from: number, to: number, input: string): string ``` ```javascript const list = [0, 1, 2, 3, 4, 5] const str = 'FOO_BAR' const from = 1 const to = 4 const result = [ R.slice(str, to, list), R.slice(from, to, list) ] // => ['OO_', [1, 2, 3]] ``` Try this R.slice example in Rambda REPL R.slice source ```javascript import { curry } from './curry' 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') }) ``` [](#slice) ### sort ```typescript sort(sortFn: (a: T, b: T) => number, list: readonly T[]): readonly T[] ``` It returns copy of `list` sorted by `sortFn` function. > :boom: `sortFn` function must return a number. ```javascript const list = [ {a: 2}, {a: 3}, {a: 1} ] const sortFn = (x, y) => { return x.a > y.a ? 1 : -1 } const result = R.sort(sortFn, list) const expected = [ {a: 1}, {a: 2}, {a: 3} ] // => `result` is equal to `expected` ``` Try this R.sort example in Rambda REPL R.sort source ```javascript 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') }) ``` [](#sort) ### sortBy ```typescript sortBy(sortFn: (a: T) => Ord, list: readonly T[]): readonly T[] ``` It returns copy of `list` sorted by `sortFn` function. > :boom: `sortFn` function must return a value to compare. ```javascript const list = [ {a: 2}, {a: 3}, {a: 1} ] const sortFn = x => x.a const result = R.sortBy(sortFn, list) const expected = [ {a: 1}, {a: 2}, {a: 3} ] // => `result` is equal to `expected` ``` Try this R.sortBy example in Rambda REPL R.sortBy source ```javascript 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' test('happy', () => { const input = [ { a : 2 }, { a : 1 }, { a : 1 }, { a : 3 } ] const expected = [ { a : 1 }, { a : 1 }, { a : 2 }, { a : 3 } ] const result = sortBy(x => x.a)(input) expect(result).toEqual(expected) }) test('with compose', () => { const alice = { name : 'ALICE', age : 101, } const bob = { name : 'Bob', age : -10, } const clara = { name : 'clara', age : 314.159, } const people = [ clara, bob, alice ] const sortByNameCaseInsensitive = sortBy(compose(toLower, prop('name'))) expect(sortByNameCaseInsensitive(people)).toEqual([ alice, bob, clara ]) }) ``` [](#sortBy) ### sortByPath ```typescript sortByPath(sortPath: Path, list: readonly T[]): readonly T[] ``` It returns copy of `list` sorted by `sortPath` value. As `sortPath` is passed to `R.path`, it can be either a string or an array of strings. ```javascript const list = [ {a: {b: 2}}, {a: {b: 1}}, {a: {b: 3}} ] const result = R.sortByPath('a.b', list) const expected = [ {a: {b: 1}}, {a: {b: 2}}, {a: {b: 3}} ] // => `result` is equal to `expected` ``` Try this R.sortByPath example in Rambda REPL R.sortByPath source ```javascript import { path } from './path' import { sortBy } from './sortBy' export function sortByPath(sortPath, list){ if (arguments.length === 1) return _list => sortByPath(sortPath, _list) return sortBy(path(sortPath), list) } ``` Tests ```javascript import { sortByPath } from './sortByPath' const list = [ { a : { b : 3 } }, { a : { b : 1 } }, { a : { b : 2 } } ] const sorted = [ { a : { b : 1 } }, { a : { b : 2 } }, { a : { b : 3 } } ] test('with string as path', () => { expect(sortByPath('a.b', list)).toEqual(sorted) }) test('with list of strings as path', () => { expect(sortByPath([ 'a', 'b' ], list)).toEqual(sorted) }) test('with string as path - curried', () => { expect(sortByPath('a.b')(list)).toEqual(sorted) }) test('with list of strings as path - curried', () => { expect(sortByPath([ 'a', 'b' ])(list)).toEqual(sorted) }) ``` [](#sortByPath) ### sortByProps ```typescript sortByProps(sortPaths: readonly string[], list: readonly T[]): readonly T[] ``` It returns sorted copy of `list` of objects. Sorting is done using a list of strings, each representing a path. Two members `a` and `b` from `list` can be sorted if both return a value for a given path. If the value is equal, then the next member of `sortPaths`(if there is such) will be used in order to find difference between `a` and `b`. ```javascript const list = [ {a: {b: 2}}, {a: {b: 1}}, {a: {b: 3}} ] const result = R.sortByPath('a.b', list) const expected = [ {a: {b: 1}}, {a: {b: 2}}, {a: {b: 3}} ] // => `result` is equal to `expected` ``` Try this R.sortByProps example in Rambda REPL R.sortByProps source ```javascript import { path } from './path' function singleSort( a, b, sortPaths ){ let toReturn = 0 sortPaths.forEach(singlePath => { if (toReturn !== 0) return const aResult = path(singlePath, a) const bResult = path(singlePath, b) if ([ aResult, bResult ].includes(undefined)) return if (aResult === bResult) return toReturn = aResult > bResult ? 1 : -1 }) return toReturn } export function sortByProps(sortPaths, list){ if (arguments.length === 1) return _list => sortByProps(sortPaths, _list) const clone = list.slice() clone.sort((a, b) => singleSort( a, b, sortPaths )) return clone } ``` Tests ```javascript import { sortByProps } from './sortByProps' const list = [ { a : { b : 3 } }, { a : { b : 2 } }, { a : { b : 1 } } ] const sorted = [ { a : { b : 1 } }, { a : { b : 2 } }, { a : { b : 3 } } ] test('wrong paths are ignored', () => { expect(sortByProps([ 'foo.bar', 'a.c', 'a.b', 'a.d' ], list)).toEqual(sorted) }) test('skip sort when path results are equal', () => { const input = [ { a : { b : 0, c : 2, }, }, { a : { b : 0, c : 1, }, }, ] expect(sortByProps([ 'a.b', 'a.d' ], input)).toEqual(input) }) test('when list is already sorted', () => { const input = [ { a : { b : 0, c : 1, }, }, { a : { b : 0, c : 2, }, }, ] expect(sortByProps([ 'a.b', 'a.c' ])(input)).toEqual(input) }) ``` [](#sortByProps) ### sortObject ```typescript sortObject(predicate: SortObjectPredicate, input: { readonly [key: string]: T }): { readonly [keyOutput: string]: T } ``` It returns a sorted version of `input` object. ```javascript const predicate = (propA, propB, valueA, valueB) => valueA > valueB ? -1 : 1 const result = R.sortObject(predicate, {a:1, b: 4, c: 2}) // => {b: 4, c: 2, a: 1} ``` Try this R.sortObject example in Rambda REPL R.sortObject source ```javascript import { sort } from './sort' export function sortObject(predicate, obj){ if (arguments.length === 1){ return _obj => sortObject(predicate, _obj) } const keys = Object.keys(obj) const sortedKeys = sort((a, b) => predicate( a, b, obj[ a ], obj[ b ] ), keys) const toReturn = {} sortedKeys.forEach(singleKey => { toReturn[ singleKey ] = obj[ singleKey ] }) return toReturn } ``` Tests ```javascript import { runTests } from 'helpers-fn' import { allTrue } from './allTrue' import { equals } from './equals' import { sortObject } from './sortObject' const obj = { c : 1, a : 2, b : 3, } const predicateA = ( propA, propB, valueA, valueB ) => propA > propB ? -1 : 1 const expectationA = [ 'c', 'b', 'a' ] const predicateB = ( propA, propB, valueA, valueB ) => propA < propB ? -1 : 1 const expectationB = [ 'a', 'b', 'c' ] const predicateC = ( propA, propB, valueA, valueB ) => valueA > valueB ? -1 : 1 const expectationC = [ 'b', 'a', 'c' ] const fn = ([ predicate, expectation ]) => { const result = sortObject(predicate, obj) const curriedResult = sortObject(predicate)(obj) const sortedKeys = Object.keys(result) const sortedKeysCurried = Object.keys(curriedResult) const isSameObject = equals(obj, result) const isSameObjectCurried = equals(obj, curriedResult) return allTrue( isSameObject, isSameObjectCurried, equals(sortedKeys, expectation), equals(sortedKeysCurried, expectation) ) } const testData = { label : 'foo', data : [ { ok : [ predicateA, expectationA ] }, { ok : [ predicateB, expectationB ] }, { ok : [ predicateC, expectationC ] }, ], fn, } runTests(testData) ``` [](#sortObject) ### split ```typescript split(separator: string | RegExp): (str: string) => readonly string[] ``` Curried version of `String.prototype.split` ```javascript const str = 'foo|bar|baz' const separator = |' const result = R.split(separator, str)) // => [ 'foo', 'bar', 'baz' ] ``` Try this R.split example in Rambda REPL R.split source ```javascript export function split(separator, str){ if (arguments.length === 1) return _str => split(separator, _str) return str.split(separator) } ``` Tests ```javascript import { split } from './split' const str = 'foo|bar|baz' const splitChar = '|' const expected = [ 'foo', 'bar', 'baz' ] test('happy', () => { expect(split(splitChar, str)).toEqual(expected) }) test('curried', () => { expect(split(splitChar)(str)).toEqual(expected) }) ``` [](#split) ### splitAt ```typescript splitAt(index: number, input: readonly T[]): readonly [readonly T[], readonly T[]] ``` It splits string or array at a given index. ```javascript const list = [ 1, 2, 3 ] const result = splitAt(2, list) // => [[ 1, 2 ], [ 3 ]] ``` Try this R.splitAt example in Rambda REPL R.splitAt source ```javascript 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) ] } ``` Tests ```javascript 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) }) }) ``` [](#splitAt) ### splitEvery ```typescript splitEvery(sliceLength: number, input: readonly T[]): readonly (readonly T[])[] ``` It splits `input` into slices of `sliceLength`. ```javascript const result = [ R.splitEvery(2, [1, 2, 3]), R.splitEvery(3, 'foobar') ] const expected = [ [[1, 2], [3]], ['foo', 'bar'] ] // => `result` is equal to `expected` ``` Try this R.splitEvery example in Rambda REPL R.splitEvery source ```javascript export function splitEvery(sliceLength, listOrString){ if (arguments.length === 1){ return _listOrString => splitEvery(sliceLength, _listOrString) } if (sliceLength < 1){ throw new Error('First argument to splitEvery must be a positive integer') } const willReturn = [] let counter = 0 while (counter < listOrString.length){ willReturn.push(listOrString.slice(counter, counter += sliceLength)) } return willReturn } ``` Tests ```javascript import { splitEvery } from './splitEvery' 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') }) ``` [](#splitEvery) ### splitWhen ```typescript splitWhen(predicate: Predicate, 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`. ```javascript const list = [1, 2, 1, 2] const result = R.splitWhen(R.equals(2), list) // => [[1], [2, 1, 2]] ``` Try this R.splitWhen example in Rambda REPL R.splitWhen source ```javascript export function splitWhen(predicate, input){ if (arguments.length === 1){ return _input => splitWhen(predicate, _input) } if (!input) throw new TypeError(`Cannot read property 'length' of ${ input }`) const preFound = [] const postFound = [] let found = false let counter = -1 while (counter++ < input.length - 1){ if (found){ postFound.push(input[ counter ]) } else if (predicate(input[ counter ])){ postFound.push(input[ counter ]) found = true } else { preFound.push(input[ counter ]) } } return [ preFound, postFound ] } ``` Tests ```javascript import { splitWhen as splitWhenRamda } from 'ramda' import { equals } from './equals' 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) }) }) ``` [](#splitWhen) ### startsWith ```typescript startsWith(target: string, str: string): boolean ``` Curried version of `String.prototype.startsWith` > :boom: It doesn't work with arrays unlike its corresponding **Ramda** method. ```javascript const str = 'foo-bar' const result = [ R.startsWith('foo', str), R.startsWith('bar', str) ] // => [true, false] ``` Try this R.startsWith example in Rambda REPL 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() }) ``` [](#startsWith) ### subtract Curried version of `x - y` ```javascript const x = 3 const y = 1 R.subtract(x, y) // => 2 ``` Try this R.subtract example in Rambda REPL [](#subtract) ### sum ```typescript sum(list: readonly number[]): number ``` ```javascript R.sum([1, 2, 3, 4, 5]) // => 15 ``` Try this R.sum example in Rambda REPL R.sum source ```javascript export function sum(list){ return list.reduce((prev, current) => prev + current, 0) } ``` Tests ```javascript import { sum } from './sum' test('happy', () => { expect(sum([ 1, 2, 3, 4, 5 ])).toBe(15) }) ``` [](#sum) ### switcher ```typescript switcher(valueToMatch: any): Switchem ``` Edited fork of [Switchem](https://github.com/planttheidea/switchem) library. The method return a value if the matched option is a value. If the matched option is a function, then `R.switcher` returns a function which expects input. Tests of the method explain it better than this short description. ```javascript const valueToMatch = {foo: 1} const result = R.switcher(valueToMatch) .is('baz', 'is baz') .is(x => typeof x === 'boolean', 'is boolean') .is({foo: 1}, 'Property foo is 1') .default('is bar') // => 'Property foo is 1' ``` Try this R.switcher example in Rambda REPL R.switcher source ```javascript import { equals } from './equals' const NO_MATCH_FOUND = Symbol ? Symbol('NO_MATCH_FOUND') : undefined const getMatchingKeyValuePair = ( cases, testValue, defaultValue ) => { let iterationValue for (let index = 0; index < cases.length; index++){ iterationValue = cases[ index ].test(testValue) if (iterationValue !== NO_MATCH_FOUND){ return iterationValue } } return defaultValue } const isEqual = (testValue, matchValue) => { const willReturn = typeof testValue === 'function' ? testValue(matchValue) : equals(testValue, matchValue) return willReturn } const is = (testValue, matchResult = true) => ({ key : testValue, test : matchValue => isEqual(testValue, matchValue) ? matchResult : NO_MATCH_FOUND, }) class Switchem{ constructor( defaultValue, cases, willMatch ){ if (cases === undefined && willMatch === undefined){ this.cases = [] this.defaultValue = undefined this.willMatch = defaultValue } else { this.cases = cases this.defaultValue = defaultValue this.willMatch = willMatch } return this } default(defaultValue){ const holder = new Switchem( defaultValue, this.cases, this.willMatch ) return holder.match(this.willMatch) } is(testValue, matchResult){ return new Switchem( this.defaultValue, [ ...this.cases, is(testValue, matchResult) ], this.willMatch ) } match(matchValue){ return getMatchingKeyValuePair( this.cases, matchValue, this.defaultValue ) } } export function switcher(input){ return new Switchem(input) } ``` Tests ```javascript import { add } from './add' import { switcher } from './switcher' import { tap } from './tap' import { trim } from './trim' test('with undefined', () => { const result = switcher(undefined) .is(x => x === 0, '0') .is(x => x === undefined, 'UNDEFINED') .default('3') expect(result).toEqual('UNDEFINED') }) test('happy', () => { const a = true const b = false const result = switcher([ a, b ]) .is([ false, false ], '0') .is([ false, true ], '1') .is([ true, true ], '2') .default('3') expect(result).toEqual('3') }) test('can compare objects', () => { const result = switcher({ a : 1 }) .is({ a : 1 }, 'it is object') .is('baz', 'it is baz') .default('it is default') expect(result).toEqual('it is object') }) test('options are mixture of functions and values - input match function', () => { const fn = switcher('foo').is('bar', 1) .is('foo', add(1)) .default(1000) expect(fn(2)).toEqual(3) }) test('options are mixture of functions and values - input match value', () => { const result = switcher('bar').is('bar', 1) .is('foo', add(1)) .default(1000) expect(result).toBe(1) }) test('return function if all options are functions', () => { const fn = switcher('foo').is('bar', tap) .is('foo', add(1)) .default(trim) expect(fn(2)).toEqual(3) }) const switchFn = input => switcher(input) .is(x => x.length && x.length === 7, 'has length of 7') .is('baz', 'it is baz') .default('it is default') test('works with function as condition', () => { expect(switchFn([ 0, 1, 2, 3, 4, 5, 6 ])).toEqual('has length of 7') }) test('works with string as condition', () => { expect(switchFn('baz')).toEqual('it is baz') }) test('fallback to default input when no matches', () => { expect(switchFn(1)).toEqual('it is default') }) ``` [](#switcher) ### symmetricDifference ```typescript symmetricDifference(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. ```javascript 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 R.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 }, ]) }) ``` [](#symmetricDifference) ### T ```typescript T(): boolean ``` ```javascript R.T() // => true ``` Try this R.T example in Rambda REPL R.T source ```javascript export function T(){ return true } ``` [](#T) ### tail ```typescript tail(input: readonly T[]): readonly T[] ``` It returns all but the first element of `input`. ```javascript const result = [ R.tail([1, 2, 3]), R.tail('foo') ] // => [[2, 3], 'oo'] ``` Try this R.tail example in Rambda REPL R.tail source ```javascript import { drop } from './drop' 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('') }) ``` [](#tail) ### take ```typescript take(howMany: number, input: readonly T[]): readonly T[] ``` It returns the first `howMany` elements of `input`. ```javascript const howMany = 2 const result = [ R.take(howMany, [1, 2, 3]), R.take(howMany, 'foobar'), ] // => [[1, 2], 'fo'] ``` Try this R.take example in Rambda REPL R.take source ```javascript import baseSlice from './_internals/baseSlice' 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([]) }) ``` [](#take) ### takeLast ```typescript takeLast(howMany: number, input: readonly T[]): readonly T[] ``` It returns the last `howMany` elements of `input`. ```javascript const howMany = 2 const result = [ R.takeLast(howMany, [1, 2, 3]), R.takeLast(howMany, 'foobar'), ] // => [[2, 3], 'ar'] ``` Try this R.takeLast example in Rambda REPL R.takeLast source ```javascript import baseSlice from './_internals/baseSlice' 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 ]) }) ``` [](#takeLast) ### takeLastWhile ```typescript takeLastWhile(predicate: (x: string) => boolean, input: string): string ``` ```javascript const result = R.takeLastWhile( x => x > 2, [1, 2, 3, 4] ) // => [3, 4] ``` Try this R.takeLastWhile example in Rambda REPL R.takeLastWhile source ```javascript import { _isArray } from './_internals/_isArray' 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('') } ``` Tests ```javascript 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') }) ``` [](#takeLastWhile) ### takeUntil ```typescript takeUntil(predicate: (x: T) => boolean, list: readonly T[]): readonly T[] ``` ```javascript const list = [1, 2, 3, 4, 5] const predicate = x => x > 3 const result = R.takeUntil(predicate, list) // => [1, 2, 3] ``` Try this R.takeUntil example in Rambda REPL R.takeUntil source ```javascript export function takeUntil(predicate, list){ const toReturn = [] let stopFlag = false let counter = -1 while (stopFlag === false && counter++ < list.length - 1){ if (predicate(list[ counter ])){ stopFlag = true } else { toReturn.push(list[ counter ]) } } return toReturn } ``` Tests ```javascript import { takeUntil } from './takeUntil' const list = [ 1, 2, 3, 4, 5, 6 ] test('happy', () => { const result = takeUntil(x => x > 3, list) expect(result).toEqual([ 1, 2, 3 ]) }) test('predicate always returns true', () => { const result = takeUntil(x => x < 10, list) expect(result).toEqual([]) }) test('predicate always returns false', () => { const result = takeUntil(x => x > 10, list) expect(result).toEqual(list) }) ``` [](#takeUntil) ### takeWhile ```javascript 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) ### tap ```typescript tap(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`. ```javascript const list = [1, 2, 3] R.compose( R.map(x => x * 2) R.tap(console.log), R.filter(x => x > 1) )(list) // => `2` and `3` will be logged ``` Try this R.tap example in Rambda REPL R.tap source ```javascript export function tap(fn, x){ if (arguments.length === 1) return _x => tap(fn, _x) fn(x) return x } ``` Tests ```javascript import { tap } from './tap' 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) }) ``` [](#tap) ### tapAsync ```typescript tapAsync(fn: Func | Promise, input: T): T ``` Asynchronous version of `R.tap`. R.tapAsync source ```javascript async function tapAsyncFn(fn, input){ await fn(input) return input } export function tapAsync(fn, input){ if (arguments.length === 1){ return async _input => tapAsyncFn(fn, _input) } return new Promise((resolve, reject) => { tapAsyncFn(fn, input).then(resolve) .catch(reject) }) } ``` Tests ```javascript import { delay } from './delay' import { pipedAsync } from './pipedAsync' import { tapAsync } from './tapAsync' test('happy', async () => { const result = await tapAsync(delay, 1) expect(result).toEqual(1) }) test('complex', async () => { let marker = false const fn = () => marker = true const result = await pipedAsync( 1, async x => { await delay(100) return x + 1 }, tapAsync(fn), x => x + 1 ) expect(marker).toBeTrue() expect(result).toEqual(3) }) ``` [](#tapAsync) ### test ```typescript test(regExpression: RegExp): (str: string) => boolean ``` It determines whether `str` matches `regExpression`. ```javascript R.test(/^f/, 'foo') // => true ``` Try this R.test example in Rambda REPL R.test source ```javascript export function test(pattern, str){ if (arguments.length === 1) return _str => test(pattern, _str) if (typeof pattern === 'string'){ throw new TypeError(`‘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')).toThrowWithMessage(TypeError, '‘test’ requires a value of type RegExp as its first argument; received "foo"') }) ``` [](#test) ### throttle ```typescript throttle(fn: (input: T) => U, ms: number): (input: T) => U ``` It creates a throttled function that invokes `fn` maximum once for a `period` of milliseconds. ```javascript let counter = 0 const inc = () => { counter++ } const throttledInc = R.throttle(inc, 800) const result = async () => { throttledInc() await R.delay(500) throttledInc() return counter } // `result` resolves to `1` ``` Try this R.throttle example in Rambda REPL R.throttle source ```javascript export function throttle(fn, ms){ let wait = false return function (...input){ if (!wait){ fn.apply(null, input) wait = true setTimeout(() => { wait = false }, ms) } } } ``` Tests ```javascript import { delay } from './delay' import { throttle } from './throttle' test('', async () => { let counter = 0 let aHolder let bHolder const inc = (a, b) => { aHolder = a bHolder = b counter++ } const incWrapped = throttle(inc, 1000) incWrapped(1, 2) await delay(500) incWrapped(2, 3) incWrapped(3, 4) expect(counter).toBe(1) expect(aHolder).toBe(1) expect(bHolder).toBe(2) await delay(1000) incWrapped(5, 6) expect(counter).toBe(2) expect(aHolder).toBe(5) expect(bHolder).toBe(6) }) ``` [](#throttle) ### times ```typescript times(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). ```javascript const fn = x => x * 2 const howMany = 5 R.times(fn, howMany) // => [0, 2, 4, 6, 8] ``` Try this R.times example in Rambda REPL R.times source ```javascript import { 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 ]) }) ``` [](#times) ### toDecimal ```typescript toDecimal(num: number, charsAfterDecimalPoint?: number): number ``` ```javascript R.toDecimal(2.45464,2) // => 2.45 ``` Try this R.toDecimal example in Rambda REPL R.toDecimal source ```javascript export function toDecimal(number, charsAfterDecimalPoint = 2){ return Number(parseFloat(String(number)).toFixed(charsAfterDecimalPoint)) } ``` Tests ```javascript import { toDecimal } from './toDecimal' test('happy', () => { expect(toDecimal(2.2789, 1)).toBe(2.3) expect(toDecimal(2.2789, 3)).toBe(2.279) expect(toDecimal(2, 3)).toBe(2) expect(toDecimal(2.2789)).toBe(2.28) expect(toDecimal(2.45464)).toBe(2.45) }) ``` [](#toDecimal) ### toLower ```typescript toLower(str: string): string ``` ```javascript R.toLower('FOO') // => 'foo' ``` Try this R.toLower example in Rambda REPL R.toLower source ```javascript export function toLower(str){ return str.toLowerCase() } ``` Tests ```javascript import { toLower } from './toLower' test('toLower', () => { expect(toLower('FOO|BAR|BAZ')).toEqual('foo|bar|baz') }) ``` [](#toLower) ### toPairs ```typescript toPairs(obj: { readonly [k: string]: S } | { readonly [k: number]: S }): readonly (readonly [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 this R.toPairs example in Rambda REPL R.toPairs source ```javascript export function toPairs(obj){ return Object.entries(obj) } ``` Tests ```javascript import { toPairs } from './toPairs' const obj = { a : 1, b : 2, c : [ 3, 4 ], } const expected = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ], ] test('happy', () => { expect(toPairs(obj)).toEqual(expected) }) ``` [](#toPairs) ### toString ```typescript toString(x: T): string ``` ```javascript R.toString([1, 2]) // => '1,2' ``` Try this R.toString example in Rambda REPL R.toString source ```javascript export function toString(x){ return x.toString() } ``` Tests ```javascript import { toString } from './toString' test('happy', () => { expect(toString([ 1, 2, 3 ])).toEqual('1,2,3') }) ``` [](#toString) ### toUpper ```typescript toUpper(str: string): string ``` ```javascript R.toUpper('foo') // => 'FOO' ``` Try this R.toUpper example in Rambda REPL R.toUpper source ```javascript export function toUpper(str){ return str.toUpperCase() } ``` Tests ```javascript import { toUpper } from './toUpper' test('toUpper', () => { expect(toUpper('foo|bar|baz')).toEqual('FOO|BAR|BAZ') }) ``` [](#toUpper) ### transpose ```typescript transpose(list: readonly (readonly T[])[]): readonly (readonly T[])[] ``` ```javascript const list = [[10, 11], [20], [], [30, 31, 32]] const expected = [[10, 20, 30], [11, 31], [32]] const result = R.transpose(list) // => `result` is equal to `expected` ``` Try this R.transpose example in Rambda REPL R.transpose source ```javascript import { _isArray } from './_internals/_isArray' export function transpose(array){ return array.reduce((acc, el) => { el.forEach((nestedEl, i) => _isArray(acc[ i ]) ? acc[ i ].push(nestedEl) : acc.push([ nestedEl ])) return acc }, []) } ``` Tests ```javascript import { transpose } from './transpose' test('happy', () => { const input = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ], ] expect(transpose(input)).toEqual([ [ 'a', 'b', 'c' ], [ 1, 2, 3 ], ]) }) test('when rows are shorter', () => { const actual = transpose([ [ 10, 11 ], [ 20 ], [], [ 30, 31, 32 ] ]) const expected = [ [ 10, 20, 30 ], [ 11, 31 ], [ 32 ] ] expect(actual).toEqual(expected) }) test('with empty array', () => { expect(transpose([])).toEqual([]) }) test('array with falsy values', () => { const actual = transpose([ [ true, false, undefined, null ], [ null, undefined, false, true ], ]) const expected = [ [ true, null ], [ false, undefined ], [ undefined, false ], [ null, true ], ] expect(actual).toEqual(expected) }) ``` [](#transpose) ### trim ```typescript trim(str: string): string ``` ```javascript R.trim(' foo ') // => 'foo' ``` Try this R.trim example in Rambda REPL R.trim source ```javascript export function trim(str){ return str.trim() } ``` Tests ```javascript import { trim } from './trim' test('trim', () => { expect(trim(' foo ')).toEqual('foo') }) ``` [](#trim) ### tryCatch ```typescript tryCatch( 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.tryCatch` to fully understand how this method works. ```javascript 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 R.tryCatch source ```javascript 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 } } } ``` Tests ```javascript 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, }) }) ``` [](#tryCatch) ### tryCatchAsync ```typescript tryCatchAsync( fn: (input: any) => Promise, fallback: T ): (input: any) => Promise ``` It returns function that runs `fn` in `try/catch` block. If there was an error, then `fallback` is used to return the result. ```javascript const x = {foo: 1} const fnFoo = async () => x.foo const fnBar = async () => x.bar const result = await Promise.all([ R.tryCatchAsync (fnFoo, false)(), R.tryCatchAsync(fnBar, false)() ]) // => [1, false] ``` Try this R.tryCatchAsync example in Rambda REPL R.tryCatchAsync source ```javascript import { isFunction } from './isFunction' import { isPromise } from './isPromise' export function tryCatchAsync(fn, fallback){ return (...inputs) => new Promise(resolve => { fn(...inputs) .then(resolve) .catch(err => { if (!isFunction(fallback)){ return resolve(fallback) } if (!isPromise(fallback)){ return resolve(fallback(err, ...inputs)) } fallback(err, ...inputs).then(resolve) .catch(resolve) }) }) } ``` Tests ```javascript import { delay } from './delay' import { tryCatchAsync } from './tryCatchAsync' test('when fallback is function', async () => { const fn = async x => x.x const result = await tryCatchAsync(fn, () => 1)(null) expect(result).toBe(1) }) test('when fallback throws', async () => { const fn = async x => x.x const fallback = async (err, xx) => xx.y const result = await tryCatchAsync(fn, fallback)(null) expect(result.message).toMatchInlineSnapshot('"Cannot read property \'y\' of null"') }) test('fallback is not used', async () => { const fn = async x => x.x expect(tryCatchAsync(fn, false)({ x : 1 })).resolves.toBe(1) }) test('fallback receives error object and all initial inputs', async () => { async 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 = tryCatchAsync(thrower, catchFn) const result = await willThrow( 'A', 'B', 'C' ) expect(result).toBe('throwerError|A|B|C') }) test('when async + value fallback', async () => { const fn = async () => { await delay(100) return JSON.parse('{a:') } const result = await tryCatchAsync(fn, 'fallback')(100) expect(result).toBe('fallback') }) ``` [](#tryCatchAsync) ### type ```typescript type(x: any): RambdaTypes ``` It accepts any input and it returns its type. > :boom: `NaN`, `Promise` and `Async` are types specific for **Rambda**. ```javascript 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 R.type source ```javascript 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' } ``` Tests ```javascript 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') }) ``` [](#type) ### union ```typescript union(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. ```javascript const result = R.union([1,2,3], [3,4,5]); // => [1, 2, 3, 4, 5] ``` Try this R.union example in Rambda REPL R.union source ```javascript import { 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 } ``` Tests ```javascript 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) }) ``` [](#union) ### uniq ```typescript uniq(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. ```javascript const list = [1, 1, {a: 1}, {a: 2}, {a:1}] R.uniq(list) // => [1, {a: 1}, {a: 2}] ``` Try this R.uniq example in Rambda REPL R.uniq source ```javascript import { 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 ] ]) }) ``` [](#uniq) ### uniqWith ```typescript uniqWith(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. ```javascript const list = [ {id: 0, title:'foo'}, {id: 1, title:'bar'}, {id: 2, title:'baz'}, {id: 3, title:'foo'}, {id: 4, title:'bar'}, ] const expected = [ {id: 0, title:'foo'}, {id: 1, title:'bar'}, {id: 2, title:'baz'}, ] const predicate = (x,y) => x.title === y.title const result = R.uniqWith(predicate, list) // => `result` is equal to `expected` ``` Try this R.uniqWith example in Rambda REPL R.uniqWith source ```javascript 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 } ``` 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) }) ``` [](#uniqWith) ### unless ```typescript unless(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. ```javascript const fn = R.unless( x => x > 2, x => x + 10 ) const result = [ fn(1), fn(5) ] // => [11, 5] ``` Try this R.unless example in Rambda REPL R.unless source ```javascript export function unless(predicate, whenFalse){ if (arguments.length === 1){ return _whenFalse => unless(predicate, _whenFalse) } return input => { if (predicate(input)) return input return whenFalse(input) } } ``` Tests ```javascript 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) }) ``` [](#unless) ### update ```typescript update(index: number, newValue: T, list: readonly T[]): readonly T[] ``` It returns a copy of `list` with updated element at `index` with `newValue`. ```javascript const index = 2 const newValue = 88 const list = [1, 2, 3, 4, 5] const result = R.update(index, newValue, list) // => [1, 2, 88, 4, 5] ``` Try this R.update example in Rambda REPL R.update source ```javascript import { curry } from './curry' function updateFn( index, newValue, list ){ const arrClone = list.slice() return arrClone.fill( newValue, index, index + 1 ) } export const update = curry(updateFn) ``` Tests ```javascript 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) }) ``` [](#update) ### updateObject ```typescript updateObject(rules: readonly (readonly [string, any])[], input: object): Output ``` Very similar to `R.assocPath` but it applies list of updates instead of only a single update. It return a copy of `obj` input with changed properties according to `rules` input. Each instance of `rules` is a tuple of object path and the new value for this path. If such object path does not exist, then such object path is created. As it uses `R.path` underneath, object path can be either string or array of strings(in Typescript object path can be only a string). ```javascript const obj = { a: {b: 1}, foo: {bar: 10}, } const rules = [ ['a.b', 2], ['foo.bar', 20], ['q.z', 300], ] const result = R.updateObject(rules, obj) const expected = { a: {b: 2}, foo: {bar: 20}, q: {z: 300}, } // => `result` is equal to `expected` ``` Try this R.updateObject example in Rambda REPL R.updateObject source ```javascript import { assocPath } from './assocPath' export function updateObject(rules, obj){ if (arguments.length === 1) return _obj => updateObject(rules, _obj) let clone = { ...obj } /*?.*/ rules.forEach(([ objectPath, newValue ]) => { clone = assocPath( objectPath, newValue, clone ) }) return clone } ``` Tests ```javascript import { updateObject } from './updateObject' const obj = { a : { b : 1 }, foo : { bar : 10 }, } const rules = [ [ 'a.b', 2 ], [ 'foo.bar', 20 ], [ 'q.z', 300 ], ] const expected = { a : { b : 2 }, foo : { bar : 20 }, q : { z : 300 }, } test('happy', () => { const result = updateObject(rules, obj) expect(result).toEqual(expected) }) test('curried', () => { const result = updateObject(rules)(obj) expect(result).toEqual(expected) }) ``` [](#updateObject) ### values ```typescript values(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. ```javascript const obj = {a:1, b:2} R.values(obj) // => [1, 2] ``` Try this R.values example in Rambda REPL R.values source ```javascript import { type } from './type' 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([]) }) ``` [](#values) ### view ```typescript view(lens: Lens): (target: T) => U ``` It returns the value of `lens` focus over `target` object. ```javascript 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 R.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 } ``` Tests ```javascript 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') }) ``` [](#view) ### viewOr ```typescript viewOr(fallback: Output, lens: Lens, input: Input): Output ``` A combination between `R.defaultTo` and `R.view. ```javascript const lens = R.lensProp('a'); const input = {a: 'foo'} const fallbackInput = {b: 'bar'} const fallback = 'FALLBACK' const result = [ R.viewOr(fallback, lens, input), R.viewOr(fallback, lens, fallbackInput) ] // => ['foo', 'FALLBACK'] ``` Try this R.viewOr example in Rambda REPL R.viewOr source ```javascript import { curry } from './curry' import { defaultTo } from './defaultTo' import { view } from './view' function viewOrFn( fallback, lens, input ){ return defaultTo(fallback, view(lens, input)) } export const viewOr = curry(viewOrFn) ``` Tests ```javascript import { lensProp } from './lensProp' import { viewOr } from './viewOr' const lens = lensProp('a') const input = { a : 'foo' } const fallbackInput = { b : 'bar' } const fallback = 'FALLBACK' test('happy', () => { const result = viewOr( fallback, lens, fallbackInput ) expect(result).toBe(fallback) }) test('curried', () => { const result = viewOr(fallback, lens)(input) expect(result).toBe('foo') }) ``` [](#viewOr) ### wait ```typescript wait(fn: Promise): Promise ``` It provides `Golang`-like interface for handling promises. ```javascript const [result, err] = await R.wait(R.delay(1000)) // => err is undefined // => result is `RAMBDAX_DELAY` ``` Try this R.wait example in Rambda REPL R.wait source ```javascript export function wait(fn){ return new Promise(resolve => { fn.then(result => resolve([ result, undefined ])).catch(e => resolve([ undefined, e ])) }) } ``` Tests ```javascript import { wait } from './wait' test('happy path', async () => { const fn = x => Promise.resolve(x + 1) const [ result, err ] = await wait(fn(1)) expect(result).toBe(2) expect(err).toBeUndefined() }) test('when promise is rejected', async () => { const fn = x => Promise.reject(Error('foo')) const [ result, err ] = await wait(fn(1)) expect(result).toBeUndefined() expect(err).toEqual(Error('foo')) }) ``` [](#wait) ### waitFor ```typescript waitFor( waitForTrueCondition: () => boolean, howLong: number, loops?: number ): () => Promise ``` It returns `true`, if `condition` returns `true` within `howLong` milisececonds time period. The method accepts an optional third argument `loops`(default to 10), which is the number of times `waitForTrueCondition` will be evaluated for `howLong` period. Once this function returns a value different from `false`, this value will be the final result. Otherwise, `R.waitFor` will return `false`. ```javascript const howLong = 1000 let counter = 0 const waitForTrueCondition = async x => { await R.delay(100) counter = counter + x return counter > 10 } const result = await R.waitFor(waitForTrueCondition, howLong)(2) // => true ``` Try this R.waitFor example in Rambda REPL R.waitFor source ```javascript import { delay } from './delay' import { range } from './range' import { type } from './type' export function waitFor( condition, howLong, loops = 10 ){ const typeCondition = type(condition) const passPromise = typeCondition === 'Async' const passFunction = typeCondition === 'Function' const interval = Math.floor(howLong / loops) if (!(passPromise || passFunction)){ throw new Error('R.waitFor') } return async (...inputs) => { for (const _ of range(0, loops)){ const resultCondition = await condition(...inputs) if (resultCondition === false){ await delay(interval) } else { return resultCondition } } return false } } ``` Tests ```javascript import { delay } from './delay' import { waitFor } from './waitFor' const howLong = 1000 test('true', async () => { let counter = 0 const condition = x => { counter++ return counter > x } const result = await waitFor(condition, howLong)(6) expect(result).toEqual(true) }) test('false', async () => { let counter = 0 const condition = x => { counter++ return counter > x } const result = await waitFor(condition, howLong)(12) expect(result).toEqual(false) }) test('async condition | true', async () => { let counter = 0 const condition = async x => { counter++ await delay(10) return counter > x } const result = await waitFor(condition, howLong)(6) expect(result).toEqual(true) }) test('async condition | false', async () => { let counter = 0 const condition = async x => { counter++ await delay(10) return counter > x } const result = await waitFor(condition, howLong)(12) expect(result).toEqual(false) }) test('throws when fn is not function', () => { const fn = 'foo' expect(() => waitFor(fn, howLong)()).toThrowWithMessage(Error, 'R.waitFor') }) ``` [](#waitFor) ### when ```typescript when(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): T | U ``` R.when source ```javascript import { curry } from './curry' function whenFn( predicate, whenTrueFn, input ){ if (!predicate(input)) return input return whenTrueFn(input) } export const when = curry(whenFn) ``` Tests ```javascript 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') }) ``` [](#when) ### where ```typescript where(conditions: T, input: U): boolean ``` It returns `true` if all each property in `conditions` returns `true` when applied to corresponding property in `input` object. ```javascript 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 R.where source ```javascript 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 } ``` Tests ```javascript 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) }) ``` [](#where) ### whereEq ```typescript whereEq(condition: T, input: U): boolean ``` It will return `true` if all of `input` object fully or partially include `rule` object. ```javascript 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 R.whereEq source ```javascript 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 } ``` Tests ```javascript 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') }) ``` [](#whereEq) ### without ```typescript without(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. ```javascript 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 R.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 ]) }) ``` [](#without) ### xnor ```typescript xnor(x: boolean, y: boolean): boolean ``` Logical XNOR ```javascript const result = [ R.xnor(1, 0), R.xnor(0, 1), R.xnor(0, 0), R.xnor(1, 1), ] // => [true, false, false, true] ``` Try this R.xnor example in Rambda REPL R.xnor source ```javascript export function xnor(x, y){ if (arguments.length === 1){ return _y => xnor(x, _y) } return Boolean(x && y || !x && !y) } ``` Tests ```javascript import { xnor } from './xnor' test('when true', () => { expect(xnor(1, 1)).toBeTrue() expect(xnor(0)(0)).toBeTrue() }) test('when false', () => { expect(xnor(0, 1)).toBeFalse() }) ``` [](#xnor) ### xor ```typescript xor(x: boolean, y: boolean): boolean ``` Logical XOR ```javascript const result = [ xor(true, true), xor(false, false), xor(false, true), ] // => [false, false, true] ``` Try this R.xor example in Rambda REPL 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) }) ``` [](#xor) ### zip ```typescript zip(x: readonly K[], y: readonly V[]): readonly KeyValuePair[] ``` 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. ```javascript 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 R.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) }) ``` [](#zip) ### zipObj ```typescript zipObj(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. ```javascript 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 R.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() }) ``` [](#zipObj) ### zipWith ```typescript zipWith(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): readonly TResult[] ``` ```javascript 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 R.zipWith source ```javascript 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) ``` Tests ```javascript 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 ]) }) ``` [](#zipWith) ## ❯ CHANGELOG 7.2.0 - Approve [PR #61](https://github.com/selfrefactor/rambda/pull/61) - fix wrong `R.isValid` typings - R.produceAsync returns promise even if all rules are synchronous. - `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](https://github.com/selfrefactor/rambda/issues/561) - export several internal TS interfaces and types - Add `CHANGELOG.md` file in release files list 7.1.0 - Add `R.tryCatchAsync` - Add `R.xnor` - `R.equals` supports equality of functions. - Close [Issue #559](https://github.com/selfrefactor/rambda/issues/559) - improve `R.propOr` typings - Close [Issue #560](https://github.com/selfrefactor/rambda/issues/560) - apply immutable lint to Typescript definitions - Close [Issue #553](https://github.com/selfrefactor/rambda/issues/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` 7.0.1 - Fix missing `Evolved` declaration in Typescript definition 7.0.0 - Rename `R.produce` to `R.produceAsync` - Add `R.produce` which is synchronous version of `R.produceAsync` - Stop supporting expression inside template's props. Also, spaces are no longer allowed between `{{` and `}}`, i.e. `R.interpolate('{{ foo }}', x)` should be `R.interpolate('{{foo}}', x)`. - Add typings for `R.takeWhile` when iterable is a string - Add `R.takeLastWhile` - Add `R.dropWhile` - Add `R.eqProps` - Add `R.dropLastWhile` - Add `R.dropRepeats` - Add `R.dropRepeatsWith` - Add `R.evolve` 6.2.0 - `R.switcher` accepts `undefined` as valid input - Add `R.props` - Add `R.zipWith` - Add `R.splitAt` - Add `R.splitWhen` - Close [Issue #547](https://github.com/selfrefactor/rambda/issues/547) - restore `readonly` declaration in Rambda Typescript definitions. - `R.append`/`R.prepend` now work only with arrays just like Ramda. Previous behaviour was for them to work with both arrays and strings. - Sync `R.pluck` typings with `@types/ramda` as there was a tiny difference. 6.1.0 - Add `R.mapIndexed` - Add `R.filterIndexed` - Add `R.forEachIndexed` - Fix `R.and` wrong definition, because the function doesn't convert the result to boolean. This introduce another difference with `@types/ramda`. - Add `R.once` - Add `R.or` 6.0.0 - Breaking change - `R.map`/`R.filter`/`R.reject`/`R.forEach`/`R.partition` doesn't pass index as second argument to the predicate, when looping over arrays. The old behaviour of *map*, *filter* and *forEach* can be found in Rambdax methods *R.mapIndexed*, *R.filterIndexed* and *R.forEachIndexed*(introduced in version `6.1.0`). - Breaking change - `R.all`/`R.none`/`R.any`/`R.find`/`R.findLast`/`R.findIndex`/`R.findLastIndex` doesn't pass index as second argument to the predicate. - Add `R.applyDiff` method - Change `R.assocPath` typings so the user can explicitly sets type of the new object - Typings of `R.assoc` match its `@types/ramda` counterpart. - Simplify `R.forEach` typings - Remove `ReadonlyArray` pattern from Typescript definitions - not enough value for the noise it adds. - Fix typing of `R.reject` as it wrongly declares that with object, it pass property to predicate. 5.1.0 - Add `R.takeUntil` method - Fix wrong `R.takeWhile` 5.0.0 - Deprecate `R.change` method - it does too much; partially replaced with `R.updateObject`. - Deprecate `R.compact` method - vague use case; `R.filter` does the same job. - `R.produce` always returns a promise - Add `R.updateObject` method - Add `R.takeWhile` method - Add `R.viewOr` method - Add `R.pipeAsync` method - Add `R.removeIndex` method - Add `R.excludes` method - `R.includes` throws on wrong input, i.e. `R.includes(1, null)` - Close [Issue #524](https://github.com/selfrefactor/rambda/issues/524) - `R.assocPath` wrong logic when number is used in array path input. - `R.mapToObjectAsync` supports currying - `R.mapAsyncLimit` supports currying - Fix `R.mapAsync` to pass property to iterator, when input is an object. - Fix currying for several async methods - `R.tapAsync`, `R.produce`, `R.filterAsync` *(extend typings) 4.2.0 - Add `R.move` method - Add `R.union` method - Add `R.lensSatisfies` method - Add `R.mapKeys` method - Add `R.sortByPath` method - Add `R.sortByProps` method - Close [Issue #519](https://github.com/selfrefactor/rambda/issues/519) - `ts-toolbelt` needs other type of export with `--isolatedModules` flag 4.1.0 - `R.template` is renamed to `R.interpolate` - `R.equals` now supports negative zero just like `Ramda.equals` - Add `R.replaceAll` method - Add `R.lensEq` method 4.0.1 Forgot to export `R.of` because of wrong marker in `files/index.d.ts` 4.0.0 Deprecate the following methods: - `R.promiseAllObject` - because `R.produce` serves the same purpose - `R.composed` - because `R.piped` makes more sense, when we want to pass the input at the start of the function - `R.defaultToStrict` - confusing logic - `R.findInObject` - overestimated importance - `R.headObject` - overestimated importance - `R.includesType` - overestimated importance - `R.inject` - confusing logic - `R.isAttach` - confusing logic - `R.mergeRight` - overestimated importance - `R.opposite` - overestimated importance - `R.otherwise` - overestimated importance - `R.pushUniq` - overestimated importance - `R.resolve` - overestimated importance - `R.s` - overestimated importance - `R.toggle` - overestimated importance - `R.uuid` - not suitable - `R.whenAsync` - overestimated importance Move the following methods to `Rambda` and change their logic to match `Ramda` implementation: - `R.hasPath` - `R.unless` - `R.pathEq` - `R.tryCatch` - `R.where` - `R.whereEq` Also these changes: - `R.flatMap` - renamed to `R.chain` and moved to `Rambda` - `R.ifElseAsync` - accept any number of arguments for the returned function - `R.produce`, `R.filterAsync`, `R.debounce`, `R.throttle` - fix typings - `R.mapAsyncLimit` - drop support for curring and therefore for usage with `R.composeAsync` - Improve `R.ok` throwed error message - `R.ok` returns `undefined` instead of `true` when validation passes. - `R.mergeDeep` is renamed to `R.mergeDeepLeft` - Add `R.pipeAsync` - Take `R.partialCurry` from `Rambda` as it is deprecated there 3.7.0 > Sync with Rambda Add `R.lens` Add `R.lensIndex` Add `R.lensPath` Add `R.lensProp` Add `R.over` Add `R.set` Add `R.view` Add `R.paths` Add `R.xor` Add `R.cond` 3.6.0 - Add `R.mapAsyncLimit` - Add `R.toggle`, match Ramda upcoming method specification - Add `R.isValidAsync` - Extend `R.template` without introducing breaking change 3.5.0 Sync with `Rambda` - add methods descriptions to Typescript definitions 3.4.0 Sync with `Rambda` and close [Issue #42](https://github.com/selfrefactor/rambdax/pull/42) 3.3.0 Fix `R.sortObject` typing 3.3.0 Add `R.filterAsync` and `R.sortObject` methods 3.2.0 `R.uuid` accept second argument in order to return string only uuid 3.1.0 Dynamic set of exports lead to adding previously ommited Rambda exports such as `R.identical` 3.0.3 Sync with Rambda - new functionality of `R.isEmpty` 3.0.2 Add typings for `R.mapToObject` 3.0.1 Fix typings 3.0.0 Breaking change as `Rambda` also has breaking changes Read more about it in `Rambda` changelog Also with this versions, typings tests are provided and several definitions are changed. - R.anyTrue, R.anyFalse, R.allTrue, R.allFalse use internal `isTruthy` and `isFalsy` methods. Empty array and object with zero length are considered falsy. - Deprecate `R.contains` - Deprecate `R.defaultToWhen` - Moved `R.runTests` to `helpers` repo 2.17.0 Change in `R.runTests` logic. It will be removed from Rambdax to `helpers` repo. 2.16.0 Restore `R.runTests` but without documentation - export `getEvaluations`, `getPositiveEvaluation`, `getNegativeEvaluation` in the context of `R.runTests` 2.15.0 Several changes - Typescript definitions have been updated and typings tests are introduced - `R.mapAsync` and `R.mapFastAsync` pass index as second argument 2.14.1 Restore `R.contains` 2.14.0 Several changes: - `R.inject` accept before flag as fourth argument - Remove `R.includesAny` - Improve typing of `R.partition` - `R.nextIndex` and `R.prevIndex` work also with number as second argument 2.13.1 Deprecate `R.log` and `R.runTests` 2.12.3 Add 'dist' directory to `files` 2.12.2 Add `R.mapToObject` typings 2.12.0 Sync with Rambda 2.11.1 Fix `R.waitFor` 2.11.0 Add `R.toDecimal` 2.10.2 Fix [issue 32](https://github.com/selfrefactor/rambdax/issues/32) 2.10.0 deprecate `R._` 2.9.1 R.fromPairs/toPairs typing 2.9.0 npm doesn't update version on their site 2.8.2 R.map typing 2.8.0 Sync with Rambda | no need for create types script 2.7.0 Add `R.prevIndex` 2.6.2 Sync with Rambda 2.6.0 `R.log` depends on `RAMBDAX_LOG` 2.5.0 Rambda's `partial` 2.4.0 Add `R.uuid` 2.3.0 `R._` parse to constant case > This introduce breaking change for ie11 as noted in [issue 31](https://github.com/selfrefactor/rambdax/issues/31) which is fixed with `2.10.0` which deprecates this method 2.2.1 Add `R.log`, `R.logInit` and `R.logHolder` 2.1.0 Add `R._` 2.0.0 Add `R.toggle` 1.9.0 Add `R.pushUniq` 1.8.2 No need for sourcemaps 1.8.1 Fix building with `regeneratorRuntime` 1.8.0 Upgrade to new major Rollup release - Restore `R.headObject` - Add `R.hasPath` method 1.7.2 `R.memoize` contains dev console.logs 1.7.1 Forgot to build types 1.7.0 Rename `R.then` to `R.resolve` because of Ramda issue with `R.then`(they rename it to `R.andThen`) - Add `R.isFalsy`, `R.nextIndex` and `R.mergeDeep` 1.6.3 Forgot to export `R.unless`(credit to @mobily for the PR) 1.6.0 Restore `R.compact` method 1.5.6 `R.maybe` accepts also anonymous functions as second and third argument 1.5.5 Add `R.maybe` method - Fix errors caugth by `DeepScan` service - Fix Typescript definitions for `R.then` and `R.otherwise` - `R.change` increase nesting level to 4 1.4.1 `R.isValid` didn't work with `Number` prototype 1.4.0 Add multiple methods - Add `R.defaultToStrict` - Add `R.defaultToWhen` - Add `R.whereEq` - Add `R.partition` - Add `R.negate` is renamed to `R.opposite` - Add `R.then` - Add `R.otherwise` - `R.isValid` accepts prototypes as rules, i.e. `schema = {a: String}` - The prevoious point leads to the same change applied to the methods depending on `R.isValid`, i.e. `R.ok`, `R.pass` and `R.isAttach` 1.3.0 Add `R.unless` - `R.when` accepts both function and value for `whenTrue` argument. The same is valid for `R.unless` - export `R.negate` which is the same as `R.complement` 1.2.0 Export `src` folder 1.1.0 Restore `promiseAllObject` and `flatMap` 1.0.1 Fix typings 1.0.0 Deprecate the following methods: - compact - evolve - flatMap - greater - intersection - less - omitBy - pickBy - promiseAllObject - promiseAllSecure - rangeBy > Also pass deprecation of `addIndex` from `Rambda@2.0.0` 0.24.0 add `R.pipedAsync`, replace `R.multiline` with `R.glue`, remove `R.validate` 0.23.0 Add `R.count` 0.22.0 Add `R.includesAny` 0.21.0 Add `R.includesType` 0.20.1 `R.pass` and `R.ok` work with single schema. 0.20.0 Add `R.pathEq` 0.19.0 Add `R.wait`, expose already complete `R.waitFor` 0.18.0 Add`R.anyType` and `R.allType` 0.17.0 Rename `R.is` to `R.pass` and restore `R.is` original functionality. 0.16.0 getter, setter, reset methods 0.15.3 No more `prepublish` script 0.15.2 curry in `remove` > Last version with `lib` folder exposed [](#-changelog) ## ❯ Additional info > Most influential contributors - [@farwayer](https://github.com/farwayer) - improving performance in R.find, R.filter; give the idea how to make benchmarks more reliable; - [@thejohnfreeman](https://github.com/thejohnfreeman) - add R.assoc, R.chain; - [@helmuthdu](https://github.com/helmuthdu) - add R.clone; help improve code style; - [@jpgorman](https://github.com/jpgorman) - add R.zip, R.reject, R.without, R.addIndex; - [@ku8ar](https://github.com/ku8ar) - add R.slice, R.propOr, R.identical, R.propIs and several math related methods; introduce the idea to display missing Ramda methods; - [@romgrk](https://github.com/romgrk) - add R.groupBy, R.indexBy, R.findLast, R.findLastIndex; - [@squidfunk](https://github.com/squidfunk) - add R.assocPath, R.symmetricDifference, R.difference, R.intersperse; - [@synthet1c](https://github.com/synthet1c) - add all lenses methods; add R.applySpec, R.converge; - [@vlad-zhukov](https://github.com/vlad-zhukov) - help with configuring Rollup, Babel; change export file to use ES module exports; > Rambda references - [Interview with Dejan Totef at SurviveJS blog](https://survivejs.com/blog/rambda-interview/) - [Awesome functional Javascript programming libraries](https://github.com/stoeffel/awesome-fp-js#libraries) > Links to Rambda - [https://mailchi.mp/webtoolsweekly/web-tools-280](Web Tools Weekly) - [https://github.com/stoeffel/awesome-fp-js](awesome-fp-js) - [https://github.com/docsifyjs/awesome-docsify](awesome-docsify) > Deprecated from `Used by` section - [SAP's Cloud SDK](https://github.com/SAP/cloud-sdk) - This repo doesn't uses `Rambda` since *October/2020* [commit that removes Rambda](https://github.com/SAP/cloud-sdk/commit/b29b4f915c4e4e9c2441e7b6b67cf83dac1fdac3) > Releases [Rambda's releases](https://github.com/selfrefactor/rambda/releases) before **6.4.0** were used mostly for testing purposes. [](#-additional-info) ## My other libraries Niketa theme Collection of 9 light VSCode themes Niketa dark theme Collection of 9 dark VSCode themes String-fn String utility library Useful Javascript libraries Large collection of JavaScript,Typescript and Angular related repos links Run-fn CLI commands for lint JS/TS files, commit git changes and upgrade of dependencies
(propsToPick: readonly P[], obj: Record): readonly T[] ``` It takes list with properties `propsToPick` and returns a list with property values in `obj`. ```javascript const result = [ R.props(['a', 'b'], {a:1, c:3}) // => [1, undefined] ``` Try this R.props example in Rambda REPL R.props source ```javascript import { _isArray } from './_internals/_isArray' 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) } ``` Tests ```javascript 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() }) ``` [](#props) ### random ```typescript random(minInclusive: number, maxInclusive: number): number ``` It returns a random number between `min` inclusive and `max` inclusive. R.random source ```javascript export function random(min, max){ return Math.floor(Math.random() * (max - min + 1)) + min } ``` Tests ```javascript import { random } from './random' import { range } from './range' test('when returns true', () => { range(0, 100).map(() => { const randomResult = random(1, 10) expect(randomResult).toBeLessThanOrEqual(10) expect(randomResult).toBeGreaterThanOrEqual(1) }) }) ``` [](#random) ### range ```typescript range(startInclusive: number, endExclusive: number): readonly number[] ``` It returns list of numbers between `startInclusive` to `endExclusive` markers. ```javascript R.range(0, 5) // => [0, 1, 2, 3, 4] ``` Try this R.range example in Rambda REPL R.range source ```javascript export function range(start, end){ if (arguments.length === 1) return _end => range(start, _end) if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){ throw new TypeError('Both arguments to range must be numbers') } if (end < start) return [] const len = end - start const willReturn = Array(len) for (let i = 0; i < len; i++){ willReturn[ i ] = start + i } return willReturn } ``` Tests ```javascript import { range } from './range' test('happy', () => { expect(range(0, 10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]) }) test('end range is bigger than start range', () => { expect(range(7, 3)).toEqual([]) expect(range(5, 5)).toEqual([]) }) test('with bad input', () => { const throwMessage = 'Both arguments to range must be numbers' expect(() => range('a', 6)).toThrowWithMessage(Error, throwMessage) expect(() => range(6, 'z')).toThrowWithMessage(Error, throwMessage) }) test('curry', () => { expect(range(0)(10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]) }) ``` [](#range) ### reduce ```typescript reduce(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 `reducer` function. ```javascript 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 R.reduce source ```javascript 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) ``` Tests ```javascript 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') }) ``` [](#reduce) ### reject ```typescript reject(predicate: Predicate, list: readonly T[]): readonly T[] ``` It has the opposite effect of `R.filter`. ```javascript const list = [1, 2, 3, 4] const obj = {a: 1, b: 2} const predicate = x => x > 1 const result = [ R.reject(predicate, list) R.reject(predicate, obj) ] // => [[1, 2], {a: 1}] ``` Try this R.reject example in Rambda REPL R.reject source ```javascript import { filter } from './filter' export function reject(predicate, list){ if (arguments.length === 1) return _list => reject(predicate, _list) return filter(x => !predicate(x), list) } ``` Tests ```javascript import { reject } from './reject' const isOdd = n => n % 2 === 1 test('with array', () => { expect(reject(isOdd)([ 1, 2, 3, 4 ])).toEqual([ 2, 4 ]) }) test('with object', () => { const obj = { a : 1, b : 2, c : 3, d : 4, } expect(reject(isOdd, obj)).toEqual({ b : 2, d : 4, }) }) ``` [](#reject) ### remove ```typescript remove( toRemove: string | RegExp | readonly (string | RegExp)[], text: string ): string ``` It will remove all `toRemove` entries from `text` sequentially. `toRemove` argument can be either a list of strings/regular expressions or a single string/regular expression. > :boom: This is the only case where Rambdax exports clashes with Ramda API, as Ramda has `remove` method. If `Rambda.remove` is introduced, then this method will be renamed. ```javascript const result = remove( ['foo','bar'], 'foo bar baz foo' ) // => 'baz foo' ``` Try this R.remove example in Rambda REPL R.remove source ```javascript import { replace } from './replace' import { type } from './type' export function remove(inputs, text){ if (arguments.length === 1){ return textHolder => remove(inputs, textHolder) } if (type(text) !== 'String'){ throw new Error(`R.remove requires string not ${ type(text) }`) } if (type(inputs) !== 'Array'){ return replace( inputs, '', text ) } let textCopy = text inputs.forEach(singleInput => { textCopy = replace( singleInput, '', textCopy ).trim() }) return textCopy } ``` Tests ```javascript import { remove } from './remove' test('happy', () => { const inputs = [ /foo/, /not\shere/, /also/, 'bar' ] const text = 'foo bar baz foo' const result = remove(inputs)(text) const expectedResult = 'baz foo' expect(result).toEqual(expectedResult) }) test('with strings + curry', () => { const inputs = [ 'foo', 'bar' ] const text = 'foo bar baz foo' const result = remove(inputs)(text) const expectedResult = 'baz foo' expect(result).toEqual(expectedResult) }) test('with strings and regex', () => { const inputs = [ /foo/g, 'bar' ] const text = 'foo bar baz foo' const result = remove(inputs, text) const expectedResult = 'baz' expect(result).toEqual(expectedResult) }) test('text is not string', () => { const inputs = [ /foo/g, 'bar' ] const text = null expect(() => remove(inputs, text)).toThrowWithMessage(Error, 'R.remove requires string not Null') }) test('with regexes', () => { const inputs = [ /foo/g, /bar/ ] const text = 'foo bar baz foo' const result = remove(inputs, text) const expectedResult = 'baz' expect(result).toEqual(expectedResult) }) test('with single rule', () => { const inputs = /foo/g const text = 'foo bar baz foo' const result = remove(inputs, text) const expectedResult = ' bar baz ' expect(result).toEqual(expectedResult) }) ``` [](#remove) ### removeIndex ```typescript removeIndex(index: number, list: readonly T[]): readonly T[] ``` It returns a copy of `list` input with removed `index`. ```javascript const list = [1, 2, 3, 4] const result = R.removeIndex(1, list) // => [1, 3, 4] ``` Try this R.removeIndex example in Rambda REPL R.removeIndex source ```javascript export function removeIndex(list, index){ if (arguments.length === 1) return _index => removeIndex(list, _index) if (index <= 0) return list.slice(1) if (index >= list.length - 1) return list.slice(0, list.length - 1) return [ ...list.slice(0, index), ...list.slice(index + 1) ] } ``` Tests ```javascript import { removeIndex } from './removeIndex' const list = [ 1, 2, 3, 4 ] test('first or before first index', () => { expect(removeIndex(list, 0)).toEqual([ 2, 3, 4 ]) expect(removeIndex(list)(-2)).toEqual([ 2, 3, 4 ]) }) test('last or after last index', () => { expect(removeIndex(list, 4)).toEqual([ 1, 2, 3 ]) expect(removeIndex(list, 10)).toEqual([ 1, 2, 3 ]) }) test('middle index', () => { expect(removeIndex(list, 1)).toEqual([ 1, 3, 4 ]) expect(removeIndex(list, 2)).toEqual([ 1, 2, 4 ]) }) ``` [](#removeIndex) ### renameProps ```typescript renameProps(rules: object, input: object): object ``` If property `prop` of `rules` is also a property in `input`, then rename `input` property to `rules[prop]`. R.renameProps source ```javascript import { merge } from './merge' import { omit } from './omit' export function renameProps(conditions, inputObject){ if (arguments.length === 1){ return inputObjectHolder => renameProps(conditions, inputObjectHolder) } const renamed = {} Object.keys(conditions).forEach(condition => { if (Object.keys(inputObject).includes(condition)){ renamed[ conditions[ condition ] ] = inputObject[ condition ] } }) return merge(renamed, omit(Object.keys(conditions), inputObject)) } ``` Tests ```javascript import { renameProps } from './renameProps' test('renameProps', () => { const rules = { f : 'foo', b : 'bar', } const input = { f : 1, b : 2, } const result = renameProps(rules, input) const expectedResult = { foo : 1, bar : 2, } expect(result).toEqual(expectedResult) }) test('curry', () => { const rules = { f : 'foo', b : 'bar', } const input = { f : 1, b : 2, } const result = renameProps(rules)(input) const expectedResult = { foo : 1, bar : 2, } expect(result).toEqual(expectedResult) }) ``` [](#renameProps) ### repeat ```typescript repeat(x: T): (timesToRepeat: number) => readonly T[] ``` ```javascript R.repeat('foo', 3) // => ['foo', 'foo', 'foo'] ``` Try this R.repeat example in Rambda REPL R.repeat source ```javascript export function repeat(x, timesToRepeat){ if (arguments.length === 1){ return _timesToRepeat => repeat(x, _timesToRepeat) } return Array(timesToRepeat).fill(x) } ``` Tests ```javascript import { repeat } from './repeat' test('repeat', () => { expect(repeat('')(3)).toEqual([ '', '', '' ]) expect(repeat('foo', 3)).toEqual([ 'foo', 'foo', 'foo' ]) const obj = {} const arr = repeat(obj, 3) expect(arr).toEqual([ {}, {}, {} ]) expect(arr[ 0 ] === arr[ 1 ]).toBeTrue() }) ``` [](#repeat) ### replace ```typescript replace(strOrRegex: RegExp | string, replacer: string, str: string): string ``` It replaces `strOrRegex` found in `str` with `replacer`. ```javascript const strOrRegex = /o/g const result = R.replace(strOrRegex, '|0|', 'foo') // => 'f|0||0|' ``` Try this R.replace example in Rambda REPL R.replace source ```javascript import { curry } from './curry' function replaceFn( pattern, replacer, str ){ return str.replace(pattern, replacer) } export const replace = curry(replaceFn) ``` 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') }) ``` [](#replace) ### replaceAll ```typescript replaceAll(patterns: ReadonlyArray, replacer: string, input: string): string ``` Same as `R.replace` but it accepts array of string and regular expressions instead of a single value. ```javascript const replacer = '|' const patterns = [ /foo/g, 'bar' ] const input = 'foo bar baz foo bar' const result = replaceAll(patterns, replacer, input) // => '| | baz | bar' ``` Try this R.replaceAll example in Rambda REPL R.replaceAll source ```javascript import { curry } from './curry' import { ok } from './ok' function replaceAllFn( patterns, replacer, input ){ ok( patterns, replacer, input )( Array, String, String ) let text = input patterns.forEach(singlePattern => { text = text.replace(singlePattern, replacer) }) return text } export const replaceAll = curry(replaceAllFn) ``` Tests ```javascript import { replaceAll } from './replaceAll' const replacer = '|' const patterns = [ /foo/g, 'bar' ] const input = 'foo bar baz foo bar' test('happy', () => { const result = replaceAll( patterns, replacer, input ) const expected = '| | baz | bar' expect(result).toEqual(expected) }) test('throws when wrong patterns', () => { expect(() => replaceAll( {}, replacer, input )).toThrow() }) test('throws when wrong input', () => { expect(() => replaceAll( patterns, replacer, [] )).toThrow() }) test('throws when wrong replacer', () => { expect(() => replaceAll( patterns, null, input )).toThrow() }) ``` [](#replaceAll) ### reset ```typescript reset(): void ``` > :boom: `R.getter` method contains explanations, tests and source information of `R.reset`, `R.setter` and `R.getter` methods. [](#reset) ### reverse ```typescript reverse(input: readonly T[]): readonly T[] ``` It returns a reversed copy of list or string `input`. ```javascript const result = [ R.reverse('foo'), R.reverse([1, 2, 3]) ] // => ['oof', [3, 2, 1] ``` Try this R.reverse example in Rambda REPL R.reverse source ```javascript export function reverse(listOrString){ if (typeof listOrString === 'string'){ return listOrString.split('').reverse() .join('') } const clone = listOrString.slice() return clone.reverse() } ``` Tests ```javascript import { reverse } from './reverse' 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 ]) }) ``` [](#reverse) ### set ```typescript set(lens: Lens, replacer: U, obj: T): T ``` It returns a copied **Object** or **Array** with modified `lens` focus set to `replacer` value. ```javascript const input = {x: 1, y: 2} const xLens = R.lensProp('x') 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 R.set source ```javascript 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) ``` Tests ```javascript 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 ]) }) ``` [](#set) ### setter ```typescript setter(keyOrObject: string | object, value?: any): void ``` > :boom: `R.getter` method contains explanations, tests and source information of `R.reset`, `R.setter` and `R.getter` methods. [](#setter) ### shuffle ```typescript shuffle(list: readonly T[]): readonly T[] ``` It returns a randomized copy of array. R.shuffle source ```javascript export function shuffle(arrayRaw){ const array = arrayRaw.concat() let counter = array.length while (counter > 0){ const index = Math.floor(Math.random() * counter) counter-- const temp = array[ counter ] array[ counter ] = array[ index ] array[ index ] = temp } return array } ``` Tests ```javascript import { range } from './range' import { shuffle } from './shuffle' import { uniq } from './uniq' test('happy', () => { const list = range(0, 7) const result = range(0, 300).map(() => shuffle(list)) const allUniq = uniq(result) expect(allUniq.length > 150).toBeTrue() }) ``` [](#shuffle) ### slice ```typescript slice(from: number, to: number, input: string): string ``` ```javascript const list = [0, 1, 2, 3, 4, 5] const str = 'FOO_BAR' const from = 1 const to = 4 const result = [ R.slice(str, to, list), R.slice(from, to, list) ] // => ['OO_', [1, 2, 3]] ``` Try this R.slice example in Rambda REPL R.slice source ```javascript import { curry } from './curry' 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') }) ``` [](#slice) ### sort ```typescript sort(sortFn: (a: T, b: T) => number, list: readonly T[]): readonly T[] ``` It returns copy of `list` sorted by `sortFn` function. > :boom: `sortFn` function must return a number. ```javascript const list = [ {a: 2}, {a: 3}, {a: 1} ] const sortFn = (x, y) => { return x.a > y.a ? 1 : -1 } const result = R.sort(sortFn, list) const expected = [ {a: 1}, {a: 2}, {a: 3} ] // => `result` is equal to `expected` ``` Try this R.sort example in Rambda REPL R.sort source ```javascript 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') }) ``` [](#sort) ### sortBy ```typescript sortBy(sortFn: (a: T) => Ord, list: readonly T[]): readonly T[] ``` It returns copy of `list` sorted by `sortFn` function. > :boom: `sortFn` function must return a value to compare. ```javascript const list = [ {a: 2}, {a: 3}, {a: 1} ] const sortFn = x => x.a const result = R.sortBy(sortFn, list) const expected = [ {a: 1}, {a: 2}, {a: 3} ] // => `result` is equal to `expected` ``` Try this R.sortBy example in Rambda REPL R.sortBy source ```javascript 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' test('happy', () => { const input = [ { a : 2 }, { a : 1 }, { a : 1 }, { a : 3 } ] const expected = [ { a : 1 }, { a : 1 }, { a : 2 }, { a : 3 } ] const result = sortBy(x => x.a)(input) expect(result).toEqual(expected) }) test('with compose', () => { const alice = { name : 'ALICE', age : 101, } const bob = { name : 'Bob', age : -10, } const clara = { name : 'clara', age : 314.159, } const people = [ clara, bob, alice ] const sortByNameCaseInsensitive = sortBy(compose(toLower, prop('name'))) expect(sortByNameCaseInsensitive(people)).toEqual([ alice, bob, clara ]) }) ``` [](#sortBy) ### sortByPath ```typescript sortByPath(sortPath: Path, list: readonly T[]): readonly T[] ``` It returns copy of `list` sorted by `sortPath` value. As `sortPath` is passed to `R.path`, it can be either a string or an array of strings. ```javascript const list = [ {a: {b: 2}}, {a: {b: 1}}, {a: {b: 3}} ] const result = R.sortByPath('a.b', list) const expected = [ {a: {b: 1}}, {a: {b: 2}}, {a: {b: 3}} ] // => `result` is equal to `expected` ``` Try this R.sortByPath example in Rambda REPL R.sortByPath source ```javascript import { path } from './path' import { sortBy } from './sortBy' export function sortByPath(sortPath, list){ if (arguments.length === 1) return _list => sortByPath(sortPath, _list) return sortBy(path(sortPath), list) } ``` Tests ```javascript import { sortByPath } from './sortByPath' const list = [ { a : { b : 3 } }, { a : { b : 1 } }, { a : { b : 2 } } ] const sorted = [ { a : { b : 1 } }, { a : { b : 2 } }, { a : { b : 3 } } ] test('with string as path', () => { expect(sortByPath('a.b', list)).toEqual(sorted) }) test('with list of strings as path', () => { expect(sortByPath([ 'a', 'b' ], list)).toEqual(sorted) }) test('with string as path - curried', () => { expect(sortByPath('a.b')(list)).toEqual(sorted) }) test('with list of strings as path - curried', () => { expect(sortByPath([ 'a', 'b' ])(list)).toEqual(sorted) }) ``` [](#sortByPath) ### sortByProps ```typescript sortByProps(sortPaths: readonly string[], list: readonly T[]): readonly T[] ``` It returns sorted copy of `list` of objects. Sorting is done using a list of strings, each representing a path. Two members `a` and `b` from `list` can be sorted if both return a value for a given path. If the value is equal, then the next member of `sortPaths`(if there is such) will be used in order to find difference between `a` and `b`. ```javascript const list = [ {a: {b: 2}}, {a: {b: 1}}, {a: {b: 3}} ] const result = R.sortByPath('a.b', list) const expected = [ {a: {b: 1}}, {a: {b: 2}}, {a: {b: 3}} ] // => `result` is equal to `expected` ``` Try this R.sortByProps example in Rambda REPL R.sortByProps source ```javascript import { path } from './path' function singleSort( a, b, sortPaths ){ let toReturn = 0 sortPaths.forEach(singlePath => { if (toReturn !== 0) return const aResult = path(singlePath, a) const bResult = path(singlePath, b) if ([ aResult, bResult ].includes(undefined)) return if (aResult === bResult) return toReturn = aResult > bResult ? 1 : -1 }) return toReturn } export function sortByProps(sortPaths, list){ if (arguments.length === 1) return _list => sortByProps(sortPaths, _list) const clone = list.slice() clone.sort((a, b) => singleSort( a, b, sortPaths )) return clone } ``` Tests ```javascript import { sortByProps } from './sortByProps' const list = [ { a : { b : 3 } }, { a : { b : 2 } }, { a : { b : 1 } } ] const sorted = [ { a : { b : 1 } }, { a : { b : 2 } }, { a : { b : 3 } } ] test('wrong paths are ignored', () => { expect(sortByProps([ 'foo.bar', 'a.c', 'a.b', 'a.d' ], list)).toEqual(sorted) }) test('skip sort when path results are equal', () => { const input = [ { a : { b : 0, c : 2, }, }, { a : { b : 0, c : 1, }, }, ] expect(sortByProps([ 'a.b', 'a.d' ], input)).toEqual(input) }) test('when list is already sorted', () => { const input = [ { a : { b : 0, c : 1, }, }, { a : { b : 0, c : 2, }, }, ] expect(sortByProps([ 'a.b', 'a.c' ])(input)).toEqual(input) }) ``` [](#sortByProps) ### sortObject ```typescript sortObject(predicate: SortObjectPredicate, input: { readonly [key: string]: T }): { readonly [keyOutput: string]: T } ``` It returns a sorted version of `input` object. ```javascript const predicate = (propA, propB, valueA, valueB) => valueA > valueB ? -1 : 1 const result = R.sortObject(predicate, {a:1, b: 4, c: 2}) // => {b: 4, c: 2, a: 1} ``` Try this R.sortObject example in Rambda REPL R.sortObject source ```javascript import { sort } from './sort' export function sortObject(predicate, obj){ if (arguments.length === 1){ return _obj => sortObject(predicate, _obj) } const keys = Object.keys(obj) const sortedKeys = sort((a, b) => predicate( a, b, obj[ a ], obj[ b ] ), keys) const toReturn = {} sortedKeys.forEach(singleKey => { toReturn[ singleKey ] = obj[ singleKey ] }) return toReturn } ``` Tests ```javascript import { runTests } from 'helpers-fn' import { allTrue } from './allTrue' import { equals } from './equals' import { sortObject } from './sortObject' const obj = { c : 1, a : 2, b : 3, } const predicateA = ( propA, propB, valueA, valueB ) => propA > propB ? -1 : 1 const expectationA = [ 'c', 'b', 'a' ] const predicateB = ( propA, propB, valueA, valueB ) => propA < propB ? -1 : 1 const expectationB = [ 'a', 'b', 'c' ] const predicateC = ( propA, propB, valueA, valueB ) => valueA > valueB ? -1 : 1 const expectationC = [ 'b', 'a', 'c' ] const fn = ([ predicate, expectation ]) => { const result = sortObject(predicate, obj) const curriedResult = sortObject(predicate)(obj) const sortedKeys = Object.keys(result) const sortedKeysCurried = Object.keys(curriedResult) const isSameObject = equals(obj, result) const isSameObjectCurried = equals(obj, curriedResult) return allTrue( isSameObject, isSameObjectCurried, equals(sortedKeys, expectation), equals(sortedKeysCurried, expectation) ) } const testData = { label : 'foo', data : [ { ok : [ predicateA, expectationA ] }, { ok : [ predicateB, expectationB ] }, { ok : [ predicateC, expectationC ] }, ], fn, } runTests(testData) ``` [](#sortObject) ### split ```typescript split(separator: string | RegExp): (str: string) => readonly string[] ``` Curried version of `String.prototype.split` ```javascript const str = 'foo|bar|baz' const separator = |' const result = R.split(separator, str)) // => [ 'foo', 'bar', 'baz' ] ``` Try this R.split example in Rambda REPL R.split source ```javascript export function split(separator, str){ if (arguments.length === 1) return _str => split(separator, _str) return str.split(separator) } ``` Tests ```javascript import { split } from './split' const str = 'foo|bar|baz' const splitChar = '|' const expected = [ 'foo', 'bar', 'baz' ] test('happy', () => { expect(split(splitChar, str)).toEqual(expected) }) test('curried', () => { expect(split(splitChar)(str)).toEqual(expected) }) ``` [](#split) ### splitAt ```typescript splitAt(index: number, input: readonly T[]): readonly [readonly T[], readonly T[]] ``` It splits string or array at a given index. ```javascript const list = [ 1, 2, 3 ] const result = splitAt(2, list) // => [[ 1, 2 ], [ 3 ]] ``` Try this R.splitAt example in Rambda REPL R.splitAt source ```javascript 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) ] } ``` Tests ```javascript 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) }) }) ``` [](#splitAt) ### splitEvery ```typescript splitEvery(sliceLength: number, input: readonly T[]): readonly (readonly T[])[] ``` It splits `input` into slices of `sliceLength`. ```javascript const result = [ R.splitEvery(2, [1, 2, 3]), R.splitEvery(3, 'foobar') ] const expected = [ [[1, 2], [3]], ['foo', 'bar'] ] // => `result` is equal to `expected` ``` Try this R.splitEvery example in Rambda REPL R.splitEvery source ```javascript export function splitEvery(sliceLength, listOrString){ if (arguments.length === 1){ return _listOrString => splitEvery(sliceLength, _listOrString) } if (sliceLength < 1){ throw new Error('First argument to splitEvery must be a positive integer') } const willReturn = [] let counter = 0 while (counter < listOrString.length){ willReturn.push(listOrString.slice(counter, counter += sliceLength)) } return willReturn } ``` Tests ```javascript import { splitEvery } from './splitEvery' 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') }) ``` [](#splitEvery) ### splitWhen ```typescript splitWhen(predicate: Predicate, 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`. ```javascript const list = [1, 2, 1, 2] const result = R.splitWhen(R.equals(2), list) // => [[1], [2, 1, 2]] ``` Try this R.splitWhen example in Rambda REPL R.splitWhen source ```javascript export function splitWhen(predicate, input){ if (arguments.length === 1){ return _input => splitWhen(predicate, _input) } if (!input) throw new TypeError(`Cannot read property 'length' of ${ input }`) const preFound = [] const postFound = [] let found = false let counter = -1 while (counter++ < input.length - 1){ if (found){ postFound.push(input[ counter ]) } else if (predicate(input[ counter ])){ postFound.push(input[ counter ]) found = true } else { preFound.push(input[ counter ]) } } return [ preFound, postFound ] } ``` Tests ```javascript import { splitWhen as splitWhenRamda } from 'ramda' import { equals } from './equals' 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) }) }) ``` [](#splitWhen) ### startsWith ```typescript startsWith(target: string, str: string): boolean ``` Curried version of `String.prototype.startsWith` > :boom: It doesn't work with arrays unlike its corresponding **Ramda** method. ```javascript const str = 'foo-bar' const result = [ R.startsWith('foo', str), R.startsWith('bar', str) ] // => [true, false] ``` Try this R.startsWith example in Rambda REPL 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() }) ``` [](#startsWith) ### subtract Curried version of `x - y` ```javascript const x = 3 const y = 1 R.subtract(x, y) // => 2 ``` Try this R.subtract example in Rambda REPL [](#subtract) ### sum ```typescript sum(list: readonly number[]): number ``` ```javascript R.sum([1, 2, 3, 4, 5]) // => 15 ``` Try this R.sum example in Rambda REPL R.sum source ```javascript export function sum(list){ return list.reduce((prev, current) => prev + current, 0) } ``` Tests ```javascript import { sum } from './sum' test('happy', () => { expect(sum([ 1, 2, 3, 4, 5 ])).toBe(15) }) ``` [](#sum) ### switcher ```typescript switcher(valueToMatch: any): Switchem ``` Edited fork of [Switchem](https://github.com/planttheidea/switchem) library. The method return a value if the matched option is a value. If the matched option is a function, then `R.switcher` returns a function which expects input. Tests of the method explain it better than this short description. ```javascript const valueToMatch = {foo: 1} const result = R.switcher(valueToMatch) .is('baz', 'is baz') .is(x => typeof x === 'boolean', 'is boolean') .is({foo: 1}, 'Property foo is 1') .default('is bar') // => 'Property foo is 1' ``` Try this R.switcher example in Rambda REPL R.switcher source ```javascript import { equals } from './equals' const NO_MATCH_FOUND = Symbol ? Symbol('NO_MATCH_FOUND') : undefined const getMatchingKeyValuePair = ( cases, testValue, defaultValue ) => { let iterationValue for (let index = 0; index < cases.length; index++){ iterationValue = cases[ index ].test(testValue) if (iterationValue !== NO_MATCH_FOUND){ return iterationValue } } return defaultValue } const isEqual = (testValue, matchValue) => { const willReturn = typeof testValue === 'function' ? testValue(matchValue) : equals(testValue, matchValue) return willReturn } const is = (testValue, matchResult = true) => ({ key : testValue, test : matchValue => isEqual(testValue, matchValue) ? matchResult : NO_MATCH_FOUND, }) class Switchem{ constructor( defaultValue, cases, willMatch ){ if (cases === undefined && willMatch === undefined){ this.cases = [] this.defaultValue = undefined this.willMatch = defaultValue } else { this.cases = cases this.defaultValue = defaultValue this.willMatch = willMatch } return this } default(defaultValue){ const holder = new Switchem( defaultValue, this.cases, this.willMatch ) return holder.match(this.willMatch) } is(testValue, matchResult){ return new Switchem( this.defaultValue, [ ...this.cases, is(testValue, matchResult) ], this.willMatch ) } match(matchValue){ return getMatchingKeyValuePair( this.cases, matchValue, this.defaultValue ) } } export function switcher(input){ return new Switchem(input) } ``` Tests ```javascript import { add } from './add' import { switcher } from './switcher' import { tap } from './tap' import { trim } from './trim' test('with undefined', () => { const result = switcher(undefined) .is(x => x === 0, '0') .is(x => x === undefined, 'UNDEFINED') .default('3') expect(result).toEqual('UNDEFINED') }) test('happy', () => { const a = true const b = false const result = switcher([ a, b ]) .is([ false, false ], '0') .is([ false, true ], '1') .is([ true, true ], '2') .default('3') expect(result).toEqual('3') }) test('can compare objects', () => { const result = switcher({ a : 1 }) .is({ a : 1 }, 'it is object') .is('baz', 'it is baz') .default('it is default') expect(result).toEqual('it is object') }) test('options are mixture of functions and values - input match function', () => { const fn = switcher('foo').is('bar', 1) .is('foo', add(1)) .default(1000) expect(fn(2)).toEqual(3) }) test('options are mixture of functions and values - input match value', () => { const result = switcher('bar').is('bar', 1) .is('foo', add(1)) .default(1000) expect(result).toBe(1) }) test('return function if all options are functions', () => { const fn = switcher('foo').is('bar', tap) .is('foo', add(1)) .default(trim) expect(fn(2)).toEqual(3) }) const switchFn = input => switcher(input) .is(x => x.length && x.length === 7, 'has length of 7') .is('baz', 'it is baz') .default('it is default') test('works with function as condition', () => { expect(switchFn([ 0, 1, 2, 3, 4, 5, 6 ])).toEqual('has length of 7') }) test('works with string as condition', () => { expect(switchFn('baz')).toEqual('it is baz') }) test('fallback to default input when no matches', () => { expect(switchFn(1)).toEqual('it is default') }) ``` [](#switcher) ### symmetricDifference ```typescript symmetricDifference(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. ```javascript 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 R.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 }, ]) }) ``` [](#symmetricDifference) ### T ```typescript T(): boolean ``` ```javascript R.T() // => true ``` Try this R.T example in Rambda REPL R.T source ```javascript export function T(){ return true } ``` [](#T) ### tail ```typescript tail(input: readonly T[]): readonly T[] ``` It returns all but the first element of `input`. ```javascript const result = [ R.tail([1, 2, 3]), R.tail('foo') ] // => [[2, 3], 'oo'] ``` Try this R.tail example in Rambda REPL R.tail source ```javascript import { drop } from './drop' 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('') }) ``` [](#tail) ### take ```typescript take(howMany: number, input: readonly T[]): readonly T[] ``` It returns the first `howMany` elements of `input`. ```javascript const howMany = 2 const result = [ R.take(howMany, [1, 2, 3]), R.take(howMany, 'foobar'), ] // => [[1, 2], 'fo'] ``` Try this R.take example in Rambda REPL R.take source ```javascript import baseSlice from './_internals/baseSlice' 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([]) }) ``` [](#take) ### takeLast ```typescript takeLast(howMany: number, input: readonly T[]): readonly T[] ``` It returns the last `howMany` elements of `input`. ```javascript const howMany = 2 const result = [ R.takeLast(howMany, [1, 2, 3]), R.takeLast(howMany, 'foobar'), ] // => [[2, 3], 'ar'] ``` Try this R.takeLast example in Rambda REPL R.takeLast source ```javascript import baseSlice from './_internals/baseSlice' 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 ]) }) ``` [](#takeLast) ### takeLastWhile ```typescript takeLastWhile(predicate: (x: string) => boolean, input: string): string ``` ```javascript const result = R.takeLastWhile( x => x > 2, [1, 2, 3, 4] ) // => [3, 4] ``` Try this R.takeLastWhile example in Rambda REPL R.takeLastWhile source ```javascript import { _isArray } from './_internals/_isArray' 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('') } ``` Tests ```javascript 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') }) ``` [](#takeLastWhile) ### takeUntil ```typescript takeUntil(predicate: (x: T) => boolean, list: readonly T[]): readonly T[] ``` ```javascript const list = [1, 2, 3, 4, 5] const predicate = x => x > 3 const result = R.takeUntil(predicate, list) // => [1, 2, 3] ``` Try this R.takeUntil example in Rambda REPL R.takeUntil source ```javascript export function takeUntil(predicate, list){ const toReturn = [] let stopFlag = false let counter = -1 while (stopFlag === false && counter++ < list.length - 1){ if (predicate(list[ counter ])){ stopFlag = true } else { toReturn.push(list[ counter ]) } } return toReturn } ``` Tests ```javascript import { takeUntil } from './takeUntil' const list = [ 1, 2, 3, 4, 5, 6 ] test('happy', () => { const result = takeUntil(x => x > 3, list) expect(result).toEqual([ 1, 2, 3 ]) }) test('predicate always returns true', () => { const result = takeUntil(x => x < 10, list) expect(result).toEqual([]) }) test('predicate always returns false', () => { const result = takeUntil(x => x > 10, list) expect(result).toEqual(list) }) ``` [](#takeUntil) ### takeWhile ```javascript 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) ### tap ```typescript tap(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`. ```javascript const list = [1, 2, 3] R.compose( R.map(x => x * 2) R.tap(console.log), R.filter(x => x > 1) )(list) // => `2` and `3` will be logged ``` Try this R.tap example in Rambda REPL R.tap source ```javascript export function tap(fn, x){ if (arguments.length === 1) return _x => tap(fn, _x) fn(x) return x } ``` Tests ```javascript import { tap } from './tap' 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) }) ``` [](#tap) ### tapAsync ```typescript tapAsync(fn: Func | Promise, input: T): T ``` Asynchronous version of `R.tap`. R.tapAsync source ```javascript async function tapAsyncFn(fn, input){ await fn(input) return input } export function tapAsync(fn, input){ if (arguments.length === 1){ return async _input => tapAsyncFn(fn, _input) } return new Promise((resolve, reject) => { tapAsyncFn(fn, input).then(resolve) .catch(reject) }) } ``` Tests ```javascript import { delay } from './delay' import { pipedAsync } from './pipedAsync' import { tapAsync } from './tapAsync' test('happy', async () => { const result = await tapAsync(delay, 1) expect(result).toEqual(1) }) test('complex', async () => { let marker = false const fn = () => marker = true const result = await pipedAsync( 1, async x => { await delay(100) return x + 1 }, tapAsync(fn), x => x + 1 ) expect(marker).toBeTrue() expect(result).toEqual(3) }) ``` [](#tapAsync) ### test ```typescript test(regExpression: RegExp): (str: string) => boolean ``` It determines whether `str` matches `regExpression`. ```javascript R.test(/^f/, 'foo') // => true ``` Try this R.test example in Rambda REPL R.test source ```javascript export function test(pattern, str){ if (arguments.length === 1) return _str => test(pattern, _str) if (typeof pattern === 'string'){ throw new TypeError(`‘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')).toThrowWithMessage(TypeError, '‘test’ requires a value of type RegExp as its first argument; received "foo"') }) ``` [](#test) ### throttle ```typescript throttle(fn: (input: T) => U, ms: number): (input: T) => U ``` It creates a throttled function that invokes `fn` maximum once for a `period` of milliseconds. ```javascript let counter = 0 const inc = () => { counter++ } const throttledInc = R.throttle(inc, 800) const result = async () => { throttledInc() await R.delay(500) throttledInc() return counter } // `result` resolves to `1` ``` Try this R.throttle example in Rambda REPL R.throttle source ```javascript export function throttle(fn, ms){ let wait = false return function (...input){ if (!wait){ fn.apply(null, input) wait = true setTimeout(() => { wait = false }, ms) } } } ``` Tests ```javascript import { delay } from './delay' import { throttle } from './throttle' test('', async () => { let counter = 0 let aHolder let bHolder const inc = (a, b) => { aHolder = a bHolder = b counter++ } const incWrapped = throttle(inc, 1000) incWrapped(1, 2) await delay(500) incWrapped(2, 3) incWrapped(3, 4) expect(counter).toBe(1) expect(aHolder).toBe(1) expect(bHolder).toBe(2) await delay(1000) incWrapped(5, 6) expect(counter).toBe(2) expect(aHolder).toBe(5) expect(bHolder).toBe(6) }) ``` [](#throttle) ### times ```typescript times(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). ```javascript const fn = x => x * 2 const howMany = 5 R.times(fn, howMany) // => [0, 2, 4, 6, 8] ``` Try this R.times example in Rambda REPL R.times source ```javascript import { 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 ]) }) ``` [](#times) ### toDecimal ```typescript toDecimal(num: number, charsAfterDecimalPoint?: number): number ``` ```javascript R.toDecimal(2.45464,2) // => 2.45 ``` Try this R.toDecimal example in Rambda REPL R.toDecimal source ```javascript export function toDecimal(number, charsAfterDecimalPoint = 2){ return Number(parseFloat(String(number)).toFixed(charsAfterDecimalPoint)) } ``` Tests ```javascript import { toDecimal } from './toDecimal' test('happy', () => { expect(toDecimal(2.2789, 1)).toBe(2.3) expect(toDecimal(2.2789, 3)).toBe(2.279) expect(toDecimal(2, 3)).toBe(2) expect(toDecimal(2.2789)).toBe(2.28) expect(toDecimal(2.45464)).toBe(2.45) }) ``` [](#toDecimal) ### toLower ```typescript toLower(str: string): string ``` ```javascript R.toLower('FOO') // => 'foo' ``` Try this R.toLower example in Rambda REPL R.toLower source ```javascript export function toLower(str){ return str.toLowerCase() } ``` Tests ```javascript import { toLower } from './toLower' test('toLower', () => { expect(toLower('FOO|BAR|BAZ')).toEqual('foo|bar|baz') }) ``` [](#toLower) ### toPairs ```typescript toPairs(obj: { readonly [k: string]: S } | { readonly [k: number]: S }): readonly (readonly [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 this R.toPairs example in Rambda REPL R.toPairs source ```javascript export function toPairs(obj){ return Object.entries(obj) } ``` Tests ```javascript import { toPairs } from './toPairs' const obj = { a : 1, b : 2, c : [ 3, 4 ], } const expected = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ], ] test('happy', () => { expect(toPairs(obj)).toEqual(expected) }) ``` [](#toPairs) ### toString ```typescript toString(x: T): string ``` ```javascript R.toString([1, 2]) // => '1,2' ``` Try this R.toString example in Rambda REPL R.toString source ```javascript export function toString(x){ return x.toString() } ``` Tests ```javascript import { toString } from './toString' test('happy', () => { expect(toString([ 1, 2, 3 ])).toEqual('1,2,3') }) ``` [](#toString) ### toUpper ```typescript toUpper(str: string): string ``` ```javascript R.toUpper('foo') // => 'FOO' ``` Try this R.toUpper example in Rambda REPL R.toUpper source ```javascript export function toUpper(str){ return str.toUpperCase() } ``` Tests ```javascript import { toUpper } from './toUpper' test('toUpper', () => { expect(toUpper('foo|bar|baz')).toEqual('FOO|BAR|BAZ') }) ``` [](#toUpper) ### transpose ```typescript transpose(list: readonly (readonly T[])[]): readonly (readonly T[])[] ``` ```javascript const list = [[10, 11], [20], [], [30, 31, 32]] const expected = [[10, 20, 30], [11, 31], [32]] const result = R.transpose(list) // => `result` is equal to `expected` ``` Try this R.transpose example in Rambda REPL R.transpose source ```javascript import { _isArray } from './_internals/_isArray' export function transpose(array){ return array.reduce((acc, el) => { el.forEach((nestedEl, i) => _isArray(acc[ i ]) ? acc[ i ].push(nestedEl) : acc.push([ nestedEl ])) return acc }, []) } ``` Tests ```javascript import { transpose } from './transpose' test('happy', () => { const input = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ], ] expect(transpose(input)).toEqual([ [ 'a', 'b', 'c' ], [ 1, 2, 3 ], ]) }) test('when rows are shorter', () => { const actual = transpose([ [ 10, 11 ], [ 20 ], [], [ 30, 31, 32 ] ]) const expected = [ [ 10, 20, 30 ], [ 11, 31 ], [ 32 ] ] expect(actual).toEqual(expected) }) test('with empty array', () => { expect(transpose([])).toEqual([]) }) test('array with falsy values', () => { const actual = transpose([ [ true, false, undefined, null ], [ null, undefined, false, true ], ]) const expected = [ [ true, null ], [ false, undefined ], [ undefined, false ], [ null, true ], ] expect(actual).toEqual(expected) }) ``` [](#transpose) ### trim ```typescript trim(str: string): string ``` ```javascript R.trim(' foo ') // => 'foo' ``` Try this R.trim example in Rambda REPL R.trim source ```javascript export function trim(str){ return str.trim() } ``` Tests ```javascript import { trim } from './trim' test('trim', () => { expect(trim(' foo ')).toEqual('foo') }) ``` [](#trim) ### tryCatch ```typescript tryCatch( 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.tryCatch` to fully understand how this method works. ```javascript 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 R.tryCatch source ```javascript 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 } } } ``` Tests ```javascript 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, }) }) ``` [](#tryCatch) ### tryCatchAsync ```typescript tryCatchAsync( fn: (input: any) => Promise, fallback: T ): (input: any) => Promise ``` It returns function that runs `fn` in `try/catch` block. If there was an error, then `fallback` is used to return the result. ```javascript const x = {foo: 1} const fnFoo = async () => x.foo const fnBar = async () => x.bar const result = await Promise.all([ R.tryCatchAsync (fnFoo, false)(), R.tryCatchAsync(fnBar, false)() ]) // => [1, false] ``` Try this R.tryCatchAsync example in Rambda REPL R.tryCatchAsync source ```javascript import { isFunction } from './isFunction' import { isPromise } from './isPromise' export function tryCatchAsync(fn, fallback){ return (...inputs) => new Promise(resolve => { fn(...inputs) .then(resolve) .catch(err => { if (!isFunction(fallback)){ return resolve(fallback) } if (!isPromise(fallback)){ return resolve(fallback(err, ...inputs)) } fallback(err, ...inputs).then(resolve) .catch(resolve) }) }) } ``` Tests ```javascript import { delay } from './delay' import { tryCatchAsync } from './tryCatchAsync' test('when fallback is function', async () => { const fn = async x => x.x const result = await tryCatchAsync(fn, () => 1)(null) expect(result).toBe(1) }) test('when fallback throws', async () => { const fn = async x => x.x const fallback = async (err, xx) => xx.y const result = await tryCatchAsync(fn, fallback)(null) expect(result.message).toMatchInlineSnapshot('"Cannot read property \'y\' of null"') }) test('fallback is not used', async () => { const fn = async x => x.x expect(tryCatchAsync(fn, false)({ x : 1 })).resolves.toBe(1) }) test('fallback receives error object and all initial inputs', async () => { async 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 = tryCatchAsync(thrower, catchFn) const result = await willThrow( 'A', 'B', 'C' ) expect(result).toBe('throwerError|A|B|C') }) test('when async + value fallback', async () => { const fn = async () => { await delay(100) return JSON.parse('{a:') } const result = await tryCatchAsync(fn, 'fallback')(100) expect(result).toBe('fallback') }) ``` [](#tryCatchAsync) ### type ```typescript type(x: any): RambdaTypes ``` It accepts any input and it returns its type. > :boom: `NaN`, `Promise` and `Async` are types specific for **Rambda**. ```javascript 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 R.type source ```javascript 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' } ``` Tests ```javascript 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') }) ``` [](#type) ### union ```typescript union(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. ```javascript const result = R.union([1,2,3], [3,4,5]); // => [1, 2, 3, 4, 5] ``` Try this R.union example in Rambda REPL R.union source ```javascript import { 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 } ``` Tests ```javascript 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) }) ``` [](#union) ### uniq ```typescript uniq(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. ```javascript const list = [1, 1, {a: 1}, {a: 2}, {a:1}] R.uniq(list) // => [1, {a: 1}, {a: 2}] ``` Try this R.uniq example in Rambda REPL R.uniq source ```javascript import { 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 ] ]) }) ``` [](#uniq) ### uniqWith ```typescript uniqWith(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. ```javascript const list = [ {id: 0, title:'foo'}, {id: 1, title:'bar'}, {id: 2, title:'baz'}, {id: 3, title:'foo'}, {id: 4, title:'bar'}, ] const expected = [ {id: 0, title:'foo'}, {id: 1, title:'bar'}, {id: 2, title:'baz'}, ] const predicate = (x,y) => x.title === y.title const result = R.uniqWith(predicate, list) // => `result` is equal to `expected` ``` Try this R.uniqWith example in Rambda REPL R.uniqWith source ```javascript 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 } ``` 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) }) ``` [](#uniqWith) ### unless ```typescript unless(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. ```javascript const fn = R.unless( x => x > 2, x => x + 10 ) const result = [ fn(1), fn(5) ] // => [11, 5] ``` Try this R.unless example in Rambda REPL R.unless source ```javascript export function unless(predicate, whenFalse){ if (arguments.length === 1){ return _whenFalse => unless(predicate, _whenFalse) } return input => { if (predicate(input)) return input return whenFalse(input) } } ``` Tests ```javascript 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) }) ``` [](#unless) ### update ```typescript update(index: number, newValue: T, list: readonly T[]): readonly T[] ``` It returns a copy of `list` with updated element at `index` with `newValue`. ```javascript const index = 2 const newValue = 88 const list = [1, 2, 3, 4, 5] const result = R.update(index, newValue, list) // => [1, 2, 88, 4, 5] ``` Try this R.update example in Rambda REPL R.update source ```javascript import { curry } from './curry' function updateFn( index, newValue, list ){ const arrClone = list.slice() return arrClone.fill( newValue, index, index + 1 ) } export const update = curry(updateFn) ``` Tests ```javascript 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) }) ``` [](#update) ### updateObject ```typescript updateObject(rules: readonly (readonly [string, any])[], input: object): Output ``` Very similar to `R.assocPath` but it applies list of updates instead of only a single update. It return a copy of `obj` input with changed properties according to `rules` input. Each instance of `rules` is a tuple of object path and the new value for this path. If such object path does not exist, then such object path is created. As it uses `R.path` underneath, object path can be either string or array of strings(in Typescript object path can be only a string). ```javascript const obj = { a: {b: 1}, foo: {bar: 10}, } const rules = [ ['a.b', 2], ['foo.bar', 20], ['q.z', 300], ] const result = R.updateObject(rules, obj) const expected = { a: {b: 2}, foo: {bar: 20}, q: {z: 300}, } // => `result` is equal to `expected` ``` Try this R.updateObject example in Rambda REPL R.updateObject source ```javascript import { assocPath } from './assocPath' export function updateObject(rules, obj){ if (arguments.length === 1) return _obj => updateObject(rules, _obj) let clone = { ...obj } /*?.*/ rules.forEach(([ objectPath, newValue ]) => { clone = assocPath( objectPath, newValue, clone ) }) return clone } ``` Tests ```javascript import { updateObject } from './updateObject' const obj = { a : { b : 1 }, foo : { bar : 10 }, } const rules = [ [ 'a.b', 2 ], [ 'foo.bar', 20 ], [ 'q.z', 300 ], ] const expected = { a : { b : 2 }, foo : { bar : 20 }, q : { z : 300 }, } test('happy', () => { const result = updateObject(rules, obj) expect(result).toEqual(expected) }) test('curried', () => { const result = updateObject(rules)(obj) expect(result).toEqual(expected) }) ``` [](#updateObject) ### values ```typescript values(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. ```javascript const obj = {a:1, b:2} R.values(obj) // => [1, 2] ``` Try this R.values example in Rambda REPL R.values source ```javascript import { type } from './type' 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([]) }) ``` [](#values) ### view ```typescript view(lens: Lens): (target: T) => U ``` It returns the value of `lens` focus over `target` object. ```javascript 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 R.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 } ``` Tests ```javascript 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') }) ``` [](#view) ### viewOr ```typescript viewOr(fallback: Output, lens: Lens, input: Input): Output ``` A combination between `R.defaultTo` and `R.view. ```javascript const lens = R.lensProp('a'); const input = {a: 'foo'} const fallbackInput = {b: 'bar'} const fallback = 'FALLBACK' const result = [ R.viewOr(fallback, lens, input), R.viewOr(fallback, lens, fallbackInput) ] // => ['foo', 'FALLBACK'] ``` Try this R.viewOr example in Rambda REPL R.viewOr source ```javascript import { curry } from './curry' import { defaultTo } from './defaultTo' import { view } from './view' function viewOrFn( fallback, lens, input ){ return defaultTo(fallback, view(lens, input)) } export const viewOr = curry(viewOrFn) ``` Tests ```javascript import { lensProp } from './lensProp' import { viewOr } from './viewOr' const lens = lensProp('a') const input = { a : 'foo' } const fallbackInput = { b : 'bar' } const fallback = 'FALLBACK' test('happy', () => { const result = viewOr( fallback, lens, fallbackInput ) expect(result).toBe(fallback) }) test('curried', () => { const result = viewOr(fallback, lens)(input) expect(result).toBe('foo') }) ``` [](#viewOr) ### wait ```typescript wait(fn: Promise): Promise ``` It provides `Golang`-like interface for handling promises. ```javascript const [result, err] = await R.wait(R.delay(1000)) // => err is undefined // => result is `RAMBDAX_DELAY` ``` Try this R.wait example in Rambda REPL R.wait source ```javascript export function wait(fn){ return new Promise(resolve => { fn.then(result => resolve([ result, undefined ])).catch(e => resolve([ undefined, e ])) }) } ``` Tests ```javascript import { wait } from './wait' test('happy path', async () => { const fn = x => Promise.resolve(x + 1) const [ result, err ] = await wait(fn(1)) expect(result).toBe(2) expect(err).toBeUndefined() }) test('when promise is rejected', async () => { const fn = x => Promise.reject(Error('foo')) const [ result, err ] = await wait(fn(1)) expect(result).toBeUndefined() expect(err).toEqual(Error('foo')) }) ``` [](#wait) ### waitFor ```typescript waitFor( waitForTrueCondition: () => boolean, howLong: number, loops?: number ): () => Promise ``` It returns `true`, if `condition` returns `true` within `howLong` milisececonds time period. The method accepts an optional third argument `loops`(default to 10), which is the number of times `waitForTrueCondition` will be evaluated for `howLong` period. Once this function returns a value different from `false`, this value will be the final result. Otherwise, `R.waitFor` will return `false`. ```javascript const howLong = 1000 let counter = 0 const waitForTrueCondition = async x => { await R.delay(100) counter = counter + x return counter > 10 } const result = await R.waitFor(waitForTrueCondition, howLong)(2) // => true ``` Try this R.waitFor example in Rambda REPL R.waitFor source ```javascript import { delay } from './delay' import { range } from './range' import { type } from './type' export function waitFor( condition, howLong, loops = 10 ){ const typeCondition = type(condition) const passPromise = typeCondition === 'Async' const passFunction = typeCondition === 'Function' const interval = Math.floor(howLong / loops) if (!(passPromise || passFunction)){ throw new Error('R.waitFor') } return async (...inputs) => { for (const _ of range(0, loops)){ const resultCondition = await condition(...inputs) if (resultCondition === false){ await delay(interval) } else { return resultCondition } } return false } } ``` Tests ```javascript import { delay } from './delay' import { waitFor } from './waitFor' const howLong = 1000 test('true', async () => { let counter = 0 const condition = x => { counter++ return counter > x } const result = await waitFor(condition, howLong)(6) expect(result).toEqual(true) }) test('false', async () => { let counter = 0 const condition = x => { counter++ return counter > x } const result = await waitFor(condition, howLong)(12) expect(result).toEqual(false) }) test('async condition | true', async () => { let counter = 0 const condition = async x => { counter++ await delay(10) return counter > x } const result = await waitFor(condition, howLong)(6) expect(result).toEqual(true) }) test('async condition | false', async () => { let counter = 0 const condition = async x => { counter++ await delay(10) return counter > x } const result = await waitFor(condition, howLong)(12) expect(result).toEqual(false) }) test('throws when fn is not function', () => { const fn = 'foo' expect(() => waitFor(fn, howLong)()).toThrowWithMessage(Error, 'R.waitFor') }) ``` [](#waitFor) ### when ```typescript when(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): T | U ``` R.when source ```javascript import { curry } from './curry' function whenFn( predicate, whenTrueFn, input ){ if (!predicate(input)) return input return whenTrueFn(input) } export const when = curry(whenFn) ``` Tests ```javascript 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') }) ``` [](#when) ### where ```typescript where(conditions: T, input: U): boolean ``` It returns `true` if all each property in `conditions` returns `true` when applied to corresponding property in `input` object. ```javascript 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 R.where source ```javascript 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 } ``` Tests ```javascript 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) }) ``` [](#where) ### whereEq ```typescript whereEq(condition: T, input: U): boolean ``` It will return `true` if all of `input` object fully or partially include `rule` object. ```javascript 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 R.whereEq source ```javascript 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 } ``` Tests ```javascript 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') }) ``` [](#whereEq) ### without ```typescript without(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. ```javascript 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 R.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 ]) }) ``` [](#without) ### xnor ```typescript xnor(x: boolean, y: boolean): boolean ``` Logical XNOR ```javascript const result = [ R.xnor(1, 0), R.xnor(0, 1), R.xnor(0, 0), R.xnor(1, 1), ] // => [true, false, false, true] ``` Try this R.xnor example in Rambda REPL R.xnor source ```javascript export function xnor(x, y){ if (arguments.length === 1){ return _y => xnor(x, _y) } return Boolean(x && y || !x && !y) } ``` Tests ```javascript import { xnor } from './xnor' test('when true', () => { expect(xnor(1, 1)).toBeTrue() expect(xnor(0)(0)).toBeTrue() }) test('when false', () => { expect(xnor(0, 1)).toBeFalse() }) ``` [](#xnor) ### xor ```typescript xor(x: boolean, y: boolean): boolean ``` Logical XOR ```javascript const result = [ xor(true, true), xor(false, false), xor(false, true), ] // => [false, false, true] ``` Try this R.xor example in Rambda REPL 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) }) ``` [](#xor) ### zip ```typescript zip(x: readonly K[], y: readonly V[]): readonly KeyValuePair[] ``` 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. ```javascript 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 R.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) }) ``` [](#zip) ### zipObj ```typescript zipObj(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. ```javascript 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 R.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() }) ``` [](#zipObj) ### zipWith ```typescript zipWith(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): readonly TResult[] ``` ```javascript 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 R.zipWith source ```javascript 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) ``` Tests ```javascript 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 ]) }) ``` [](#zipWith) ## ❯ CHANGELOG 7.2.0 - Approve [PR #61](https://github.com/selfrefactor/rambda/pull/61) - fix wrong `R.isValid` typings - R.produceAsync returns promise even if all rules are synchronous. - `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](https://github.com/selfrefactor/rambda/issues/561) - export several internal TS interfaces and types - Add `CHANGELOG.md` file in release files list 7.1.0 - Add `R.tryCatchAsync` - Add `R.xnor` - `R.equals` supports equality of functions. - Close [Issue #559](https://github.com/selfrefactor/rambda/issues/559) - improve `R.propOr` typings - Close [Issue #560](https://github.com/selfrefactor/rambda/issues/560) - apply immutable lint to Typescript definitions - Close [Issue #553](https://github.com/selfrefactor/rambda/issues/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` 7.0.1 - Fix missing `Evolved` declaration in Typescript definition 7.0.0 - Rename `R.produce` to `R.produceAsync` - Add `R.produce` which is synchronous version of `R.produceAsync` - Stop supporting expression inside template's props. Also, spaces are no longer allowed between `{{` and `}}`, i.e. `R.interpolate('{{ foo }}', x)` should be `R.interpolate('{{foo}}', x)`. - Add typings for `R.takeWhile` when iterable is a string - Add `R.takeLastWhile` - Add `R.dropWhile` - Add `R.eqProps` - Add `R.dropLastWhile` - Add `R.dropRepeats` - Add `R.dropRepeatsWith` - Add `R.evolve` 6.2.0 - `R.switcher` accepts `undefined` as valid input - Add `R.props` - Add `R.zipWith` - Add `R.splitAt` - Add `R.splitWhen` - Close [Issue #547](https://github.com/selfrefactor/rambda/issues/547) - restore `readonly` declaration in Rambda Typescript definitions. - `R.append`/`R.prepend` now work only with arrays just like Ramda. Previous behaviour was for them to work with both arrays and strings. - Sync `R.pluck` typings with `@types/ramda` as there was a tiny difference. 6.1.0 - Add `R.mapIndexed` - Add `R.filterIndexed` - Add `R.forEachIndexed` - Fix `R.and` wrong definition, because the function doesn't convert the result to boolean. This introduce another difference with `@types/ramda`. - Add `R.once` - Add `R.or` 6.0.0 - Breaking change - `R.map`/`R.filter`/`R.reject`/`R.forEach`/`R.partition` doesn't pass index as second argument to the predicate, when looping over arrays. The old behaviour of *map*, *filter* and *forEach* can be found in Rambdax methods *R.mapIndexed*, *R.filterIndexed* and *R.forEachIndexed*(introduced in version `6.1.0`). - Breaking change - `R.all`/`R.none`/`R.any`/`R.find`/`R.findLast`/`R.findIndex`/`R.findLastIndex` doesn't pass index as second argument to the predicate. - Add `R.applyDiff` method - Change `R.assocPath` typings so the user can explicitly sets type of the new object - Typings of `R.assoc` match its `@types/ramda` counterpart. - Simplify `R.forEach` typings - Remove `ReadonlyArray` pattern from Typescript definitions - not enough value for the noise it adds. - Fix typing of `R.reject` as it wrongly declares that with object, it pass property to predicate. 5.1.0 - Add `R.takeUntil` method - Fix wrong `R.takeWhile` 5.0.0 - Deprecate `R.change` method - it does too much; partially replaced with `R.updateObject`. - Deprecate `R.compact` method - vague use case; `R.filter` does the same job. - `R.produce` always returns a promise - Add `R.updateObject` method - Add `R.takeWhile` method - Add `R.viewOr` method - Add `R.pipeAsync` method - Add `R.removeIndex` method - Add `R.excludes` method - `R.includes` throws on wrong input, i.e. `R.includes(1, null)` - Close [Issue #524](https://github.com/selfrefactor/rambda/issues/524) - `R.assocPath` wrong logic when number is used in array path input. - `R.mapToObjectAsync` supports currying - `R.mapAsyncLimit` supports currying - Fix `R.mapAsync` to pass property to iterator, when input is an object. - Fix currying for several async methods - `R.tapAsync`, `R.produce`, `R.filterAsync` *(extend typings) 4.2.0 - Add `R.move` method - Add `R.union` method - Add `R.lensSatisfies` method - Add `R.mapKeys` method - Add `R.sortByPath` method - Add `R.sortByProps` method - Close [Issue #519](https://github.com/selfrefactor/rambda/issues/519) - `ts-toolbelt` needs other type of export with `--isolatedModules` flag 4.1.0 - `R.template` is renamed to `R.interpolate` - `R.equals` now supports negative zero just like `Ramda.equals` - Add `R.replaceAll` method - Add `R.lensEq` method 4.0.1 Forgot to export `R.of` because of wrong marker in `files/index.d.ts` 4.0.0 Deprecate the following methods: - `R.promiseAllObject` - because `R.produce` serves the same purpose - `R.composed` - because `R.piped` makes more sense, when we want to pass the input at the start of the function - `R.defaultToStrict` - confusing logic - `R.findInObject` - overestimated importance - `R.headObject` - overestimated importance - `R.includesType` - overestimated importance - `R.inject` - confusing logic - `R.isAttach` - confusing logic - `R.mergeRight` - overestimated importance - `R.opposite` - overestimated importance - `R.otherwise` - overestimated importance - `R.pushUniq` - overestimated importance - `R.resolve` - overestimated importance - `R.s` - overestimated importance - `R.toggle` - overestimated importance - `R.uuid` - not suitable - `R.whenAsync` - overestimated importance Move the following methods to `Rambda` and change their logic to match `Ramda` implementation: - `R.hasPath` - `R.unless` - `R.pathEq` - `R.tryCatch` - `R.where` - `R.whereEq` Also these changes: - `R.flatMap` - renamed to `R.chain` and moved to `Rambda` - `R.ifElseAsync` - accept any number of arguments for the returned function - `R.produce`, `R.filterAsync`, `R.debounce`, `R.throttle` - fix typings - `R.mapAsyncLimit` - drop support for curring and therefore for usage with `R.composeAsync` - Improve `R.ok` throwed error message - `R.ok` returns `undefined` instead of `true` when validation passes. - `R.mergeDeep` is renamed to `R.mergeDeepLeft` - Add `R.pipeAsync` - Take `R.partialCurry` from `Rambda` as it is deprecated there 3.7.0 > Sync with Rambda Add `R.lens` Add `R.lensIndex` Add `R.lensPath` Add `R.lensProp` Add `R.over` Add `R.set` Add `R.view` Add `R.paths` Add `R.xor` Add `R.cond` 3.6.0 - Add `R.mapAsyncLimit` - Add `R.toggle`, match Ramda upcoming method specification - Add `R.isValidAsync` - Extend `R.template` without introducing breaking change 3.5.0 Sync with `Rambda` - add methods descriptions to Typescript definitions 3.4.0 Sync with `Rambda` and close [Issue #42](https://github.com/selfrefactor/rambdax/pull/42) 3.3.0 Fix `R.sortObject` typing 3.3.0 Add `R.filterAsync` and `R.sortObject` methods 3.2.0 `R.uuid` accept second argument in order to return string only uuid 3.1.0 Dynamic set of exports lead to adding previously ommited Rambda exports such as `R.identical` 3.0.3 Sync with Rambda - new functionality of `R.isEmpty` 3.0.2 Add typings for `R.mapToObject` 3.0.1 Fix typings 3.0.0 Breaking change as `Rambda` also has breaking changes Read more about it in `Rambda` changelog Also with this versions, typings tests are provided and several definitions are changed. - R.anyTrue, R.anyFalse, R.allTrue, R.allFalse use internal `isTruthy` and `isFalsy` methods. Empty array and object with zero length are considered falsy. - Deprecate `R.contains` - Deprecate `R.defaultToWhen` - Moved `R.runTests` to `helpers` repo 2.17.0 Change in `R.runTests` logic. It will be removed from Rambdax to `helpers` repo. 2.16.0 Restore `R.runTests` but without documentation - export `getEvaluations`, `getPositiveEvaluation`, `getNegativeEvaluation` in the context of `R.runTests` 2.15.0 Several changes - Typescript definitions have been updated and typings tests are introduced - `R.mapAsync` and `R.mapFastAsync` pass index as second argument 2.14.1 Restore `R.contains` 2.14.0 Several changes: - `R.inject` accept before flag as fourth argument - Remove `R.includesAny` - Improve typing of `R.partition` - `R.nextIndex` and `R.prevIndex` work also with number as second argument 2.13.1 Deprecate `R.log` and `R.runTests` 2.12.3 Add 'dist' directory to `files` 2.12.2 Add `R.mapToObject` typings 2.12.0 Sync with Rambda 2.11.1 Fix `R.waitFor` 2.11.0 Add `R.toDecimal` 2.10.2 Fix [issue 32](https://github.com/selfrefactor/rambdax/issues/32) 2.10.0 deprecate `R._` 2.9.1 R.fromPairs/toPairs typing 2.9.0 npm doesn't update version on their site 2.8.2 R.map typing 2.8.0 Sync with Rambda | no need for create types script 2.7.0 Add `R.prevIndex` 2.6.2 Sync with Rambda 2.6.0 `R.log` depends on `RAMBDAX_LOG` 2.5.0 Rambda's `partial` 2.4.0 Add `R.uuid` 2.3.0 `R._` parse to constant case > This introduce breaking change for ie11 as noted in [issue 31](https://github.com/selfrefactor/rambdax/issues/31) which is fixed with `2.10.0` which deprecates this method 2.2.1 Add `R.log`, `R.logInit` and `R.logHolder` 2.1.0 Add `R._` 2.0.0 Add `R.toggle` 1.9.0 Add `R.pushUniq` 1.8.2 No need for sourcemaps 1.8.1 Fix building with `regeneratorRuntime` 1.8.0 Upgrade to new major Rollup release - Restore `R.headObject` - Add `R.hasPath` method 1.7.2 `R.memoize` contains dev console.logs 1.7.1 Forgot to build types 1.7.0 Rename `R.then` to `R.resolve` because of Ramda issue with `R.then`(they rename it to `R.andThen`) - Add `R.isFalsy`, `R.nextIndex` and `R.mergeDeep` 1.6.3 Forgot to export `R.unless`(credit to @mobily for the PR) 1.6.0 Restore `R.compact` method 1.5.6 `R.maybe` accepts also anonymous functions as second and third argument 1.5.5 Add `R.maybe` method - Fix errors caugth by `DeepScan` service - Fix Typescript definitions for `R.then` and `R.otherwise` - `R.change` increase nesting level to 4 1.4.1 `R.isValid` didn't work with `Number` prototype 1.4.0 Add multiple methods - Add `R.defaultToStrict` - Add `R.defaultToWhen` - Add `R.whereEq` - Add `R.partition` - Add `R.negate` is renamed to `R.opposite` - Add `R.then` - Add `R.otherwise` - `R.isValid` accepts prototypes as rules, i.e. `schema = {a: String}` - The prevoious point leads to the same change applied to the methods depending on `R.isValid`, i.e. `R.ok`, `R.pass` and `R.isAttach` 1.3.0 Add `R.unless` - `R.when` accepts both function and value for `whenTrue` argument. The same is valid for `R.unless` - export `R.negate` which is the same as `R.complement` 1.2.0 Export `src` folder 1.1.0 Restore `promiseAllObject` and `flatMap` 1.0.1 Fix typings 1.0.0 Deprecate the following methods: - compact - evolve - flatMap - greater - intersection - less - omitBy - pickBy - promiseAllObject - promiseAllSecure - rangeBy > Also pass deprecation of `addIndex` from `Rambda@2.0.0` 0.24.0 add `R.pipedAsync`, replace `R.multiline` with `R.glue`, remove `R.validate` 0.23.0 Add `R.count` 0.22.0 Add `R.includesAny` 0.21.0 Add `R.includesType` 0.20.1 `R.pass` and `R.ok` work with single schema. 0.20.0 Add `R.pathEq` 0.19.0 Add `R.wait`, expose already complete `R.waitFor` 0.18.0 Add`R.anyType` and `R.allType` 0.17.0 Rename `R.is` to `R.pass` and restore `R.is` original functionality. 0.16.0 getter, setter, reset methods 0.15.3 No more `prepublish` script 0.15.2 curry in `remove` > Last version with `lib` folder exposed [](#-changelog) ## ❯ Additional info > Most influential contributors - [@farwayer](https://github.com/farwayer) - improving performance in R.find, R.filter; give the idea how to make benchmarks more reliable; - [@thejohnfreeman](https://github.com/thejohnfreeman) - add R.assoc, R.chain; - [@helmuthdu](https://github.com/helmuthdu) - add R.clone; help improve code style; - [@jpgorman](https://github.com/jpgorman) - add R.zip, R.reject, R.without, R.addIndex; - [@ku8ar](https://github.com/ku8ar) - add R.slice, R.propOr, R.identical, R.propIs and several math related methods; introduce the idea to display missing Ramda methods; - [@romgrk](https://github.com/romgrk) - add R.groupBy, R.indexBy, R.findLast, R.findLastIndex; - [@squidfunk](https://github.com/squidfunk) - add R.assocPath, R.symmetricDifference, R.difference, R.intersperse; - [@synthet1c](https://github.com/synthet1c) - add all lenses methods; add R.applySpec, R.converge; - [@vlad-zhukov](https://github.com/vlad-zhukov) - help with configuring Rollup, Babel; change export file to use ES module exports; > Rambda references - [Interview with Dejan Totef at SurviveJS blog](https://survivejs.com/blog/rambda-interview/) - [Awesome functional Javascript programming libraries](https://github.com/stoeffel/awesome-fp-js#libraries) > Links to Rambda - [https://mailchi.mp/webtoolsweekly/web-tools-280](Web Tools Weekly) - [https://github.com/stoeffel/awesome-fp-js](awesome-fp-js) - [https://github.com/docsifyjs/awesome-docsify](awesome-docsify) > Deprecated from `Used by` section - [SAP's Cloud SDK](https://github.com/SAP/cloud-sdk) - This repo doesn't uses `Rambda` since *October/2020* [commit that removes Rambda](https://github.com/SAP/cloud-sdk/commit/b29b4f915c4e4e9c2441e7b6b67cf83dac1fdac3) > Releases [Rambda's releases](https://github.com/selfrefactor/rambda/releases) before **6.4.0** were used mostly for testing purposes. [](#-additional-info) ## My other libraries Niketa theme Collection of 9 light VSCode themes Niketa dark theme Collection of 9 dark VSCode themes String-fn String utility library Useful Javascript libraries Large collection of JavaScript,Typescript and Angular related repos links Run-fn CLI commands for lint JS/TS files, commit git changes and upgrade of dependencies