JavaScripting

The definitive source of the best
JavaScript libraries, frameworks, and plugins.


  • ×

    Rambda

    Faster alternative to Ramda in just 10kB
    Filed under  › 

    • 🔾47%Overall
    • 980
    • 10 hours
    • 🕩58
    • 👥5

    Rambda

    Rambda is smaller and faster alternative to the popular functional programming library Ramda. - Documentation

    CircleCI codecov dependencies Status Commit activity All contributors Library size

    ➤ Example use

    import { compose, map, filter } from 'rambda'
    
    const result = compose(
      map(x => x * 2),
      filter(x => x > 2)
    )([1, 2, 3, 4])
    // => [6, 8]
    

    You can test this example in Rambda's REPL

    ---------------

    ➤ Rambda's advantages

    Typescript included

    Typescript definitions are included in the library, in comparison to Ramda, where you need to additionally install @types/ramda.

    Still, you need to be aware that functional programming features in Typescript are in development, which means that using R.compose/R.pipe can be problematic.

    Smaller size

    The size of a library affects not only the build bundle size but also the dev bundle size and build time. This is important advantage, expecially for big projects.

    Tree-shaking

    Currently Rambda is more tree-shakable than Ramda - proven in the following repo.

    The repo holds two Angular9 applications: one with small example code of Ramda and the other - same code but with Rambda as import library.

    The test shows that Rambda bundle size is 2.03 MB less than its Ramda counterpart.

    There is also Webpack/Rollup/Parcel/Esbuild tree-shaking example including several libraries including Ramda, Rambda and Rambdax.

    actually tree-shaking is the initial reason for creation of Rambda

    Dot notation for R.path, R.paths, R.assocPath and R.lensPath

    Standard usage of R.path is R.path(['a', 'b'], {a: {b: 1} }).

    In Rambda you have the choice to use dot notation(which is arguably more readable):

    R.path('a.b', {a: {b: 1} })
    

    Comma notation for R.pick and R.omit

    Similar to dot notation, but the separator is comma(,) instead of dot(.).

    R.pick('a,b', {a: 1 , b: 2, c: 3} })
    // No space allowed between properties
    

    Speed

    Rambda is generally more performant than Ramda as the benchmarks can prove that.

    Support

    Most of the valid issues are fixed within 2-3 days.

    Closing the issue is usually accompanied by publishing a new patch version of Rambda to NPM.

    ---------------

    ➤ Missing Ramda methods

    Click to see the full list of 90 Ramda methods not implemented in Rambda - __ - addIndex - ap - aperture - apply - applyTo - ascend - binary - bind - call - comparator - composeK - composeP - composeWith - construct - constructN - contains - countBy - descend - differenceWith - dissocPath - empty - eqBy - forEachObjIndexed - gt - gte - hasIn - innerJoin - insert - insertAll - into - invert - invertObj - invoker - juxt - keysIn - lift - liftN - lt - lte - mapAccum - mapAccumRight - mapObjIndexed - memoizeWith - mergeDeepLeft - mergeDeepWith - mergeDeepWithKey - mergeRight - mergeWith - mergeWithKey - nAry - nthArg - o - objOf - otherwise - pair - partialRight - pathSatisfies - pickBy - pipeK - pipeP - pipeWith - project - propSatisfies - reduceBy - reduceRight - reduceWhile - reduced - remove - scan - sequence - sortWith - symmetricDifferenceWith - andThen - toPairsIn - transduce - traverse - unapply - unary - uncurryN - unfold - unionWith - uniqBy - unnest - until - useWith - valuesIn - xprod - thunkify - default

    ---------------

    ➤ Install

    • yarn add rambda

    • For UMD usage either use ./dist/rambda.umd.js or the following CDN link:

    https://unpkg.com/rambda@CURRENT_VERSION/dist/rambda.umd.js
    
    • with deno
    import {compose, add} from 'https://raw.githubusercontent.com/selfrefactor/rambda/master/dist/rambda.esm.js'
    

    ---------------

    Differences between Rambda and Ramda

    • Rambda's type detects async functions and unresolved Promises. The returned values are 'Async' and 'Promise'.

    • Rambda's type handles NaN input, in which case it returns NaN.

    • Rambda's forEach can iterate over objects not only arrays.

    • Rambda's map, filter, partition when they iterate over objects, they pass property and input object as predicate's argument.

    • Rambda's filter returns empty array with bad input(null or undefined), while Ramda throws.

    • Ramda's clamp work with strings, while Rambda's method work only with numbers.

    • Error handling, when wrong inputs are provided, may not be the same. This difference will be better documented once all brute force tests are completed.

    • Typescript definitions between rambda and @types/ramda may vary.

    If you need more Ramda methods in Rambda, you may either submit a PR or check the extended version of Rambda - Rambdax. In case of the former, you may want to consult with Rambda contribution guidelines.

    ---------------

    ➤ Benchmarks

    Click to expand all benchmark results There are methods which are benchmarked only with Ramda and Rambda(i.e. no Lodash). Note that some of these methods, are called with and without curring. This is done in order to give more detailed performance feedback. The benchmarks results are produced from latest versions of Rambda, Lodash(4.17.20) and Ramda(0.27.1). method | Rambda | Ramda | Lodash --- |--- | --- | --- add | 96.25% slower | 96.24% slower | 🚀 Fastest adjust | 🚀 Fastest | 5.52% slower | 🔳 all | 🚀 Fastest | 94.95% slower | 🔳 allPass | 🚀 Fastest | 98.95% slower | 🔳 any | 🚀 Fastest | 98.18% slower | 6.18% slower anyPass | 🚀 Fastest | 99.09% slower | 🔳 append | 🚀 Fastest | 84.09% slower | 🔳 applySpec | 🚀 Fastest | 75.73% slower | 🔳 assoc | 87.98% slower | 57.39% slower | 🚀 Fastest clone | 🚀 Fastest | 96.03% slower | 91.75% slower compose | 🚀 Fastest | 96.45% slower | 77.83% slower converge | 49.12% slower | 🚀 Fastest | 🔳 curry | 🚀 Fastest | 34.9% slower | 🔳 curryN | 63.32% slower | 🚀 Fastest | 🔳 defaultTo | 🚀 Fastest | 50.3% slower | 🔳 drop | 🚀 Fastest | 97.45% slower | 🔳 dropLast | 🚀 Fastest | 97.07% slower | 🔳 equals | 72.11% slower | 79.48% slower | 🚀 Fastest filter | 🚀 Fastest | 94.74% slower | 58.18% slower find | 🚀 Fastest | 98.2% slower | 88.96% slower findIndex | 🚀 Fastest | 97.97% slower | 79.39% slower flatten | 6.56% slower | 95.38% slower | 🚀 Fastest ifElse | 🚀 Fastest | 70.97% slower | 🔳 includes | 🚀 Fastest | 71.7% slower | 🔳 indexOf | 🚀 Fastest | 84.08% slower | 7.86% slower init | 94.42% slower | 97.55% slower | 🚀 Fastest is | 🚀 Fastest | 11.72% slower | 🔳 isEmpty | 51.68% slower | 93.82% slower | 🚀 Fastest last | 🚀 Fastest | 99.64% slower | 1.05% slower lastIndexOf | 🚀 Fastest | 42.38% slower | 🔳 map | 🚀 Fastest | 69.63% slower | 4.68% slower match | 🚀 Fastest | 46.75% slower | 🔳 merge | 63.55% slower | 🚀 Fastest | 55.25% slower none | 🚀 Fastest | 98.22% slower | 🔳 omit | 🚀 Fastest | 70.66% slower | 97.56% slower over | 🚀 Fastest | 50.77% slower | 🔳 path | 🚀 Fastest | 74.94% slower | 5.72% slower pick | 🚀 Fastest | 26.29% slower | 86.82% slower prop | 🚀 Fastest | 89.89% slower | 🔳 propEq | 🚀 Fastest | 95.26% slower | 🔳 range | 95.17% slower | 90.22% slower | 🚀 Fastest reduce | 52.76% slower | 74.02% slower | 🚀 Fastest repeat | 85.91% slower | 95.31% slower | 🚀 Fastest replace | 0.47% slower | 28.13% slower | 🚀 Fastest set | 🚀 Fastest | 36.26% slower | 🔳 sort | 🚀 Fastest | 63.15% slower | 🔳 sortBy | 🚀 Fastest | 61.57% slower | 88.88% slower split | 🚀 Fastest | 85.34% slower | 33.69% slower splitEvery | 🚀 Fastest | 90.18% slower | 🔳 take | 93.44% slower | 98.04% slower | 🚀 Fastest takeLast | 92.61% slower | 98.83% slower | 🚀 Fastest test | 🚀 Fastest | 94.42% slower | 🔳 type | 18.91% slower | 🚀 Fastest | 🔳 uniq | 98.98% slower | 96.58% slower | 🚀 Fastest update | 🚀 Fastest | 38.88% slower | 🔳 view | 🚀 Fastest | 82.21% slower | 🔳

    ---------------

    ➤ Used by

    ---------------

    API

    add

    
    add(a: number, b: number): number
    

    It adds a and b.

    :boom: It doesn't work with strings, as the inputs are parsed to numbers before calculation.

    R.add(2, 3) // =>  5
    

    Try this R.add example in Rambda REPL

    All Typescript definitions typescript add(a: number, b: number): number; add(a: number): (b: number) => number;
    R.add source javascript export function add(a, b) { if (arguments.length === 1) return (_b) => add(a, _b); return Number(a) + Number(b); }
    Tests javascript import { add } from './add' test('with number', () => { expect(add(2, 3)).toEqual(5) expect(add(7)(10)).toEqual(17) }) test('string is bad input', () => { expect(add('foo', 'bar')).toBeNaN() }) test('ramda specs', () => { expect(add('1', '2')).toEqual(3) expect(add(1, '2')).toEqual(3) expect(add(true, false)).toEqual(1) expect(add(null, null)).toEqual(0) expect(add(undefined, undefined)).toEqual(NaN) expect(add(new Date(1), new Date(2))).toEqual(3) })
    Typescript test typescript import {add} from 'rambda' describe('R.add', () => { it('happy', () => { const result = add(4, 1) result // $ExpectType number }) it('curried', () => { const result = add(4)(1) result // $ExpectType number }) })

    ---------------

    adjust

    
    adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[]
    

    It replaces index in array list with the result of replaceFn(list[i]).

    R.adjust(
      0,
      a => a + 1,
      [0, 100]
    ) // => [1, 100]
    

    Try this R.adjust example in Rambda REPL

    All Typescript definitions typescript adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[]; adjust<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[];
    R.adjust source javascript import { curry } from './curry' function adjustFn( index, replaceFn, list ){ const actualIndex = index < 0 ? list.length + index : index if (index >= list.length || actualIndex < 0) return list const clone = list.slice() clone[ actualIndex ] = replaceFn(clone[ actualIndex ]) return clone } export const adjust = curry(adjustFn)
    Tests javascript import { add } from './add' import { adjust } from './adjust' import { pipe } from './pipe' const list = [ 0, 1, 2 ] const expected = [ 0, 11, 2 ] test('happy', () => {}) test('happy', () => { expect(adjust( 1, add(10), list )).toEqual(expected) }) test('with curring type 1 1 1', () => { expect(adjust(1)(add(10))(list)).toEqual(expected) }) test('with curring type 1 2', () => { expect(adjust(1)(add(10), list)).toEqual(expected) }) test('with curring type 2 1', () => { expect(adjust(1, add(10))(list)).toEqual(expected) }) test('with negative index', () => { expect(adjust( -2, add(10), list )).toEqual(expected) }) test('when index is out of bounds', () => { const list = [ 0, 1, 2, 3 ] expect(adjust( 4, add(1), list )).toEqual(list) expect(adjust( -5, add(1), list )).toEqual(list) })
    1 failed Ramda.adjust specs > :boom: Reason for the failure: Ramda method accepts an array-like object javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('adjust', function() { it('accepts an array-like object', function() { function args() { return arguments; } eq(R.adjust(2, R.add(1), args(0, 1, 2, 3)), [0, 1, 3, 3]); }); });

    ---------------

    all

    
    all<T>(predicate: (x: T) => boolean, list: T[]): boolean
    

    It returns true, if all members of array list returns true, when applied as argument to predicate function.

    const list = [ 0, 1, 2, 3, 4 ]
    const predicate = x => x > -1
    
    const result = R.all(predicate, list)
    // => true
    

    Try this R.all example in Rambda REPL

    All Typescript definitions typescript all<T>(predicate: (x: T) => boolean, list: T[]): boolean; all<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
    R.all source javascript export function all(predicate, list){ if (arguments.length === 1) return _list => all(predicate, _list) for (let i = 0; i < list.length; i++){ if (!predicate(list[ i ])) return false } return true }
    Tests javascript import { all } from './all' const list = [ 0, 1, 2, 3, 4 ] test('when true', () => { const fn = x => x > -1 expect(all(fn)(list)).toBeTrue() }) test('when false', () => { const fn = x => x > 2 expect(all(fn, list)).toBeFalse() })
    Typescript test typescript import {all} from 'rambda' describe('all', () => { it('happy', () => { const result = all( x => { x // $ExpectType number return x > 0 }, [1, 2, 3] ) result // $ExpectType boolean }) it('curried needs a type', () => { const result = all<number>(x => { x // $ExpectType number return x > 0 })([1, 2, 3]) result // $ExpectType boolean }) })

    ---------------

    allPass

    
    allPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean
    

    It returns true, if all functions of predicates return true, when input is their argument.

    const input = {
      a : 1,
      b : 2,
    }
    const predicates = [
      x => x.a === 1,
      x => x.b === 2,
    ]
    const result = R.allPass(predicates)(input) // => true
    

    Try this R.allPass example in Rambda REPL

    All Typescript definitions typescript allPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
    R.allPass source javascript export function allPass(predicates){ return input => { let counter = 0 while (counter < predicates.length){ if (!predicates[ counter ](input)){ return false } counter++ } return true } }
    Tests javascript import { allPass } from './allPass' test('happy', () => { const rules = [ x => typeof x === 'number', x => x > 10, x => x * 7 < 100 ] expect(allPass(rules)(11)).toBeTrue() expect(allPass(rules)(undefined)).toBeFalse() }) test('when returns true', () => { const conditionArr = [ val => val.a === 1, val => val.b === 2 ] expect(allPass(conditionArr)({ a : 1, b : 2, })).toBeTrue() }) test('when returns false', () => { const conditionArr = [ val => val.a === 1, val => val.b === 3 ] expect(allPass(conditionArr)({ a : 1, b : 2, })).toBeFalse() })
    Typescript test typescript import {allPass} from 'rambda' describe('allPass', () => { it('happy', () => { const x = allPass<number>([ y => { y // $ExpectType number return typeof y === 'number' }, y => { return y > 0 }, ])(11) x // $ExpectType boolean }) })
    1 failed Ramda.allPass specs > :boom: Reason for the failure: Ramda method returns a curried function whose arity matches that of the highest-arity predicate javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('allPass', function() { var odd = function(n) { return n % 2 !== 0; }; var lt20 = function(n) { return n < 20; }; var gt5 = function(n) { return n > 5; }; var plusEq = function(w, x, y, z) { return w + x === y + z; }; it('returns a curried function whose arity matches that of the highest-arity predicate', function() { eq(R.allPass([odd, gt5, plusEq]).length, 4); eq(R.allPass([odd, gt5, plusEq])(9, 9, 9, 9), true); eq(R.allPass([odd, gt5, plusEq])(9)(9)(9)(9), true); }); });

    ---------------

    always

    
    always<T>(x: T): () => T
    

    It returns function that always returns x.

    const fn = R.always(7)
    
    console.log(fn())// => 7
    

    Try this R.always example in Rambda REPL

    All Typescript definitions typescript always<T>(x: T): () => T;
    R.always source javascript export function always(x){ return () => x }
    Tests javascript import { always } from './always' import { F } from './F' test('happy', () => { const fn = always(7) expect(fn()).toEqual(7) expect(fn()).toEqual(7) }) test('f', () => { const fn = always(F()) expect(fn()).toBeFalse() expect(fn()).toBeFalse() })
    Typescript test typescript import {always} from 'rambda' describe('R.always', () => { it('happy', () => { const fn = always('foo') fn // $ExpectType () => string const result = fn() result // $ExpectType string }) })

    ---------------

    and

    
    and<T, U>(x: T, y: U): T | U
    

    Logical AND

    R.and(true, true); // => true
    R.and(false, true); // => false
    R.and(true, 'foo'); // => 'foo'
    

    Try this R.and example in Rambda REPL

    All Typescript definitions typescript and<T, U>(x: T, y: U): T | U; and<T>(x: T): <U>(y: U) => T | U;
    R.and source javascript export function and(a, b){ if (arguments.length === 1) return _b => and(a, _b) return a && b }
    Tests javascript import { and } from './and' test('happy', () => { expect(and(1, 'foo')).toBe('foo') expect(and(true, true)).toBeTrue() expect(and(true)(true)).toBeTrue() expect(and(true, false)).toBeFalse() expect(and(false, true)).toBeFalse() expect(and(false, false)).toBeFalse() })
    Typescript test typescript import {and} from 'rambda' describe('R.and', () => { it('happy', () => { const result = and(true, false) result // $ExpectType boolean }) it('curried', () => { const result = and('foo')(1) result // $ExpectType string | 1 }) })

    ---------------

    any

    
    any<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean
    

    It returns true, if at least one member of list returns true, when passed to a predicate function.

    const list = [1, 2, 3]
    const predicate = x => x * x > 8
    R.any(fn, list)
    // => true
    

    Try this R.any example in Rambda REPL

    All Typescript definitions typescript any<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean; any<T>(predicate: (x: T) => boolean): (list: readonly T[]) => boolean;
    R.any source javascript export function any(predicate, list){ if (arguments.length === 1) return _list => any(predicate, _list) let counter = 0 while (counter < list.length){ if (predicate(list[ counter ], counter)){ return true } counter++ } return false }
    Tests javascript import { any } from './any' const list = [ 1, 2, 3 ] test('happy', () => { expect(any(x => x < 0, list)).toBeFalse() }) test('with curry', () => { expect(any(x => x > 2)(list)).toBeTrue() })
    Typescript test typescript import {any} from 'rambda' describe('R.any', () => { it('happy', () => { const result = any( x => { x // $ExpectType number return x > 2 }, [1, 2, 3] ) result // $ExpectType boolean }) it('when curried needs a type', () => { const result = any<number>(x => { x // $ExpectType number return x > 2 })([1, 2, 3]) result // $ExpectType boolean }) })

    ---------------

    anyPass

    
    anyPass<T>(predicates: SafePred<T>[]): SafePred<T>
    

    It accepts list of predicates and returns a function. This function with its input will return true, if any of predicates returns true for this input.

    const isBig = x => x > 20
    const isOdd = x => x % 2 === 1
    const input = 11
    
    const fn = R.anyPass(
      [isBig, isOdd]
    )
    
    const result = fn(input) 
    // => true
    

    Try this R.anyPass example in Rambda REPL

    All Typescript definitions typescript anyPass<T>(predicates: SafePred<T>[]): SafePred<T>;
    R.anyPass source javascript export function anyPass(predicates){ return input => { let counter = 0 while (counter < predicates.length){ if (predicates[ counter ](input)){ return true } counter++ } return false } }
    Tests javascript import { anyPass } from './anyPass' test('happy', () => { const rules = [ x => typeof x === 'string', x => x > 10 ] const predicate = anyPass(rules) expect(predicate('foo')).toBeTrue() expect(predicate(6)).toBeFalse() }) test('happy', () => { const rules = [ x => typeof x === 'string', x => x > 10 ] expect(anyPass(rules)(11)).toBeTrue() expect(anyPass(rules)(undefined)).toBeFalse() }) const obj = { a : 1, b : 2, } test('when returns true', () => { const conditionArr = [ val => val.a === 1, val => val.a === 2 ] expect(anyPass(conditionArr)(obj)).toBeTrue() }) test('when returns false + curry', () => { const conditionArr = [ val => val.a === 2, val => val.b === 3 ] expect(anyPass(conditionArr)(obj)).toBeFalse() }) test('happy', () => { expect(anyPass([])(3)).toEqual(false) })
    Typescript test typescript import {anyPass} from 'rambda' describe('anyPass', () => { it('happy', () => { const x = anyPass<number>([ y => { y // $ExpectType number return typeof y === 'number' }, y => { return y > 0 }, ])(11) x // $ExpectType boolean }) })
    1 failed Ramda.anyPass specs > :boom: Reason for the failure: Ramda method returns a curried function whose arity matches that of the highest-arity predicate javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('anyPass', function() { var odd = function(n) { return n % 2 !== 0; }; var gt20 = function(n) { return n > 20; }; var lt5 = function(n) { return n < 5; }; var plusEq = function(w, x, y, z) { return w + x === y + z; }; it('returns a curried function whose arity matches that of the highest-arity predicate', function() { eq(R.anyPass([odd, lt5, plusEq]).length, 4); eq(R.anyPass([odd, lt5, plusEq])(6, 7, 8, 9), false); eq(R.anyPass([odd, lt5, plusEq])(6)(7)(8)(9), false); }); });

    ---------------

    append

    
    append<T>(x: T, list: readonly T[]): T[]
    

    It adds element x at the end of list.

    const x = 'foo'
    
    const result = R.append(x, ['bar', 'baz'])
    // => ['bar', 'baz', 'foo']
    

    Try this R.append example in Rambda REPL

    All Typescript definitions typescript append<T>(x: T, list: readonly T[]): T[]; append<T>(x: T): <T>(list: readonly T[]) => T[];
    R.append source javascript export function append(x, input){ if (arguments.length === 1) return _input => append(x, _input) if (typeof input === 'string') return input.split('').concat(x) const clone = input.slice() clone.push(x) return clone }
    Tests javascript import { append } from './append' test('happy', () => { expect(append('tests', [ 'write', 'more' ])).toEqual([ 'write', 'more', 'tests', ]) }) test('append to empty array', () => { expect(append('tests')([])).toEqual([ 'tests' ]) }) test('with strings', () => { expect(append('o', 'fo')).toEqual([ 'f', 'o', 'o' ]) })
    Typescript test typescript import {append} from 'rambda' const list = [1, 2, 3] describe('R.append', () => { it('happy', () => { const result = append(4, list) result // $ExpectType number[] }) it('curried', () => { const result = append(4)(list) result // $ExpectType number[] }) })

    ---------------

    applySpec

    
    applySpec<Spec extends Record<string, (...args: readonly any[]) => any>>(
      spec: Spec
    ): (
      ...args: Parameters<ValueOfRecord<Spec>>
    ) => { [Key in keyof Spec]: ReturnType<Spec[Key]> }
    

    :boom: The currying in this function works best with functions with 4 arguments or less. (arity of 4)

    const fn = R.applySpec({
      sum: R.add,
      nested: { mul: R.multiply }
    })
    const result = fn(2, 4) 
    // => { sum: 6, nested: { mul: 8 } }
    

    Try this R.applySpec example in Rambda REPL

    All Typescript definitions typescript applySpec<Spec extends Record<string, (...args: readonly any[]) => any>>( spec: Spec ): ( ...args: Parameters<ValueOfRecord<Spec>> ) => { [Key in keyof Spec]: ReturnType<Spec[Key]> }; applySpec<T>(spec: any): (...args: readonly any[]) => T;
    R.applySpec source javascript import { _isArray } from './_internals/_isArray' // recursively traverse the given spec object to find the highest arity function function __findHighestArity(spec, max = 0){ for (const key in spec){ if (spec.hasOwnProperty(key) === false || key === 'constructor') continue if (typeof spec[ key ] === 'object'){ max = Math.max(max, __findHighestArity(spec[ key ])) } if (typeof spec[ key ] === 'function'){ max = Math.max(max, spec[ key ].length) } } return max } function __filterUndefined(){ const defined = [] let i = 0 const l = arguments.length while (i < l){ if (typeof arguments[ i ] === 'undefined') break defined[ i ] = arguments[ i ] i++ } return defined } function __applySpecWithArity( spec, arity, cache ){ const remaining = arity - cache.length if (remaining === 1) return x => __applySpecWithArity( spec, arity, __filterUndefined(...cache, x) ) if (remaining === 2) return (x, y) => __applySpecWithArity( spec, arity, __filterUndefined( ...cache, x, y ) ) if (remaining === 3) return ( x, y, z ) => __applySpecWithArity( spec, arity, __filterUndefined( ...cache, x, y, z ) ) if (remaining === 4) return ( x, y, z, a ) => __applySpecWithArity( spec, arity, __filterUndefined( ...cache, x, y, z, a ) ) if (remaining > 4) return (...args) => __applySpecWithArity( spec, arity, __filterUndefined(...cache, ...args) ) // handle spec as Array if (_isArray(spec)){ const ret = [] let i = 0 const l = spec.length for (; i < l; i++){ // handle recursive spec inside array if (typeof spec[ i ] === 'object' || _isArray(spec[ i ])){ ret[ i ] = __applySpecWithArity( spec[ i ], arity, cache ) } // apply spec to the key if (typeof spec[ i ] === 'function'){ ret[ i ] = spec[ i ](...cache) } } return ret } // handle spec as Object const ret = {} // apply callbacks to each property in the spec object for (const key in spec){ if (spec.hasOwnProperty(key) === false || key === 'constructor') continue // apply the spec recursively if (typeof spec[ key ] === 'object'){ ret[ key ] = __applySpecWithArity( spec[ key ], arity, cache ) continue } // apply spec to the key if (typeof spec[ key ] === 'function'){ ret[ key ] = spec[ key ](...cache) } } return ret } export function applySpec(spec, ...args){ // get the highest arity spec function, cache the result and pass to __applySpecWithArity const arity = __findHighestArity(spec) if (arity === 0){ return () => ({}) } const toReturn = __applySpecWithArity( spec, arity, args ) return toReturn }
    Tests javascript import { applySpec as applySpecRamda, nAry } from 'ramda' import { add, always, compose, dec, inc, map, path, prop, T } from '../rambda' import { applySpec } from './applySpec' test('different than Ramda when bad spec', () => { const result = applySpec({ sum : { a : 1 } })(1, 2) const ramdaResult = applySpecRamda({ sum : { a : 1 } })(1, 2) expect(result).toEqual({}) expect(ramdaResult).toEqual({ sum : { a : {} } }) }) test('works with empty spec', () => { expect(applySpec({})()).toEqual({}) expect(applySpec([])(1, 2)).toEqual({}) expect(applySpec(null)(1, 2)).toEqual({}) }) test('works with unary functions', () => { const result = applySpec({ v : inc, u : dec, })(1) const expected = { v : 2, u : 0, } expect(result).toEqual(expected) }) test('works with binary functions', () => { const result = applySpec({ sum : add })(1, 2) expect(result).toEqual({ sum : 3 }) }) test('works with nested specs', () => { const result = applySpec({ unnested : always(0), nested : { sum : add }, })(1, 2) const expected = { unnested : 0, nested : { sum : 3 }, } expect(result).toEqual(expected) }) test('works with arrays of nested specs', () => { const result = applySpec({ unnested : always(0), nested : [ { sum : add } ], })(1, 2) expect(result).toEqual({ unnested : 0, nested : [ { sum : 3 } ], }) }) test('works with arrays of spec objects', () => { const result = applySpec([ { sum : add } ])(1, 2) expect(result).toEqual([ { sum : 3 } ]) }) test('works with arrays of functions', () => { const result = applySpec([ map(prop('a')), map(prop('b')) ])([ { a : 'a1', b : 'b1', }, { a : 'a2', b : 'b2', }, ]) const expected = [ [ 'a1', 'a2' ], [ 'b1', 'b2' ], ] expect(result).toEqual(expected) }) test('works with a spec defining a map key', () => { expect(applySpec({ map : prop('a') })({ a : 1 })).toEqual({ map : 1 }) }) test('cannot retains the highest arity', () => { const f = applySpec({ f1 : nAry(2, T), f2 : nAry(5, T), }) const fRamda = applySpecRamda({ f1 : nAry(2, T), f2 : nAry(5, T), }) expect(f.length).toBe(0) expect(fRamda.length).toBe(5) }) test('returns a curried function', () => { expect(applySpec({ sum : add })(1)(2)).toEqual({ sum : 3 }) }) // Additional tests // ============================================ test('arity', () => { const spec = { one : x1 => x1, two : (x1, x2) => x1 + x2, three : ( x1, x2, x3 ) => x1 + x2 + x3, } expect(applySpec( spec, 1, 2, 3 )).toEqual({ one : 1, two : 3, three : 6, }) }) test('arity over 5 arguments', () => { const spec = { one : x1 => x1, two : (x1, x2) => x1 + x2, three : ( x1, x2, x3 ) => x1 + x2 + x3, four : ( x1, x2, x3, x4 ) => x1 + x2 + x3 + x4, five : ( x1, x2, x3, x4, x5 ) => x1 + x2 + x3 + x4 + x5, } expect(applySpec( spec, 1, 2, 3, 4, 5 )).toEqual({ one : 1, two : 3, three : 6, four : 10, five : 15, }) }) test('curried', () => { const spec = { one : x1 => x1, two : (x1, x2) => x1 + x2, three : ( x1, x2, x3 ) => x1 + x2 + x3, } expect(applySpec(spec)(1)(2)(3)).toEqual({ one : 1, two : 3, three : 6, }) }) test('curried over 5 arguments', () => { const spec = { one : x1 => x1, two : (x1, x2) => x1 + x2, three : ( x1, x2, x3 ) => x1 + x2 + x3, four : ( x1, x2, x3, x4 ) => x1 + x2 + x3 + x4, five : ( x1, x2, x3, x4, x5 ) => x1 + x2 + x3 + x4 + x5, } expect(applySpec(spec)(1)(2)(3)(4)(5)).toEqual({ one : 1, two : 3, three : 6, four : 10, five : 15, }) }) test('undefined property', () => { const spec = { prop : path([ 'property', 'doesnt', 'exist' ]) } expect(applySpec(spec, {})).toEqual({ prop : undefined }) }) test('restructure json object', () => { const spec = { id : path('user.id'), name : path('user.firstname'), profile : path('user.profile'), doesntExist : path('user.profile.doesntExist'), info : { views : compose(inc, prop('views')) }, type : always('playa'), } const data = { user : { id : 1337, firstname : 'john', lastname : 'shaft', profile : 'shaft69', }, views : 42, } expect(applySpec(spec, data)).toEqual({ id : 1337, name : 'john', profile : 'shaft69', doesntExist : undefined, info : { views : 43 }, type : 'playa', }) })
    Typescript test typescript import {multiply, applySpec, inc, dec, add} from 'rambda' describe('applySpec', () => { it('ramda 1', () => { const result = applySpec({ v: inc, u: dec, })(1) result // $ExpectType { v: number; u: number; } }) it('ramda 1', () => { interface Output { sum: number, multiplied: number, } const result = applySpec<Output>({ sum: add, multiplied: multiply, })(1, 2) result // $ExpectType Output }) })

    ---------------

    assoc

    
    assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & U
    

    It makes a shallow clone of obj with setting or overriding the property prop with newValue.

    :boom: This copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.

    R.assoc('c', 3, {a: 1, b: 2})
    //=> {a: 1, b: 2, c: 3}
    

    Try this R.assoc example in Rambda REPL

    All Typescript definitions typescript assoc<T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & U; assoc<T, K extends string>(prop: K, val: T): <U>(obj: U) => Record<K, T> & U; assoc<K extends string>(prop: K): AssocPartialOne<K>;
    R.assoc source javascript import { curry } from './curry' function assocFn( prop, newValue, obj ){ return Object.assign( {}, obj, { [ prop ] : newValue } ) } export const assoc = curry(assocFn)
    Tests javascript import { assoc } from './assoc' test('adds a key to an empty object', () => { expect(assoc( 'a', 1, {} )).toEqual({ a : 1 }) }) test('adds a key to a non-empty object', () => { expect(assoc( 'b', 2, { a : 1 } )).toEqual({ a : 1, b : 2, }) }) test('adds a key to a non-empty object - curry case 1', () => { expect(assoc('b', 2)({ a : 1 })).toEqual({ a : 1, b : 2, }) }) test('adds a key to a non-empty object - curry case 2', () => { expect(assoc('b')(2, { a : 1 })).toEqual({ a : 1, b : 2, }) }) test('adds a key to a non-empty object - curry case 3', () => { const result = assoc('b')(2)({ a : 1 }) expect(result).toEqual({ a : 1, b : 2, }) }) test('changes an existing key', () => { expect(assoc( 'a', 2, { a : 1 } )).toEqual({ a : 2 }) }) test('undefined is considered an empty object', () => { expect(assoc( 'a', 1, undefined )).toEqual({ a : 1 }) }) test('null is considered an empty object', () => { expect(assoc( 'a', 1, null )).toEqual({ a : 1 }) }) test('value can be null', () => { expect(assoc( 'a', null, null )).toEqual({ a : null }) }) test('value can be undefined', () => { expect(assoc( 'a', undefined, null )).toEqual({ a : undefined }) }) test('assignment is shallow', () => { expect(assoc( 'a', { b : 2 }, { a : { c : 3 } } )).toEqual({ a : { b : 2 } }) })
    Typescript test typescript import {assoc} from 'rambda' const obj = {a: 1} const newValue = 2 const newProp = 'b' describe('R.assoc', () => { it('happy', () => { const result = assoc(newProp, newValue, obj) result.a // $ExpectType number result.b // $ExpectType number }) it('curried 1', () => { const result = assoc(newProp, newValue)(obj) result.a // $ExpectType number result.b // $ExpectType number }) it('curried 2', () => { const result = assoc(newProp)(newValue)(obj) result.a // $ExpectType number result.b // $ExpectType number }) })

    ---------------

    assocPath

    
    assocPath<Output>(path: Path, newValue: any, obj: object): Output
    

    It makes a shallow clone of obj with setting or overriding with newValue the property found with path.

    const path = 'b.c'
    const newValue = 2
    const obj = { a: 1 }
    
    R.assocPath(path, newValue, obj)
    // => { a : 1, b : { c : 2 }}
    

    Try this R.assocPath example in Rambda REPL

    All Typescript definitions typescript assocPath<Output>(path: Path, newValue: any, obj: object): Output; assocPath<Output>(path: Path, newValue: any): (obj: object) => Output; assocPath<Output>(path: Path): FunctionToolbelt.Curry<(newValue: any, obj: object) => Output>;
    R.assocPath source javascript import { _isArray } from './_internals/_isArray' import { _isInteger } from './_internals/_isInteger' import { assoc } from './assoc' import { curry } from './curry' function assocPathFn( path, newValue, input ){ const pathArrValue = typeof path === 'string' ? path.split('.').map(x => _isInteger(Number(x)) ? Number(x) : x) : path if (pathArrValue.length === 0){ return newValue } const index = pathArrValue[ 0 ] if (pathArrValue.length > 1){ const condition = typeof input !== 'object' || input === null || !input.hasOwnProperty(index) const nextinput = condition ? _isInteger(pathArrValue[ 1 ]) ? [] : {} : input[ index ] newValue = assocPathFn( Array.prototype.slice.call(pathArrValue, 1), newValue, nextinput ) } if (_isInteger(index) && _isArray(input)){ const arr = input.slice() arr[ index ] = newValue return arr } return assoc( index, newValue, input ) } export const assocPath = curry(assocPathFn)
    Tests javascript import { assocPath } from './assocPath' test('string can be used as path input', () => { const testObj = { a : [ { b : 1 }, { b : 2 } ], d : 3, } const result = assocPath( 'a.0.b', 10, testObj ) const expected = { a : [ { b : 10 }, { b : 2 } ], d : 3, } expect(result).toEqual(expected) }) test('bug', () => { /* https://github.com/selfrefactor/rambda/issues/524 */ const state = {} const withDateLike = assocPath( [ 'outerProp', '2020-03-10' ], { prop : 2 }, state ) const withNumber = assocPath( [ 'outerProp', '5' ], { prop : 2 }, state ) const withDateLikeExpected = { outerProp : { '2020-03-10' : { prop : 2 } } } const withNumberExpected = { outerProp : { 5 : { prop : 2 } } } expect(withDateLike).toEqual(withDateLikeExpected) expect(withNumber).toEqual(withNumberExpected) }) test('adds a key to an empty object', () => { expect(assocPath( [ 'a' ], 1, {} )).toEqual({ a : 1 }) }) test('adds a key to a non-empty object', () => { expect(assocPath( 'b', 2, { a : 1 } )).toEqual({ a : 1, b : 2, }) }) test('adds a nested key to a non-empty object', () => { expect(assocPath( 'b.c', 2, { a : 1 } )).toEqual({ a : 1, b : { c : 2 }, }) }) test('adds a nested key to a nested non-empty object - curry case 1', () => { expect(assocPath('b.d', 3)({ a : 1, b : { c : 2 }, })).toEqual({ a : 1, b : { c : 2, d : 3, }, }) }) test('adds a key to a non-empty object - curry case 1', () => { expect(assocPath('b', 2)({ a : 1 })).toEqual({ a : 1, b : 2, }) }) test('adds a nested key to a non-empty object - curry case 1', () => { expect(assocPath('b.c', 2)({ a : 1 })).toEqual({ a : 1, b : { c : 2 }, }) }) test('adds a key to a non-empty object - curry case 2', () => { expect(assocPath('b')(2, { a : 1 })).toEqual({ a : 1, b : 2, }) }) test('adds a key to a non-empty object - curry case 3', () => { const result = assocPath('b')(2)({ a : 1 }) expect(result).toEqual({ a : 1, b : 2, }) }) test('changes an existing key', () => { expect(assocPath( 'a', 2, { a : 1 } )).toEqual({ a : 2 }) }) test('undefined is considered an empty object', () => { expect(assocPath( 'a', 1, undefined )).toEqual({ a : 1 }) }) test('null is considered an empty object', () => { expect(assocPath( 'a', 1, null )).toEqual({ a : 1 }) }) test('value can be null', () => { expect(assocPath( 'a', null, null )).toEqual({ a : null }) }) test('value can be undefined', () => { expect(assocPath( 'a', undefined, null )).toEqual({ a : undefined }) }) test('assignment is shallow', () => { expect(assocPath( 'a', { b : 2 }, { a : { c : 3 } } )).toEqual({ a : { b : 2 } }) }) test('empty array as path', () => { const result = assocPath( [], 3, { a : 1, b : 2, } ) expect(result).toEqual(3) }) test('happy', () => { const expected = { foo : { bar : { baz : 42 } } } const result = assocPath( [ 'foo', 'bar', 'baz' ], 42, { foo : null } ) expect(result).toEqual(expected) })
    Typescript test typescript import {assocPath} from 'rambda' interface Output { a: number, foo: {bar: number}, } describe('R.assocPath - user must explicitly set type of output', () => { it('with array as path input', () => { const result = assocPath<Output>(['foo', 'bar'], 2, {a: 1}) result // $ExpectType Output }) it('with string as path input', () => { const result = assocPath<Output>('foo.bar', 2, {a: 1}) result // $ExpectType Output }) }) describe('R.assocPath - curried', () => { it('with array as path input', () => { const result = assocPath<Output>(['foo', 'bar'], 2)({a: 1}) result // $ExpectType Output }) it('with string as path input', () => { const result = assocPath<Output>('foo.bar', 2)({a: 1}) result // $ExpectType Output }) })

    ---------------

    both

    
    both(pred1: Pred, pred2: Pred): Pred
    

    It returns a function with input argument.

    This function will return true, if both firstCondition and secondCondition return true when input is passed as their argument.

    const firstCondition = x => x > 10
    const secondCondition = x => x < 20
    const fn = R.both(secondCondition)
    
    const result = [fn(15), fn(30)]
    // => [true, false]
    

    Try this R.both example in Rambda REPL

    All Typescript definitions typescript both(pred1: Pred, pred2: Pred): Pred; both<T>(pred1: Predicate<T>, pred2: Predicate<T>): Predicate<T>; both<T>(pred1: Predicate<T>): (pred2: Predicate<T>) => Predicate<T>; both(pred1: Pred): (pred2: Pred) => Pred;
    R.both source javascript export function both(f, g){ if (arguments.length === 1) return _g => both(f, _g) return (...input) => f(...input) && g(...input) }
    Tests javascript import { both } from './both' const firstFn = val => val > 0 const secondFn = val => val < 10 test('with curry', () => { expect(both(firstFn)(secondFn)(17)).toBeFalse() }) test('without curry', () => { expect(both(firstFn, secondFn)(7)).toBeTrue() }) test('with multiple inputs', () => { const between = function ( a, b, c ){ return a < b && b < c } const total20 = function ( a, b, c ){ return a + b + c === 20 } const fn = both(between, total20) expect(fn( 5, 7, 8 )).toBeTrue() }) test('skip evaluation of the second expression', () => { let effect = 'not evaluated' const F = function (){ return false } const Z = function (){ effect = 'Z got evaluated' } both(F, Z)() expect(effect).toBe('not evaluated') })
    Typescript test typescript import {both} from 'rambda' describe('R.both', () => { it('with passed type', () => { const fn = both<number>( x => x > 1, x => x % 2 === 0 ) fn // $ExpectType Predicate<number> const result = fn(2) // $ExpectType boolean result // $ExpectType boolean }) it('with passed type - curried', () => { const fn = both<number>(x => x > 1)(x => x % 2 === 0) fn // $ExpectType Predicate<number> const result = fn(2) result // $ExpectType boolean }) it('no type passed', () => { const fn = both( x => { x // $ExpectType any return x > 1 }, x => { x // $ExpectType any return x % 2 === 0 } ) const result = fn(2) result // $ExpectType boolean }) it('no type passed - curried', () => { const fn = both((x: number) => { x // $ExpectType number return x > 1 })((x: number) => { x // $ExpectType number return x % 2 === 0 }) const result = fn(2) result // $ExpectType boolean }) })
    1 failed Ramda.both specs > :boom: Reason for the failure: Ramda library supports fantasy-land javascript var S = require('sanctuary'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('both', function() { it('accepts fantasy-land applicative functors', function() { var Just = S.Just; var Nothing = S.Nothing; eq(R.both(Just(true), Just(true)), Just(true)); eq(R.both(Just(true), Just(false)), Just(false)); eq(R.both(Just(true), Nothing()), Nothing()); eq(R.both(Nothing(), Just(false)), Nothing()); eq(R.both(Nothing(), Nothing()), Nothing()); }); });

    ---------------

    chain

    
    chain<T, U>(fn: (n: T) => U[], list: readonly T[]): U[]
    

    The method is also known as flatMap.

    const duplicate = n => [ n, n ]
    const list = [ 1, 2, 3 ]
    
    const result = chain(duplicate, list)
    // => [ 1, 1, 2, 2, 3, 3 ]
    

    Try this R.chain example in Rambda REPL

    All Typescript definitions typescript chain<T, U>(fn: (n: T) => U[], list: readonly T[]): U[]; chain<T, U>(fn: (n: T) => U[]): (list: readonly T[]) => U[]; chain<X0, X1, R>(fn: (x0: X0, x1: X1) => R, fn1: (x1: X1) => X0): (x1: X1) => R;
    R.chain source javascript export function chain(fn, list){ if (arguments.length === 1){ return _list => chain(fn, _list) } return [].concat(...list.map(fn)) }
    Tests javascript import { chain } from './chain' const duplicate = n => [ n, n ] test('happy', () => { const fn = x => [ x * 2 ] const list = [ 1, 2, 3 ] const result = chain(fn, list) expect(result).toEqual([ 2, 4, 6 ]) }) test('maps then flattens one level', () => { expect(chain(duplicate, [ 1, 2, 3 ])).toEqual([ 1, 1, 2, 2, 3, 3 ]) }) test('maps then flattens one level - curry', () => { expect(chain(duplicate)([ 1, 2, 3 ])).toEqual([ 1, 1, 2, 2, 3, 3 ]) }) test('flattens only one level', () => { const nest = n => [ [ n ] ] expect(chain(nest, [ 1, 2, 3 ])).toEqual([ [ 1 ], [ 2 ], [ 3 ] ]) })
    Typescript test typescript import {chain} from 'rambda' const list = [1, 2, 3] const fn = (x: number) => [`${x}`, `${x}`] describe('R.chain', () => { it('without passing type', () => { const result = chain(fn, list) result // $ExpectType string[] const resultCurried = chain(fn)(list) resultCurried // $ExpectType string[] }) })

    5 failed Ramda.chain specs

    :boom: Reason for the failure: Ramda method passes to chain property if available | Ramda library supports fantasy-land

    ---------------

    clamp

    
    clamp(min: number, max: number, input: number): number
    

    Restrict a number input to be withing min and max limits.

    If input is bigger than max, then the result is max.

    If input is smaller than min, then the result is min.

    R.clamp(0, 10, 5) //=> 5
    R.clamp(0, 10, -1) //=> 0
    R.clamp(0, 10, 11) //=> 10
    

    Try this R.clamp example in Rambda REPL

    All Typescript definitions typescript clamp(min: number, max: number, input: number): number; clamp(min: number, max: number): (input: number) => number;
    R.clamp source javascript import { curry } from './curry' function clampFn( min, max, input ){ if (min > max){ throw new Error('min must not be greater than max in clamp(min, max, value)') } if (input >= min && input <= max) return input if (input > max) return max if (input < min) return min } export const clamp = curry(clampFn)
    Tests javascript import { clamp } from './clamp' test('when min is greater than max', () => { expect(() => clamp( -5, -10, 5 )).toThrowWithMessage(Error, 'min must not be greater than max in clamp(min, max, value)') }) test('rambda specs', () => { expect(clamp( 1, 10, 0 )).toEqual(1) expect(clamp( 3, 12, 1 )).toEqual(3) expect(clamp( -15, 3, -100 )).toEqual(-15) expect(clamp( 1, 10, 20 )).toEqual(10) expect(clamp( 3, 12, 23 )).toEqual(12) expect(clamp( -15, 3, 16 )).toEqual(3) expect(clamp( 1, 10, 4 )).toEqual(4) expect(clamp( 3, 12, 6 )).toEqual(6) expect(clamp( -15, 3, 0 )).toEqual(0) })
    Typescript test typescript import {clamp} from 'rambda' describe('R.clamp', () => { it('happy', () => { const result = clamp(1, 10, 20) result // $ExpectType number }) })

    ---------------

    clone

    
    clone<T>(input: T): T
    

    It creates a deep copy of the input, which may contain (nested) Arrays and Objects, Numbers, Strings, Booleans and Dates.

    const objects = [{a: 1}, {b: 2}];
    const objectsClone = R.clone(objects);
    
    const result = [
      R.equals(objects, objectsClone),
      R.equals(objects[0], objectsClone[0]),
    ] // => [ true, true ]
    

    Try this R.clone example in Rambda REPL

    All Typescript definitions typescript clone<T>(input: T): T; clone<T>(input: readonly T[]): T[];
    R.clone source javascript import { _isArray } from './_internals/_isArray' export function clone(input){ const out = _isArray(input) ? Array(input.length) : {} if (input && input.getTime) return new Date(input.getTime()) for (const key in input){ const v = input[ key ] out[ key ] = typeof v === 'object' && v !== null ? v.getTime ? new Date(v.getTime()) : clone(v) : v } return out }
    Tests javascript import assert from 'assert' import { clone } from './clone' import { equals } from './equals' test('with array', () => { const arr = [ { b : 2, c : 'foo', d : [ 1, 2, 3 ], }, 1, new Date(), null, ] expect(clone(arr)).toEqual(arr) }) test('with object', () => { const obj = { a : 1, b : 2, c : 3, d : [ 1, 2, 3 ], e : new Date(), } expect(clone(obj)).toEqual(obj) }) test('with date', () => { const date = new Date( 2014, 10, 14, 23, 59, 59, 999 ) const cloned = clone(date) assert.notStrictEqual(date, cloned) expect(cloned).toEqual(new Date( 2014, 10, 14, 23, 59, 59, 999 )) expect(cloned.getDay()).toEqual(5) }) test('with R.equals', () => { const objects = [ { a : 1 }, { b : 2 } ] const objectsClone = clone(objects) const result = [ equals(objects, objectsClone), equals(objects[ 0 ], objectsClone[ 0 ]), ] expect(result).toEqual([ true, true ]) })
    Typescript test typescript import {clone} from 'rambda' describe('R.clone', () => { it('happy', () => { const obj = {a: 1, b: 2} const result = clone(obj) result // $ExpectType { a: number; b: number; } }) })
    9 failed Ramda.clone specs > :boom: Reason for the failure: Rambda method work only with objects and arrays javascript var assert = require('assert'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('deep clone integers, strings and booleans', function() { it('clones integers', function() { eq(R.clone(-4), -4); eq(R.clone(9007199254740991), 9007199254740991); }); it('clones floats', function() { eq(R.clone(-4.5), -4.5); eq(R.clone(0.0), 0.0); }); it('clones strings', function() { eq(R.clone('ramda'), 'ramda'); }); it('clones booleans', function() { eq(R.clone(true), true); }); }); describe('deep clone objects', function() { it('clones objects with circular references', function() { var x = {c: null}; var y = {a: x}; var z = {b: y}; x.c = z; var clone = R.clone(x); assert.notStrictEqual(x, clone); assert.notStrictEqual(x.c, clone.c); assert.notStrictEqual(x.c.b, clone.c.b); assert.notStrictEqual(x.c.b.a, clone.c.b.a); assert.notStrictEqual(x.c.b.a.c, clone.c.b.a.c); eq(R.keys(clone), R.keys(x)); eq(R.keys(clone.c), R.keys(x.c)); eq(R.keys(clone.c.b), R.keys(x.c.b)); eq(R.keys(clone.c.b.a), R.keys(x.c.b.a)); eq(R.keys(clone.c.b.a.c), R.keys(x.c.b.a.c)); x.c.b = 1; assert.notDeepEqual(clone.c.b, x.c.b); }); }); describe('deep clone arrays', function() { }); describe('deep clone functions', function() { }); describe('built-in types', function() { it('clones RegExp object', function() { R.forEach(function(pattern) { var clone = R.clone(pattern); assert.notStrictEqual(clone, pattern); eq(clone.constructor, RegExp); eq(clone.source, pattern.source); eq(clone.global, pattern.global); eq(clone.ignoreCase, pattern.ignoreCase); eq(clone.multiline, pattern.multiline); }, [/x/, /x/g, /x/i, /x/m, /x/gi, /x/gm, /x/im, /x/gim]); }); }); describe('deep clone deep nested mixed objects', function() { it('clones array with mutual ref object', function() { var obj = {a: 1}; var list = [{b: obj}, {b: obj}]; var clone = R.clone(list); assert.strictEqual(list[0].b, list[1].b); assert.strictEqual(clone[0].b, clone[1].b); assert.notStrictEqual(clone[0].b, list[0].b); assert.notStrictEqual(clone[1].b, list[1].b); eq(clone[0].b, {a:1}); eq(clone[1].b, {a:1}); obj.a = 2; eq(clone[0].b, {a:1}); eq(clone[1].b, {a:1}); }); }); describe('deep clone edge cases', function() { it('nulls, undefineds and empty objects and arrays', function() { eq(R.clone(null), null); eq(R.clone(undefined), undefined); assert.notStrictEqual(R.clone(undefined), null); var obj = {}; assert.notStrictEqual(R.clone(obj), obj); var list = []; assert.notStrictEqual(R.clone(list), list); }); }); describe('Let `R.clone` use an arbitrary user defined `clone` method', function() { it('dispatches to `clone` method if present', function() { function ArbitraryClone(x) { this.value = x; } ArbitraryClone.prototype.clone = function() { return new ArbitraryClone(this.value); }; var obj = new ArbitraryClone(42); var arbitraryClonedObj = R.clone(obj); eq(arbitraryClonedObj, new ArbitraryClone(42)); eq(arbitraryClonedObj instanceof ArbitraryClone, true); }); });

    ---------------

    complement

    
    complement(pred: (...args: readonly any[]) => boolean): (...args: readonly any[]) => boolean
    

    It returns inverted version of origin function that accept input as argument.

    The return value of inverted is the negative boolean value of origin(input).

    const origin = x => x > 5
    const inverted = complement(origin)
    
    const result = [
      origin(7),
      inverted(7)
    ] => [ true, false ]
    

    Try this R.complement example in Rambda REPL

    All Typescript definitions typescript complement(pred: (...args: readonly any[]) => boolean): (...args: readonly any[]) => boolean;
    R.complement source javascript export function complement(fn){ return (...input) => !fn(...input) }
    Tests javascript import { complement } from './complement' test('happy', () => { const fn = complement(x => x.length === 0) expect(fn([ 1, 2, 3 ])).toBeTrue() }) test('with multiple parameters', () => { const between = function ( a, b, c ){ return a < b && b < c } const f = complement(between) expect(f( 4, 5, 11 )).toEqual(false) expect(f( 12, 2, 6 )).toEqual(true) })
    Typescript test typescript import {complement, isNil} from 'rambda' describe('R.complement', () => { it('happy', () => { const fn = complement(isNil) const result = fn(null) result // $ExpectType boolean }) })
    1 failed Ramda.complement specs > :boom: Reason for the failure: Ramda library supports fantasy-land javascript var S = require('sanctuary'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('complement', function() { it('accepts fantasy-land functors', function() { var Just = S.Just; var Nothing = S.Nothing; eq(R.complement(Just(true)), Just(false)); eq(R.complement(Just(false)), Just(true)); eq(R.complement(Nothing()), Nothing()); }); });

    ---------------

    compose

    
    compose<T1>(fn0: () => T1): () => T1
    

    It performs right-to-left function composition.

    const result = R.compose(
      R.map(x => x * 2),
      R.filter(x => x > 2)
    )([1, 2, 3, 4])
    
    // => [6, 8]
    

    Try this R.compose example in Rambda REPL

    All Typescript definitions typescript compose<T1>(fn0: () => T1): () => T1; compose<V0, T1>(fn0: (x0: V0) => T1): (x0: V0) => T1; compose<V0, V1, T1>(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1; compose<V0, V1, V2, T1>(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1; compose<T1, T2>(fn1: (x: T1) => T2, fn0: () => T1): () => T2; compose<V0, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0) => T1): (x0: V0) => T2; compose<V0, V1, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T2; compose<V0, V1, V2, T1, T2>(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T2; compose<T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T3; compose<V0, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T3; compose<V0, V1, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T3; compose<V0, V1, V2, T1, T2, T3>(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T3; compose<T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T4; compose<V0, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T4; compose<V0, V1, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T4; compose<V0, V1, V2, T1, T2, T3, T4>(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T4; compose<T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T5; compose<V0, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T5; compose<V0, V1, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T5; compose<V0, V1, V2, T1, T2, T3, T4, T5>(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T5; compose<T1, T2, T3, T4, T5, T6>(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T6; compose<V0, T1, T2, T3, T4, T5, T6>(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T6; compose<V0, V1, T1, T2, T3, T4, T5, T6>( fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T6; compose<V0, V1, V2, T1, T2, T3, T4, T5, T6>( fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T6;
    R.compose source javascript export function compose(...fns){ if (fns.length === 0){ throw new Error('compose requires at least one argument') } return (...args) => { const list = fns.slice() if (list.length > 0){ const fn = list.pop() let result = fn(...args) while (list.length > 0){ result = list.pop()(result) } return result } } }
    Tests javascript import { add } from './add' import { compose } from './compose' import { filter } from './filter' import { last } from './last' import { map } from './map' test('happy', () => { const result = compose( last, map(add(10)), map(add(1)) )([ 1, 2, 3 ]) expect(result).toEqual(14) }) test('can accepts initially two arguments', () => { const result = compose(map(x => x * 2), (list, limit) => filter(x => x > limit, list))([ 1, 2, 3, 4, false ], 2) expect(result).toEqual([ 6, 8 ]) }) test('when no arguments is passed', () => { expect(() => compose()).toThrow('compose requires at least one argument') }) test('ramda spec', () => { const f = function ( a, b, c ){ return [ a, b, c ] } const g = compose(f) expect(g( 1, 2, 3 )).toEqual([ 1, 2, 3 ]) })
    Typescript test typescript import {add, subtract, compose} from 'rambda' describe('R.compose', () => { it('happy', () => { const result = compose(subtract(11), add(1), add(1))(1) result // $ExpectType number }) it('with void', () => { const result = compose( () => {}, () => {} )() result // $ExpectType void }) })
    3 failed Ramda.compose specs > :boom: Reason for the failure: Ramda method passes context to functions | Rambda composed functions have no length javascript var assert = require('assert'); var jsv = require('jsverify'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('compose', function() { it('performs right-to-left function composition', function() { // f :: (String, Number?) -> ([Number] -> [Number]) var f = R.compose(R.map, R.multiply, parseInt); eq(f.length, 2); eq(f('10')([1, 2, 3]), [10, 20, 30]); eq(f('10', 2)([1, 2, 3]), [2, 4, 6]); }); it('passes context to functions', function() { function x(val) { return this.x * val; } function y(val) { return this.y * val; } function z(val) { return this.z * val; } var context = { a: R.compose(x, y, z), x: 4, y: 2, z: 1 }; eq(context.a(5), 40); }); it('can be applied to one argument', function() { var f = function(a, b, c) { return [a, b, c]; }; var g = R.compose(f); eq(g.length, 3); eq(g(1, 2, 3), [1, 2, 3]); }); }); describe('compose properties', function() { jsv.property('composes two functions', jsv.fn(), jsv.fn(), jsv.nat, function(f, g, x) { return R.equals(R.compose(f, g)(x), f(g(x))); jsv.property('associative', jsv.fn(), jsv.fn(), jsv.fn(), jsv.nat, function(f, g, h, x) { var result = f(g(h(x))); return R.all(R.equals(result), [ R.compose(f, g, h)(x), R.compose(f, R.compose(g, h))(x), R.compose(R.compose(f, g), h)(x) ]); });

    ---------------

    concat

    
    concat<T>(x: readonly T[], y: readonly T[]): T[]
    

    It returns a new string or array, which is the result of merging x and y.

    R.concat([1, 2])([3, 4]) // => [1, 2, 3, 4]
    R.concat('foo', 'bar') // => 'foobar'
    

    Try this R.concat example in Rambda REPL

    All Typescript definitions typescript concat<T>(x: readonly T[], y: readonly T[]): T[]; concat<T>(x: readonly T[]): (y: readonly T[]) => T[]; concat(x: string, y: string): string; concat(x: string): (y: string) => string;
    R.concat source javascript export function concat(x, y){ if (arguments.length === 1) return _y => concat(x, _y) return typeof x === 'string' ? `${ x }${ y }` : [ ...x, ...y ] }
    Tests javascript import { concat } from './concat' test('happy', () => { const arr1 = [ 'a', 'b', 'c' ] const arr2 = [ 'd', 'e', 'f' ] const a = concat(arr1, arr2) const b = concat(arr1)(arr2) const expectedResult = [ 'a', 'b', 'c', 'd', 'e', 'f' ] expect(a).toEqual(expectedResult) expect(b).toEqual(expectedResult) }) test('with strings', () => { expect(concat('ABC', 'DEF')).toEqual('ABCDEF') })
    Typescript test typescript import {concat} from 'rambda' const list1 = [1, 2, 3] const list2 = [4, 5, 6] describe('R.concat', () => { it('happy', () => { const result = concat(list1, list2) result // $ExpectType number[] }) it('curried', () => { const result = concat(list1)(list2) result // $ExpectType number[] }) })
    1 failed Ramda.concat specs > :boom: Reason for the failure: Ramda method pass to concat property if present javascript var assert = require('assert'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('concat', function() { var z1 = { x: 'z1', concat: function(that) { return this.x + ' ' + that.x; } }; var z2 = { x: 'z2' }; it('delegates to non-String object with a concat method, as second param', function() { eq(R.concat(z1, z2), 'z1 z2'); }); });

    ---------------

    cond

    
    cond(conditions: [Pred, (...a: readonly any[]) => any][]): (...x: readonly any[]) => any
    

    It takes list with conditions and returns a new function fn that expects input as argument.

    This function will start evaluating the conditions in order to find the first winner(order of conditions matter).

    The winner is this condition, which left side returns true when input is its argument. Then the evaluation of the right side of the winner will be the final result.

    If no winner is found, then fn returns undefined.

    const fn = R.cond([
      [ x => x > 25, R.always('more than 25') ],
      [ x => x > 15, R.always('more than 15') ],
      [ R.T, x => `${x} is nothing special` ],
    ])
    
    const result = [
      fn(30),
      fn(20),
      fn(10),
    ] 
    // => ['more than 25', 'more than 15', '10 is nothing special']
    

    Try this R.cond example in Rambda REPL

    All Typescript definitions typescript cond(conditions: [Pred, (...a: readonly any[]) => any][]): (...x: readonly any[]) => any; cond<A, B>(conditions: [SafePred<A>, (...a: readonly A[]) => B][]): (...x: readonly A[]) => B;
    R.cond source javascript export function cond(conditions){ return input => { let done = false let toReturn conditions.forEach(([ predicate, resultClosure ]) => { if (!done && predicate(input)){ done = true toReturn = resultClosure(input) } }) return toReturn } }
    Tests javascript import { always } from './always' import { cond } from './cond' import { equals } from './equals' import { T } from './T' test('returns a function', () => { expect(typeof cond([])).toEqual('function') }) test('returns a conditional function', () => { const fn = cond([ [ equals(0), always('water freezes at 0°C') ], [ equals(100), always('water boils at 100°C') ], [ T, function (temp){ return 'nothing special happens at ' + temp + '°C' }, ], ]) expect(fn(0)).toEqual('water freezes at 0°C') expect(fn(50)).toEqual('nothing special happens at 50°C') expect(fn(100)).toEqual('water boils at 100°C') }) test('no winner', () => { const fn = cond([ [ equals('foo'), always(1) ], [ equals('bar'), always(2) ], ]) expect(fn('quux')).toEqual(undefined) }) test('predicates are tested in order', () => { const fn = cond([ [ T, always('foo') ], [ T, always('bar') ], [ T, always('baz') ], ]) expect(fn()).toEqual('foo') })
    Typescript test typescript import {cond, always, equals} from 'rambda' describe('R.cond', () => { it('happy', () => { const fn = cond<number, string>([ [equals(0), always('water freezes at 0°C')], [equals(100), always('water boils at 100°C')], [ () => true, function(temp) { return 'nothing special happens at ' + temp + '°C' }, ], ]) const result = fn(0) result // $ExpectType string }) })
    2 failed Ramda.cond specs > :boom: Reason for the failure: pass to transformer is not applied in Rambda method javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('cond', function() { it('forwards all arguments to predicates and to transformers', function() { var fn = R.cond([ [function(_, x) { return x === 42; }, function() { return arguments.length; }] ]); eq(fn(21, 42, 84), 3); }); it('retains highest predicate arity', function() { var fn = R.cond([ [R.nAry(2, R.T), R.T], [R.nAry(3, R.T), R.T], [R.nAry(1, R.T), R.T] ]); eq(fn.length, 3); }); });

    ---------------

    converge

    
    converge(after: ((...a: any[]) => any), fns: Array<((...x: any[]) => any)>): (...y: any[]) => any
    

    Accepts a converging function and a list of branching functions and returns a new function. When invoked, this new function is applied to some arguments, each branching function is applied to those same arguments. The results of each branching function are passed as arguments to the converging function to produce the return value.

    :boom: Explanation is taken from Ramda documentation

    const result = R.converge(R.multiply)([ R.add(1), R.add(3) ])(2)
    // => 15
    

    Try this R.converge example in Rambda REPL

    All Typescript definitions typescript converge(after: ((...a: any[]) => any), fns: Array<((...x: any[]) => any)>): (...y: any[]) => any;
    R.converge source javascript import { curryN } from './curryN' import { map } from './map' import { max } from './max' import { reduce } from './reduce' export function converge(fn, transformers){ if (arguments.length === 1) return _transformers => converge(fn, _transformers) const highestArity = reduce( (a, b) => max(a, b.length), 0, transformers ) return curryN(highestArity, function (){ return fn.apply(this, map(g => g.apply(this, arguments), transformers)) }) }
    Tests javascript import { add } from './add' import { converge } from './converge' import { multiply } from './multiply' const f1 = converge(multiply, [ a => a + 1, a => a + 10 ]) const f2 = converge(multiply, [ a => a + 1, (a, b) => a + b + 10 ]) const f3 = converge(multiply, [ a => a + 1, ( a, b, c ) => a + b + c + 10 ]) test('happy', () => { expect(f2(6, 7)).toEqual(161) }) test('passes the results of applying the arguments individually', () => { const result = converge(multiply)([ add(1), add(3) ])(2) expect(result).toEqual(15) }) test('returns a function with the length of the longest argument', () => { expect(f1.length).toEqual(1) expect(f2.length).toEqual(2) expect(f3.length).toEqual(3) }) test('passes context to its functions', () => { const a = function (x){ return this.f1(x) } const b = function (x){ return this.f2(x) } const c = function (x, y){ return this.f3(x, y) } const d = converge(c, [ a, b ]) const context = { f1 : add(1), f2 : add(2), f3 : add, } expect(a.call(context, 1)).toEqual(2) expect(b.call(context, 1)).toEqual(3) expect(d.call(context, 1)).toEqual(5) }) test('works with empty functions list', () => { const fn = converge(function (){ return arguments.length }, []) expect(fn.length).toEqual(0) expect(fn()).toEqual(0) })
    Typescript test typescript import {converge} from 'ramda' const mult = (a: number, b: number) => { return a * b } const fn = converge(mult, [ (a: number) => { return a }, (a: number, b: number) => { return b }, ]) describe('R.converge', () => { it('happy', () => { const result = fn(2, 3) const curriedResult = fn(2)(3) result // $ExpectType any curriedResult // $ExpectType any }) })

    ---------------

    curry

    
    curry(fn: (...args: any[]) => any): (...a: any[]) => any
    

    It expects a function as input and returns its curried version.

    const fn = (a, b, c) => a + b + c
    const curried = R.curry(fn)
    const sum = curried(1,2)
    
    const result = sum(3) // => 6
    

    Try this R.curry example in Rambda REPL

    All Typescript definitions typescript curry(fn: (...args: any[]) => any): (...a: any[]) => any;
    R.curry source javascript export function curry(fn, args = []){ return (..._args) => (rest => rest.length >= fn.length ? fn(...rest) : curry(fn, rest))([ ...args, ..._args, ]) }
    Tests javascript import { curry } from './curry' test('happy', () => { const addFourNumbers = ( a, b, c, d ) => a + b + c + d const curriedAddFourNumbers = curry(addFourNumbers) const f = curriedAddFourNumbers(1, 2) const g = f(3) expect(g(4)).toEqual(10) }) test('when called with more arguments', () => { const add = curry((n, n2) => n + n2) expect(add( 1, 2, 3 )).toEqual(3) }) test('when called with zero arguments', () => { const sub = curry((a, b) => a - b) const s0 = sub() expect(s0(5, 2)).toEqual(3) }) test('when called via multiple curry stages', () => { const join = curry(( a, b, c, d ) => [ a, b, c, d ].join('-')) const stage1 = join('A') const stage2 = stage1('B', 'C') expect(stage2('D')).toEqual('A-B-C-D') })
    Typescript test typescript import {curry} from 'rambda' function source(a: number, b: number, c: number, d: number) { void d return a * b * c } describe('R.curry', () => { it('happy', () => { const curried = curry(source) const result1 = curried(1)(2)(3) const result2 = curried(1, 2)(3) const result3 = curried(1)(2, 3) const result4 = curried(1, 2, 3) result1 // $ExpectType any result2 // $ExpectType any result3 // $ExpectType any result4 // $ExpectType any }) })
    3 failed Ramda.curry specs > :boom: Reason for the failure: Ramda library support placeholder(R.) ```javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); var jsv = require('jsverify'); var funcN = require('./shared/funcN'); describe('curry', function() { it('properly reports the length of the curried function', function() { var f = R.curry(function(a, b, c, d) {return (a + b c) / d;}); eq(f.length, 4); var g = f(12); eq(g.length, 3); var h = g(3); eq(h.length, 2); eq(g(3, 6).length, 1); }); it('preserves context', function() { var ctx = {x: 10}; var f = function(a, b) { return a + b this.x; }; var g = R.curry(f); eq(g.call(ctx, 2, 4), 42); eq(g.call(ctx, 2).call(ctx, 4), 42); }); it('supports R. placeholder', function() { var f = function(a, b, c) { return [a, b, c]; }; var g = R.curry(f); var = R.__; eq(g(1)(2)(3), [1, 2, 3]); eq(g(1)(2, 3), [1, 2, 3]); eq(g(1, 2)(3), [1, 2, 3]); eq(g(1, 2, 3), [1, 2, 3]); eq(g(, 2, 3)(1), [1, 2, 3]); eq(g(1, , 3)(2), [1, 2, 3]); eq(g(1, 2, )(3), [1, 2, 3]); eq(g(1, , )(2)(3), [1, 2, 3]); eq(g(, 2, )(1)(3), [1, 2, 3]); eq(g(, , 3)(1)(2), [1, 2, 3]); eq(g(1, , )(2, 3), [1, 2, 3]); eq(g(, 2, )(1, 3), [1, 2, 3]); eq(g(, , 3)(1, 2), [1, 2, 3]); eq(g(1, , )(, 3)(2), [1, 2, 3]); eq(g(, 2, )(, 3)(1), [1, 2, 3]); eq(g(, , 3)(, 2)(1), [1, 2, 3]); eq(g(, , )(, )()(1, 2, 3), [1, 2, 3]); eq(g(, , )(1, , )(, )(2, )()(3), [1, 2, 3]); }); it('supports @@functional/placeholder', function() { var f = function(a, b, c) { return [a, b, c]; }; var g = R.curry(f); var = {'@@functional/placeholder': true, x: Math.random()}; eq(g(1)(2)(3), [1, 2, 3]); eq(g(1)(2, 3), [1, 2, 3]); eq(g(1, 2)(3), [1, 2, 3]); eq(g(1, 2, 3), [1, 2, 3]); eq(g(, 2, 3)(1), [1, 2, 3]); eq(g(1, , 3)(2), [1, 2, 3]); eq(g(1, 2, )(3), [1, 2, 3]); eq(g(1, , )(2)(3), [1, 2, 3]); eq(g(, 2, )(1)(3), [1, 2, 3]); eq(g(, , 3)(1)(2), [1, 2, 3]); eq(g(1, , )(2, 3), [1, 2, 3]); eq(g(, 2, )(1, 3), [1, 2, 3]); eq(g(, , 3)(1, 2), [1, 2, 3]); eq(g(1, , )(, 3)(2), [1, 2, 3]); eq(g(, 2, )(, 3)(1), [1, 2, 3]); eq(g(, , 3)(, 2)(1), [1, 2, 3]); eq(g(, , )(, )()(1, 2, 3), [1, 2, 3]); eq(g(, , )(1, , )(, )(2, )()(3), [1, 2, 3]); }); }); describe('curry properties', function() { jsv.property('curries multiple values', funcN(4), jsv.json, jsv.json, jsv.json, jsv.json, function(f, a, b, c, d) { var g = R.curry(f); return R.all(R.equals(f(a, b, c, d)), [ g(a, b, c, d), g(a)(b)(c)(d), g(a)(b, c, d), g(a, b)(c, d), g(a, b, c)(d) ]); jsv.property('curries with placeholder', funcN(3), jsv.json, jsv.json, jsv.json, function(f, a, b, c) { var = {'@@functional/placeholder': true, x: Math.random()}; var g = R.curry(f); return R.all(R.equals(f(a, b, c)), [ g(, , c)(a, b), g(a, , c)(b), g(, b, c)(a), g(a, , )(, c)(b), g(a, b, _)(c) ]); }); ```

    ---------------

    curryN

    
    curryN(length: number, fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any
    

    It returns a curried equivalent of the provided function, with the specified arity.

    All Typescript definitions typescript curryN(length: number, fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any;
    R.curryN source javascript function _curryN( n, cache, fn ){ return function (){ let ci = 0 let ai = 0 const cl = cache.length const al = arguments.length const args = new Array(cl + al) while (ci < cl){ args[ ci ] = cache[ ci ] ci++ } while (ai < al){ args[ cl + ai ] = arguments[ ai ] ai++ } const remaining = n - args.length return args.length >= n ? fn.apply(this, args) : _arity(remaining, _curryN( n, args, fn )) } } function _arity(n, fn){ switch (n){ case 0: return function (){ return fn.apply(this, arguments) } case 1: return function (_1){ return fn.apply(this, arguments) } case 2: return function (_1, _2){ return fn.apply(this, arguments) } case 3: return function ( _1, _2, _3 ){ return fn.apply(this, arguments) } case 4: return function ( _1, _2, _3, _4 ){ return fn.apply(this, arguments) } case 5: return function ( _1, _2, _3, _4, _5 ){ return fn.apply(this, arguments) } case 6: return function ( _1, _2, _3, _4, _5, _6 ){ return fn.apply(this, arguments) } case 7: return function ( _1, _2, _3, _4, _5, _6, _7 ){ return fn.apply(this, arguments) } case 8: return function ( _1, _2, _3, _4, _5, _6, _7, _8 ){ return fn.apply(this, arguments) } case 9: return function ( _1, _2, _3, _4, _5, _6, _7, _8, _9 ){ return fn.apply(this, arguments) } case 10: return function ( _1, _2, _3, _4, _5, _6, _7, _8, _9, _10 ){ return fn.apply(this, arguments) } default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten') } } export function curryN(n, fn){ if (arguments.length === 1) return _fn => curryN(n, _fn) return _arity(n, _curryN( n, [], fn )) }
    Tests javascript import { curryN } from './curryN' function source( a, b, c, d ){ void d return a * b * c } test('accepts an arity', () => { const curried = curryN(3, source) expect(curried(1)(2)(3)).toEqual(6) expect(curried(1, 2)(3)).toEqual(6) expect(curried(1)(2, 3)).toEqual(6) expect(curried( 1, 2, 3 )).toEqual(6) }) test('can be partially applied', () => { const curry3 = curryN(3) const curried = curry3(source) expect(curried.length).toEqual(3) expect(curried(1)(2)(3)).toEqual(6) expect(curried(1, 2)(3)).toEqual(6) expect(curried(1)(2, 3)).toEqual(6) expect(curried( 1, 2, 3 )).toEqual(6) }) test('preserves context', () => { const ctx = { x : 10 } const f = function (a, b){ return a + b * this.x } const g = curryN(2, f) expect(g.call( ctx, 2, 4 )).toEqual(42) expect(g.call(ctx, 2).call(ctx, 4)).toEqual(42) }) test('forwards extra arguments', () => { const f = function (){ return Array.prototype.slice.call(arguments) } const g = curryN(3, f) expect(g( 1, 2, 3 )).toEqual([ 1, 2, 3 ]) expect(g( 1, 2, 3, 4 )).toEqual([ 1, 2, 3, 4 ]) expect(g(1, 2)(3, 4)).toEqual([ 1, 2, 3, 4 ]) expect(g(1)( 2, 3, 4 )).toEqual([ 1, 2, 3, 4 ]) expect(g(1)(2)(3, 4)).toEqual([ 1, 2, 3, 4 ]) })
    Typescript test typescript import {curryN} from 'ramda' function source(a: number, b: number, c: number, d: number) { void d return a * b * c } describe('R.curryN', () => { it('happy', () => { const curried = curryN(3, source) const result1 = curried(1)(2)(3) const result2 = curried(1, 2)(3) const result3 = curried(1)(2, 3) const result4 = curried(1, 2, 3) result1 // $ExpectType any result2 // $ExpectType any result3 // $ExpectType any result4 // $ExpectType any }) })

    ---------------

    dec

    
    dec(x: number): number
    

    It decrements a number.

    All Typescript definitions typescript dec(x: number): number;
    R.dec source javascript export const dec = x => x - 1
    Tests javascript import { dec } from './dec' test('happy', () => { expect(dec(2)).toBe(1) })

    ---------------

    defaultTo

    
    defaultTo<T>(defaultValue: T): (...inputArguments: (T | null | undefined)[]) => T
    

    It returns defaultValue, if all of inputArguments are undefined, null or NaN.

    Else, it returns the first truthy inputArguments instance(from left to right).

    :boom: Rambda's defaultTo accept indefinite number of arguments when non curried, i.e. R.defaultTo(2, foo, bar, baz).

    // With single input argument
    R.defaultTo('foo', 'bar') // => 'bar'
    R.defaultTo('foo', undefined) // => 'foo'
    
    // With multiple input arguments
    R.defaultTo('foo', undefined, null, NaN) // => 'foo'
    R.defaultTo('foo', undefined, 'bar', NaN, 'qux') // => 'bar'
    R.defaultTo('foo', undefined, null, NaN, 'quz') // => 'qux'
    

    Try this R.defaultTo example in Rambda REPL

    All Typescript definitions typescript defaultTo<T>(defaultValue: T): (...inputArguments: (T | null | undefined)[]) => T; defaultTo<T>(defaultValue: T, ...inputArguments: (T | null | undefined)[]): T; defaultTo<T, U>(defaultValue: T | U, ...inputArguments: (T | U | null | undefined)[]): T | U;
    R.defaultTo source javascript function flagIs(inputArguments){ return ( inputArguments === undefined || inputArguments === null || Number.isNaN(inputArguments) === true ) } export function defaultTo(defaultArgument, ...inputArguments){ if (arguments.length === 1){ return (..._inputArguments) => defaultTo(defaultArgument, ..._inputArguments) } const limit = inputArguments.length - 1 let len = limit + 1 let ready = false let holder while (!ready){ const instance = inputArguments[ limit - len + 1 ] if (len === 0){ ready = true } else if (flagIs(instance)){ len -= 1 } else { holder = instance ready = true } } return holder === undefined ? defaultArgument : holder }
    Tests javascript import { defaultTo } from './defaultTo' test('with undefined', () => { expect(defaultTo('foo')(undefined)).toEqual('foo') }) test('with null', () => { expect(defaultTo('foo')(null)).toEqual('foo') }) test('with NaN', () => { expect(defaultTo('foo')(NaN)).toEqual('foo') }) test('with empty string', () => { expect(defaultTo('foo', '')).toEqual('') }) test('with false', () => { expect(defaultTo('foo', false)).toEqual(false) }) test('when inputArgument passes initial check', () => { expect(defaultTo('foo', 'bar')).toEqual('bar') }) test('default extends to indefinite input arguments - case 1', () => { const result = defaultTo( 'foo', null, 'bar' ) const expected = 'bar' expect(result).toEqual(expected) }) test('default extends to indefinite input arguments - case 2', () => { const result = defaultTo( 'foo', null, NaN, 'bar' ) const expected = 'bar' expect(result).toEqual(expected) }) test('default extends to indefinite input arguments - case 3', () => { const result = defaultTo( 'foo', null, NaN, undefined ) const expected = 'foo' expect(result).toEqual(expected) }) test('default extends to indefinite input arguments - case 4', () => { const result = defaultTo( 'foo', null, NaN, undefined, 'bar' ) const expected = 'bar' expect(result).toEqual(expected) }) test('default extends to indefinite input arguments - case 5', () => { const result = defaultTo( 'foo', null, NaN, 'bar', 'baz' ) const expected = 'bar' expect(result).toEqual(expected) }) test('default extends to indefinite input arguments - case 6', () => { const result = defaultTo( 'foo', null, NaN, undefined, null, NaN ) const expected = 'foo' expect(result).toEqual(expected) })
    Typescript test typescript import {defaultTo} from 'rambda' describe('R.defaultTo with Ramda spec', () => { it('input is falsy', () => { const result = defaultTo('foo', undefined) result // $ExpectType "foo" }) it('input is truthy', () => { const result = defaultTo('foo', 'bar') result // $ExpectType "foo" | "bar" }) }) describe('R.defaultTo can have many inputs', () => { it('happy', () => { const result = defaultTo('foo', undefined, 'bar') result // $ExpectType "foo" | "bar" }) it('curried', () => { const result = defaultTo('foo')(undefined, 'bar') result // $ExpectType string }) it('with two possible types', () => { const result = defaultTo<string, number>( 'foo', undefined, 1, null, 2, 'bar' ) result // $ExpectType string | number }) })

    ---------------

    difference

    
    difference<T>(a: readonly T[], b: readonly T[]): T[]
    

    It returns the uniq set of all elements in the first list a not contained in the second list b.

    const a = [ 1, 2, 3, 4 ]
    const b = [ 3, 4, 5, 6 ]
    
    const result = difference(a, b)
    // => [ 1, 2 ]
    

    Try this R.difference example in Rambda REPL

    All Typescript definitions typescript difference<T>(a: readonly T[], b: readonly T[]): T[]; difference<T>(a: readonly T[]): (b: readonly T[]) => T[];
    R.difference source javascript import { includes } from './includes' import { uniq } from './uniq' export function difference(a, b){ if (arguments.length === 1) return _b => difference(a, _b) return uniq(a).filter(aInstance => !includes(aInstance, b)) }
    Tests javascript import { difference } from './difference' test('difference', () => { const a = [ 1, 2, 3, 4 ] const b = [ 3, 4, 5, 6 ] expect(difference(a)(b)).toEqual([ 1, 2 ]) expect(difference([], [])).toEqual([]) }) test('difference with objects', () => { const a = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ] const b = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ] expect(difference(a, b)).toEqual([ { id : 1 }, { id : 2 } ]) }) test('no duplicates in first list', () => { const M2 = [ 1, 2, 3, 4, 1, 2, 3, 4 ] const N2 = [ 3, 3, 4, 4, 5, 5, 6, 6 ] expect(difference(M2, N2)).toEqual([ 1, 2 ]) }) test('should use R.equals', () => { expect(difference([ NaN ], [ NaN ]).length).toEqual(0) })
    Typescript test typescript import {difference} from 'rambda' const list1 = [1, 2, 3] const list2 = [1, 2, 4] describe('R.difference', () => { it('happy', () => { const result = difference(list1, list2) result // $ExpectType number[] }) it('curried', () => { const result = difference(list1)(list2) result // $ExpectType number[] }) })

    ---------------

    dissoc

    
    dissoc<T>(prop: string, obj: any): T
    

    It returns a new object that does not contain property prop.

    R.dissoc('b', {a: 1, b: 2, c: 3})
    //=> {a: 1, c: 3}
    

    Try this R.dissoc example in Rambda REPL

    All Typescript definitions typescript dissoc<T>(prop: string, obj: any): T; dissoc<T>(prop: string): (obj: any) => T;
    R.dissoc source javascript export function dissoc(prop, obj){ if (arguments.length === 1) return _obj => dissoc(prop, _obj) if (obj === null || obj === undefined) return {} const willReturn = {} for (const p in obj){ willReturn[ p ] = obj[ p ] } delete willReturn[ prop ] return willReturn }
    Tests javascript import { dissoc } from './dissoc' test('input is null or undefined', () => { expect(dissoc('b', null)).toEqual({}) expect(dissoc('b', undefined)).toEqual({}) }) test('property exists curried', () => { expect(dissoc('b')({ a : 1, b : 2, })).toEqual({ a : 1 }) }) test('property doesn\'t exists', () => { expect(dissoc('c', { a : 1, b : 2, })).toEqual({ a : 1, b : 2, }) }) test('works with non-string property', () => { expect(dissoc(42, { a : 1, 42 : 2, })).toEqual({ a : 1 }) expect(dissoc(null, { a : 1, null : 2, })).toEqual({ a : 1 }) expect(dissoc(undefined, { a : 1, undefined : 2, })).toEqual({ a : 1 }) }) test('includes prototype properties', () => { function Rectangle(width, height){ this.width = width this.height = height } const area = Rectangle.prototype.area = function (){ return this.width * this.height } const rect = new Rectangle(7, 6) expect(dissoc('area', rect)).toEqual({ width : 7, height : 6, }) expect(dissoc('width', rect)).toEqual({ height : 6, area : area, }) expect(dissoc('depth', rect)).toEqual({ width : 7, height : 6, area : area, }) })
    Typescript test typescript import {dissoc, pipe, identity} from 'rambda' const obj = { a: 1, b: 2, } interface Output { a: string, } describe('R.dissoc', () => { it('happy', () => { const result = dissoc<Output>('b', obj) result // $ExpectType Output }) it('curried', () => { const result = dissoc<Output>('b')(obj) result // $ExpectType Output }) it('within R.pipe', () => { const result = pipe<object, object, Output>(identity, dissoc('b'))(obj) result // $ExpectType Output }) })

    ---------------

    divide

    
    divide(x: number, y: number): number
    
    R.divide(71, 100) // => 0.71
    

    Try this R.divide example in Rambda REPL

    All Typescript definitions typescript divide(x: number, y: number): number; divide(x: number): (y: number) => number;
    R.divide source javascript export function divide(a, b){ if (arguments.length === 1) return _b => divide(a, _b) return a / b }
    Tests javascript import { divide } from './divide' test('happy', () => { expect(divide(71, 100)).toEqual(0.71) expect(divide(71)(100)).toEqual(0.71) })

    ---------------

    drop

    
    drop<T>(howMany: number, input: readonly T[]): T[]
    

    It returns howMany items dropped from beginning of list or string input.

    R.drop(2, ['foo', 'bar', 'baz']) // => ['baz']
    R.drop(2, 'foobar')  // => 'obar'
    

    Try this R.drop example in Rambda REPL

    All Typescript definitions typescript drop<T>(howMany: number, input: readonly T[]): T[]; drop(howMany: number, input: string): string; drop<T>(howMany: number): { <T>(input: readonly T[]): T[]; (input: string): string; };
    R.drop source javascript export function drop(howManyToDrop, listOrString){ if (arguments.length === 1) return _list => drop(howManyToDrop, _list) return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0) }
    Tests javascript import assert from 'assert' import { drop } from './drop' test('with array', () => { expect(drop(2)([ 'foo', 'bar', 'baz' ])).toEqual([ 'baz' ]) expect(drop(3, [ 'foo', 'bar', 'baz' ])).toEqual([]) expect(drop(4, [ 'foo', 'bar', 'baz' ])).toEqual([]) }) test('with string', () => { expect(drop(3, 'rambda')).toEqual('bda') }) test('with non-positive count', () => { expect(drop(0, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ]) expect(drop(-1, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ]) expect(drop(-Infinity, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ]) }) test('should return copy', () => { const xs = [ 1, 2, 3 ] assert.notStrictEqual(drop(0, xs), xs) assert.notStrictEqual(drop(-1, xs), xs) })
    Typescript test typescript import {drop} from 'rambda' const list = [1, 2, 3, 4] const str = 'foobar' const howMany = 2 describe('R.drop - array', () => { it('happy', () => { const result = drop(howMany, list) result // $ExpectType number[] }) it('curried', () => { const result = drop(howMany)(list) result // $ExpectType number[] }) }) describe('R.drop - string', () => { it('happy', () => { const result = drop(howMany, str) result // $ExpectType string }) it('curried', () => { const result = drop(howMany)(str) result // $ExpectType string }) })

    ---------------

    dropLast

    
    dropLast<T>(howMany: number, input: readonly T[]): T[]
    

    It returns howMany items dropped from the end of list or string input.

    R.dropLast(2, ['foo', 'bar', 'baz']) // => ['foo']
    R.dropLast(2, 'foobar')  // => 'foob'
    

    Try this R.dropLast example in Rambda REPL

    All Typescript definitions typescript dropLast<T>(howMany: number, input: readonly T[]): T[]; dropLast(howMany: number, input: string): string; dropLast<T>(howMany: number): { <T>(input: readonly T[]): T[]; (input: string): string; };
    R.dropLast source javascript export function dropLast(howManyToDrop, listOrString){ if (arguments.length === 1){ return _listOrString => dropLast(howManyToDrop, _listOrString) } return howManyToDrop > 0 ? listOrString.slice(0, -howManyToDrop) : listOrString.slice() }
    Tests javascript import assert from 'assert' import { dropLast } from './dropLast' test('with array', () => { expect(dropLast(2)([ 'foo', 'bar', 'baz' ])).toEqual([ 'foo' ]) expect(dropLast(3, [ 'foo', 'bar', 'baz' ])).toEqual([]) expect(dropLast(4, [ 'foo', 'bar', 'baz' ])).toEqual([]) }) test('with string', () => { expect(dropLast(3, 'rambda')).toEqual('ram') }) test('with non-positive count', () => { expect(dropLast(0, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ]) expect(dropLast(-1, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ]) expect(dropLast(-Infinity, [ 1, 2, 3 ])).toEqual([ 1, 2, 3 ]) }) test('should return copy', () => { const xs = [ 1, 2, 3 ] assert.notStrictEqual(dropLast(0, xs), xs) assert.notStrictEqual(dropLast(-1, xs), xs) })
    Typescript test typescript import {dropLast} from 'rambda' const list = [1, 2, 3, 4] const str = 'foobar' const howMany = 2 describe('R.dropLast - array', () => { it('happy', () => { const result = dropLast(howMany, list) result // $ExpectType number[] }) it('curried', () => { const result = dropLast(howMany)(list) result // $ExpectType number[] }) }) describe('R.dropLast - string', () => { it('happy', () => { const result = dropLast(howMany, str) result // $ExpectType string }) it('curried', () => { const result = dropLast(howMany)(str) result // $ExpectType string }) })
    5 failed Ramda.dropLast specs > :boom: Reason for the failure: Ramda method can act as a transducer javascript var assert = require('assert'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('dropLast', function() { it('can act as a transducer', function() { var dropLast2 = R.dropLast(2); assert.deepEqual(R.into([], dropLast2, [1, 3, 5, 7, 9, 1, 2]), [1, 3, 5, 7, 9]); assert.deepEqual(R.into([], dropLast2, [1]), []); }); });

    ---------------

    dropLastWhile

    
    dropLastWhile(predicate: (x: string) => boolean, iterable: string): string
    
    const list = [1, 2, 3, 4, 5];
    const predicate = x => x >= 3
    
    const result = dropLastWhile(predicate, list);
    // => [1, 2]
    

    Try this R.dropLastWhile example in Rambda REPL

    All Typescript definitions typescript dropLastWhile(predicate: (x: string) => boolean, iterable: string): string; dropLastWhile(predicate: (x: string) => boolean): (iterable: string) => string; dropLastWhile<T>(predicate: (x: T) => boolean, iterable: readonly T[]): T[]; dropLastWhile<T>(predicate: (x: T) => boolean): <T>(iterable: readonly T[]) => T[];
    R.dropLastWhile source javascript import { _isArray } from './_internals/_isArray.js' export function dropLastWhile(predicate, iterable){ if (arguments.length === 1){ return _iterable => dropLastWhile(predicate, _iterable) } if (iterable.length === 0) return iterable const isArray = _isArray(iterable) if (typeof predicate !== 'function'){ throw new Error(`'predicate' is from wrong type ${ typeof predicate }`) } if (!isArray && typeof iterable !== 'string'){ throw new Error(`'iterable' is from wrong type ${ typeof iterable }`) } let found = false const toReturn = [] let counter = iterable.length while (counter > 0){ counter-- if (!found && predicate(iterable[ counter ]) === false){ found = true toReturn.push(iterable[ counter ]) } else if (found){ toReturn.push(iterable[ counter ]) } } return isArray ? toReturn.reverse() : toReturn.reverse().join('') }
    Tests javascript import { dropLastWhile as dropLastWhileRamda } from "ramda"; import { compareCombinations } from "./_internals/testUtils"; import { dropLastWhile } from "./dropLastWhile"; const list = [1, 2, 3, 4, 5]; const str = "foobar"; test("with list", () => { const result = dropLastWhile((x) => x >= 3, list); expect(result).toEqual([1, 2]); }); test("with string", () => { const result = dropLastWhile((x) => x !== "b")(str); expect(result).toBe("foob"); }); test("with empty list", () => { expect(dropLastWhile(() => true, [])).toEqual([]); expect(dropLastWhile(() => false, [])).toEqual([]); }); const possiblePredicates = [ (x) => x > 2, (x) => x < 2, (x) => x < -2, (x) => x > 10, "", [], [1], ]; const possibleIterables = [ list, [{}, "1", 2], str, `${str}${str}`, /foo/g, Promise.resolve("foo"), 2, ]; describe("brute force", () => { compareCombinations({ fn: dropLastWhile, fnRamda: dropLastWhileRamda, firstInput: possiblePredicates, secondInput: possibleIterables, callback: (errorsCounters) => { expect(errorsCounters).toMatchInlineSnapshot(` Object { "ERRORS_MESSAGE_MISMATCH": 0, "ERRORS_TYPE_MISMATCH": 12, "RESULTS_MISMATCH": 0, "SHOULD_NOT_THROW": 21, "SHOULD_THROW": 0, } `); }, }); });
    Typescript test typescript import {dropLastWhile} from 'rambda' const list = [1, 2, 3] const str = 'FOO' describe('R.dropLastWhile', () => { it('with array', () => { const result = dropLastWhile(x => x > 1, list) result // $ExpectType number[] }) it('with array - curried', () => { const result = dropLastWhile(x => x > 1, list) result // $ExpectType number[] }) it('with string', () => { const result = dropLastWhile(x => x !== 'F', str) result // $ExpectType string }) it('with string - curried', () => { const result = dropLastWhile(x => x !== 'F')(str) result // $ExpectType string }) })

    1 failed Ramda.dropLastWhile specs

    :boom: Reason for the failure: Ramda method can act as a transducer

    ---------------

    dropRepeats

    
    dropRepeats<T>(list: readonly T[]): T[]
    

    It removes any successive duplicates according to R.equals.

    const result = R.dropRepeats([
      1, 
      1, 
      {a: 1}, 
      {a:1}, 
      1
    ])
    // => [1, {a: 1}, 1]
    

    Try this R.dropRepeats example in Rambda REPL

    All Typescript definitions typescript dropRepeats<T>(list: readonly T[]): T[];
    R.dropRepeats source javascript import { _isArray } from './_internals/_isArray' import { equals } from './equals' export function dropRepeats(list){ if (!_isArray(list)){ throw new Error(`${ list } is not a list`) } const toReturn = [] list.reduce((prev, current) => { if (!equals(prev, current)){ toReturn.push(current) } return current }, undefined) return toReturn }
    Tests javascript import { dropRepeats as dropRepeatsRamda } from "ramda"; import { compareCombinations } from "./_internals/testUtils"; import { add } from "./add"; import { dropRepeats } from "./dropRepeats"; const list = [1, 2, 2, 2, 3, 4, 4, 5, 5, 3, 2, 2, { a: 1 }, { a: 1 }]; const listClean = [1, 2, 3, 4, 5, 3, 2, { a: 1 }]; test("happy", () => { const result = dropRepeats(list); expect(result).toEqual(listClean); }); const possibleLists = [ [add(1), async () => {}, [1], [1], [2], [2]], [add(1), add(1), add(2)], [], 1, /foo/g, Promise.resolve(1), ]; describe("brute force", () => { compareCombinations({ firstInput: possibleLists, callback: (errorsCounters) => { expect(errorsCounters).toMatchInlineSnapshot(` Object { "ERRORS_MESSAGE_MISMATCH": 0, "ERRORS_TYPE_MISMATCH": 0, "RESULTS_MISMATCH": 0, "SHOULD_NOT_THROW": 3, "SHOULD_THROW": 0, } `); }, fn: dropRepeats, fnRamda: dropRepeatsRamda, }); });
    Typescript test typescript import {dropRepeats} from 'rambda' describe('R.dropRepeats', () => { it('happy', () => { const result = dropRepeats([1, 2, 2, 3]) result // $ExpectType number[] }) })

    1 failed Ramda.dropRepeats specs

    :boom: Reason for the failure: Ramda method can act as a transducer

    ---------------

    dropRepeatsWith

    
    dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean, list: readonly T[]): T[]
    
    const list = [{a:1,b:2}, {a:1,b:3}, {a:2, b:4}]
    const result = R.dropRepeatsWith(R.prop('a'))
    
    // => [{a:1,b:2}, {a:2, b:4}]
    

    Try this R.dropRepeatsWith example in Rambda REPL

    All Typescript definitions typescript dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean, list: readonly T[]): T[]; dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean): (list: readonly T[]) => T[];
    R.dropRepeatsWith source javascript import { _isArray } from './_internals/_isArray' export function dropRepeatsWith(predicate, list){ if (arguments.length === 1){ return _iterable => dropRepeatsWith(predicate, _iterable) } if (!_isArray(list)){ throw new Error(`${ list } is not a list`) } const toReturn = [] list.reduce((prev, current) => { if (prev === undefined){ toReturn.push(current) return current } if (!predicate(prev, current)){ toReturn.push(current) } return current }, undefined) return toReturn }
    Tests javascript import { dropRepeatsWith as dropRepeatsWithRamda, eqProps } from "ramda"; import { compareCombinations } from "./_internals/testUtils"; import { dropRepeatsWith } from "./dropRepeatsWith"; import { path } from "./path"; const eqI = eqProps("i"); test("happy", () => { const list = [{ i: 1 }, { i: 2 }, { i: 2 }, { i: 3 }]; const expected = [{ i: 1 }, { i: 2 }, { i: 3 }]; const result = dropRepeatsWith(eqI, list); expect(result).toEqual(expected); }); test("keeps elements from the left predicate input", () => { const list = [ { i: 1, n: 1, }, { i: 1, n: 2, }, { i: 1, n: 3, }, { i: 4, n: 1, }, { i: 4, n: 2, }, ]; const expected = [ { i: 1, n: 1, }, { i: 4, n: 1, }, ]; const result = dropRepeatsWith(eqI, list); expect(result).toEqual(expected); }); const possiblePredicates = [ null, undefined, (x) => x + 1, (x) => true, (x) => false, (x) => "", path(["a", "b"]), ]; const possibleLists = [ null, undefined, [], [1], [{ a: { b: 1 } }, { a: { b: 1 } }], [/foo/g, /foo/g], ]; describe("brute force", () => { compareCombinations({ firstInput: possiblePredicates, secondInput: possibleLists, callback: (errorsCounters) => { expect(errorsCounters).toMatchInlineSnapshot(` Object { "ERRORS_MESSAGE_MISMATCH": 4, "ERRORS_TYPE_MISMATCH": 14, "RESULTS_MISMATCH": 0, "SHOULD_NOT_THROW": 0, "SHOULD_THROW": 0, } `); }, fn: dropRepeatsWith, fnRamda: dropRepeatsWithRamda, }); });
    Typescript test typescript import {dropRepeatsWith} from 'rambda' interface Foo { a: number, } describe('R.dropRepeatsWith', () => { it('happy', () => { const result = dropRepeatsWith( (x: Foo, y: Foo) => { return x.a > y.a }, [{a: 2}, {a: 1}] ) result // $ExpectType { a: number; }[] result[0].a // $ExpectType number }) it('curried', () => { const result = dropRepeatsWith((x: Foo, y: Foo) => { return x.a > y.a })([{a: 2}, {a: 1}]) result // $ExpectType Foo[] }) })

    ---------------

    dropWhile

    
    dropWhile(fn: Predicate<string>, iterable: string): string
    
    const list = [1, 2, 3, 4]
    const predicate = x => x < 3
    const result = R.dropWhile(predicate, list)
    // => [3, 4]
    

    Try this R.dropWhile example in Rambda REPL

    All Typescript definitions typescript dropWhile(fn: Predicate<string>, iterable: string): string; dropWhile(fn: Predicate<string>): (iterable: string) => string; dropWhile<T>(fn: Predicate<T>, iterable: readonly T[]): T[]; dropWhile<T>(fn: Predicate<T>): (iterable: readonly T[]) => T[];
    R.dropWhile source javascript import { _isArray } from '../src/_internals/_isArray' export function dropWhile(predicate, iterable){ if (arguments.length === 1){ return _iterable => dropWhile(predicate, _iterable) } const isArray = _isArray(iterable) if (!isArray && typeof iterable !== 'string'){ throw new Error('`iterable` is neither list nor a string') } let flag = false const holder = [] let counter = -1 while (counter++ < iterable.length - 1){ if (flag){ holder.push(iterable[ counter ]) } else if (!predicate(iterable[ counter ])){ if (!flag) flag = true holder.push(iterable[ counter ]) } } return isArray ? holder : holder.join('') }
    Tests javascript import { dropWhile as dropWhileRamda } from 'ramda' import { compareCombinations } from './_internals/testUtils' import { dropWhile } from './dropWhile' const list = [ 1, 2, 3, 4 ] test('happy', () => { const predicate = x => x < 3 const result = dropWhile(predicate, list) expect(result).toEqual([3,4]) }) test('always true', () => { const predicate = () => true const result = dropWhileRamda(predicate, list) expect(result).toEqual([]) }) test('always false', () => { const predicate = () => 0 const result = dropWhile(predicate, list) expect(result).toEqual(list) }) test('works with string as iterable', () => { const iterable = 'foobar' const predicate = x => x !== 'b' const result = dropWhile(predicate, iterable) expect(result).toBe('bar') }) const possiblePredicates = [ null, undefined, () => 0, () => true, /foo/g, {}, [], ] const possibleIterables = [ null, undefined, [], {}, 1, '', 'foobar', [ '' ], [ 1, 2, 3, 4, 5 ], ] describe('brute force', () => { compareCombinations({ firstInput : possiblePredicates, callback : errorsCounters => { expect(errorsCounters).toMatchInlineSnapshot(` Object { "ERRORS_MESSAGE_MISMATCH": 15, "ERRORS_TYPE_MISMATCH": 14, "RESULTS_MISMATCH": 0, "SHOULD_NOT_THROW": 14, "SHOULD_THROW": 0, } `) }, secondInput : possibleIterables, fn : dropWhile, fnRamda : dropWhileRamda, }) })
    Typescript test typescript import {dropWhile} from 'rambda' const list = [1, 2, 3, 4] describe('R.dropWhile', () => { it('happy', () => { const result = dropWhile(x => x > 2, list) result // $ExpectType number[] }) it('curried require explicit type', () => { const result = dropWhile<number>(x => x > 2)(list) result // $ExpectType number[] }) }) describe('with string as iterable', () => { const str = 'foobar' it('happy', () => { const result = dropWhile(x => x !== 'b', str) result // $ExpectType string }) it('curried require explicit type', () => { const result = dropWhile(x => x !== 'b')(str) result // $ExpectType string }) })

    ---------------

    either

    
    either(firstPredicate: Pred, secondPredicate: Pred): Pred
    

    It returns a new predicate function from firstPredicate and secondPredicate inputs.

    This predicate function will return true, if any of the two input predicates return true.

    const firstPredicate = x => x > 10
    const secondPredicate = x => x % 2 === 0
    const predicate = R.either(firstPredicate, secondPredicate)
    
    const result = [
      predicate(15),
      predicate(8),
      predicate(7),
    ]
    //=> [true, true, false]
    

    Try this R.either example in Rambda REPL

    All Typescript definitions typescript either(firstPredicate: Pred, secondPredicate: Pred): Pred; either<T>(firstPredicate: Predicate<T>, secondPredicate: Predicate<T>): Predicate<T>; either<T>(firstPredicate: Predicate<T>): (secondPredicate: Predicate<T>) => Predicate<T>; either(firstPredicate: Pred): (secondPredicate: Pred) => Pred;
    R.either source javascript export function either(firstPredicate, secondPredicate){ if (arguments.length === 1){ return _secondPredicate => either(firstPredicate, _secondPredicate) } return (...input) => Boolean(firstPredicate(...input) || secondPredicate(...input)) }
    Tests javascript import { either } from './either' test('with multiple inputs', () => { const between = function ( a, b, c ){ return a < b && b < c } const total20 = function ( a, b, c ){ return a + b + c === 20 } const fn = either(between, total20) expect(fn( 7, 8, 5 )).toBeTrue() }) test('skip evaluation of the second expression', () => { let effect = 'not evaluated' const F = function (){ return true } const Z = function (){ effect = 'Z got evaluated' } either(F, Z)() expect(effect).toBe('not evaluated') }) test('case 1', () => { const firstFn = val => val > 0 const secondFn = val => val * 5 > 10 expect(either(firstFn, secondFn)(1)).toBeTrue() }) test('case 2', () => { const firstFn = val => val > 0 const secondFn = val => val === -10 const fn = either(firstFn)(secondFn) expect(fn(-10)).toBeTrue() })
    Typescript test typescript import {either} from 'rambda' describe('R.either', () => { it('with passed type', () => { const fn = either<number>( x => x > 1, x => x % 2 === 0 ) fn // $ExpectType Predicate<number> const result = fn(2) // $ExpectType boolean result // $ExpectType boolean }) it('with passed type - curried', () => { const fn = either<number>(x => x > 1)(x => x % 2 === 0) fn // $ExpectType Predicate<number> const result = fn(2) result // $ExpectType boolean }) it('no type passed', () => { const fn = either( x => { x // $ExpectType any return x > 1 }, x => { x // $ExpectType any return x % 2 === 0 } ) const result = fn(2) result // $ExpectType boolean }) it('no type passed - curried', () => { const fn = either((x: number) => { x // $ExpectType number return x > 1 })((x: number) => { x // $ExpectType number return x % 2 === 0 }) const result = fn(2) result // $ExpectType boolean }) })
    1 failed Ramda.either specs > :boom: Reason for the failure: Ramda library supports fantasy-land javascript var S = require('sanctuary'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('either', function() { it('accepts fantasy-land applicative functors', function() { var Just = S.Just; var Nothing = S.Nothing; eq(R.either(Just(true), Just(true)), Just(true)); eq(R.either(Just(true), Just(false)), Just(true)); eq(R.either(Just(false), Just(false)), Just(false)); eq(R.either(Just(true), Nothing()), Nothing()); eq(R.either(Nothing(), Just(false)), Nothing()); eq(R.either(Nothing(), Nothing()), Nothing()); }); });

    ---------------

    endsWith

    
    endsWith(target: string, str: string): boolean
    

    Curried version of String.prototype.endsWith

    :boom: It doesn't work with arrays unlike its corresponding Ramda method.

    const str = 'foo-bar'
    const target = '-bar'
    
    const result = R.endsWith(target, str)
    // => true
    

    Try this R.endsWith example in Rambda REPL

    All Typescript definitions typescript endsWith(target: string, str: string): boolean; endsWith(target: string): (str: string) => boolean;
    R.endsWith source javascript export function endsWith(target, str){ if (arguments.length === 1) return _str => endsWith(target, _str) return str.endsWith(target) }
    Tests javascript import { endsWith } from './endsWith' test('happy', () => { expect(endsWith('bar', 'foo-bar')).toBeTrue() expect(endsWith('baz')('foo-bar')).toBeFalse() }) test('does not work with arrays', () => { expect(() => endsWith([ 'c' ], [ 'a', 'b', 'c' ])).toThrowWithMessage(Error, 'str.endsWith is not a function') })
    Typescript test typescript import {endsWith} from 'rambda' const target = 'foo' const input = 'foo bar' describe('R.endsWith', () => { it('happy', () => { const result = endsWith(target, input) result // $ExpectType boolean }) it('curried', () => { const result = endsWith(target)(input) result // $ExpectType boolean }) })
    4 failed Ramda.endsWith specs > :boom: Reason for the failure: Rambda method doesn't support arrays javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('startsWith', function() { it('should return true when an array ends with the provided value', function() { eq(R.endsWith(['c'], ['a', 'b', 'c']), true); }); it('should return true when an array ends with the provided values', function() { eq(R.endsWith(['b', 'c'], ['a', 'b', 'c']), true); }); it('should return false when an array does not end with the provided value', function() { eq(R.endsWith(['b'], ['a', 'b', 'c']), false); }); it('should return false when an array does not end with the provided values', function() { eq(R.endsWith(['a', 'b'], ['a', 'b', 'c']), false); }); });

    ---------------

    eqProps

    
    eqProps<T, U>(prop: string, obj1: T, obj2: U): boolean
    

    It returns true if property prop in obj1 is equal to property prop in obj2 according to R.equals.

    const obj1 = {a: 1, b:2}
    const obj2 = {a: 1, b:3}
    const result = R.eqProps('a', obj1, obj2)
    // => true
    

    Try this R.eqProps example in Rambda REPL

    All Typescript definitions typescript eqProps<T, U>(prop: string, obj1: T, obj2: U): boolean; eqProps<P extends string>(prop: P): <T, U>(obj1: Record<P, T>, obj2: Record<P, U>) => boolean; eqProps<T>(prop: string, obj1: T): <U>(obj2: U) => boolean;
    R.eqProps source javascript import { curry } from "./curry"; import { equals } from "./equals"; function eqPropsFn(prop, obj1, obj2) { if(!obj1 || !obj2){ throw new Error('wrong object inputs are passed to R.eqProps') } return equals(obj1[prop], obj2[prop]) } export const eqProps = curry(eqPropsFn)
    Tests javascript import { eqProps as eqPropsRamda } from 'ramda' import { compareCombinations } from './_internals/testUtils' import { eqProps } from './eqProps' const obj1 = { a : 1, b : 2, } const obj2 = { a : 1, b : 3, } test('props are equal', () => { const result = eqProps( 'a', obj1, obj2 ) expect(result).toBeTrue() }) test('props are not equal', () => { const result = eqProps( 'b', obj1, obj2 ) expect(result).toBeFalse() }) test('prop does not exist ', () => { const result = eqProps( 'c', obj1, obj2 ) expect(result).toBeTrue() }) const possibleProps = [ 'a', 'a.b', null, false, 0, 1, {}, [] ] const possibleObjects = [ { a : 1 }, { a : 1, b : 2, }, {}, [], null, { a : { b : 1 }, c : 2, }, { a : { b : 1 }, c : 3, }, { a : { b : 2 } }, ] describe('brute force', () => { let totalTestsCounter = 0 compareCombinations({ firstInput : possibleProps, setCounter : () => totalTestsCounter++, callback : errorsCounters => { // console.log({ totalTestsCounter }) expect(errorsCounters).toMatchInlineSnapshot(` Object { "ERRORS_MESSAGE_MISMATCH": 0, "ERRORS_TYPE_MISMATCH": 120, "RESULTS_MISMATCH": 0, "SHOULD_NOT_THROW": 0, "SHOULD_THROW": 0, } `) }, secondInput : possibleObjects, thirdInput : possibleObjects, fn : eqProps, fnRamda : eqPropsRamda, }) })
    Typescript test typescript import {eqProps} from 'rambda' const obj1 = {a: {b: 1}, c: 2} const obj2 = {a: {b: 1}, c: 3} describe('R.eqProps', () => { it('happy', () => { const result = eqProps('a', obj1, obj2) result // $ExpectType boolean }) it('curried', () => { const result = eqProps('a', obj1)(obj2) result // $ExpectType boolean }) })

    ---------------

    equals

    
    equals<T>(x: T, y: T): boolean
    

    It deeply compares x and y and returns true if they are equal.

    :boom: It doesn't handle cyclical data structures and functions

    R.equals(
      [1, {a:2}, [{b: 3}]],
      [1, {a:2}, [{b: 3}]]
    ) // => true
    

    Try this R.equals example in Rambda REPL

    All Typescript definitions typescript equals<T>(x: T, y: T): boolean; equals<T>(x: T): (y: T) => boolean;
    R.equals source javascript import { type } from './type' function parseError(maybeError){ const typeofError = maybeError.__proto__.toString() if (![ 'Error', 'TypeError' ].includes(typeofError)) return [] return [ typeofError, maybeError.message ] } function parseDate(maybeDate){ if (!maybeDate.toDateString) return [ false ] return [ true, maybeDate.getTime() ] } function parseRegex(maybeRegex){ if (maybeRegex.constructor !== RegExp) return [ false ] return [ true, maybeRegex.toString() ] } export function equals(a, b){ if (arguments.length === 1) return _b => equals(a, _b) const aType = type(a) if (aType !== type(b)) return false if ([ 'NaN', 'Undefined', 'Null' ].includes(aType)) return true if (aType === 'Number'){ if (Object.is(-0, a) !== Object.is(-0, b)) return false return a.toString() === b.toString() } if ([ 'String', 'Boolean' ].includes(aType)){ return a.toString() === b.toString() } if (aType === 'Array'){ const aClone = Array.from(a) const bClone = Array.from(b) if (aClone.toString() !== bClone.toString()){ return false } let loopArrayFlag = true aClone.forEach((aCloneInstance, aCloneIndex) => { if (loopArrayFlag){ if ( aCloneInstance !== bClone[ aCloneIndex ] && !equals(aCloneInstance, bClone[ aCloneIndex ]) ){ loopArrayFlag = false } } }) return loopArrayFlag } const aRegex = parseRegex(a) const bRegex = parseRegex(b) if (aRegex[ 0 ]){ return bRegex[ 0 ] ? aRegex[ 1 ] === bRegex[ 1 ] : false } else if (bRegex[ 0 ]) return false const aDate = parseDate(a) const bDate = parseDate(b) if (aDate[ 0 ]){ return bDate[ 0 ] ? aDate[ 1 ] === bDate[ 1 ] : false } else if (bDate[ 0 ]) return false const aError = parseError(a) const bError = parseError(b) if (aError[ 0 ]){ return bError[ 0 ] ? aError[ 0 ] === bError[ 0 ] && aError[ 1 ] === bError[ 1 ] : false } if (aType === 'Object'){ const aKeys = Object.keys(a) if (aKeys.length !== Object.keys(b).length){ return false } let loopObjectFlag = true aKeys.forEach(aKeyInstance => { if (loopObjectFlag){ const aValue = a[ aKeyInstance ] const bValue = b[ aKeyInstance ] if (aValue !== bValue && !equals(aValue, bValue)){ loopObjectFlag = false } } }) return loopObjectFlag } return false }
    Tests javascript // import { equals } from 'ramda' import { equals } from './equals' test('with array of objects', () => { const list1 = [ { a : 1 }, [ { b : 2 } ] ] const list2 = [ { a : 1 }, [ { b : 2 } ] ] const list3 = [ { a : 1 }, [ { b : 3 } ] ] expect(equals(list1, list2)).toBeTrue() expect(equals(list1, list3)).toBeFalse() }) test('with regex', () => { expect(equals(/s/, /s/)).toEqual(true) expect(equals(/s/, /d/)).toEqual(false) expect(equals(/a/gi, /a/gi)).toEqual(true) expect(equals(/a/gim, /a/gim)).toEqual(true) expect(equals(/a/gi, /a/i)).toEqual(false) }) test('not a number', () => { expect(equals([ NaN ], [ NaN ])).toBeTrue() }) test('new number', () => { expect(equals(new Number(0), new Number(0))).toEqual(true) expect(equals(new Number(0), new Number(1))).toEqual(false) expect(equals(new Number(1), new Number(0))).toEqual(false) }) test('new string', () => { expect(equals(new String(''), new String(''))).toEqual(true) expect(equals(new String(''), new String('x'))).toEqual(false) expect(equals(new String('x'), new String(''))).toEqual(false) expect(equals(new String('foo'), new String('foo'))).toEqual(true) expect(equals(new String('foo'), new String('bar'))).toEqual(false) expect(equals(new String('bar'), new String('foo'))).toEqual(false) }) test('new Boolean', () => { expect(equals(new Boolean(true), new Boolean(true))).toEqual(true) expect(equals(new Boolean(false), new Boolean(false))).toEqual(true) expect(equals(new Boolean(true), new Boolean(false))).toEqual(false) expect(equals(new Boolean(false), new Boolean(true))).toEqual(false) }) test('new Error', () => { expect(equals(new Error('XXX'), {})).toEqual(false) expect(equals(new Error('XXX'), new TypeError('XXX'))).toEqual(false) expect(equals(new Error('XXX'), new Error('YYY'))).toEqual(false) expect(equals(new Error('XXX'), new Error('XXX'))).toEqual(true) expect(equals(new Error('XXX'), new TypeError('YYY'))).toEqual(false) }) test('with dates', () => { expect(equals(new Date(0), new Date(0))).toEqual(true) expect(equals(new Date(1), new Date(1))).toEqual(true) expect(equals(new Date(0), new Date(1))).toEqual(false) expect(equals(new Date(1), new Date(0))).toEqual(false) expect(equals(new Date(0), {})).toEqual(false) expect(equals({}, new Date(0))).toEqual(false) }) test('ramda spec', () => { expect(equals({}, {})).toEqual(true) expect(equals({ a : 1, b : 2, }, { a : 1, b : 2, })).toEqual(true) expect(equals({ a : 2, b : 3, }, { b : 3, a : 2, })).toEqual(true) expect(equals({ a : 2, b : 3, }, { a : 3, b : 3, })).toEqual(false) expect(equals({ a : 2, b : 3, c : 1, }, { a : 2, b : 3, })).toEqual(false) }) test('works with boolean tuple', () => { expect(equals([ true, false ], [ true, false ])).toBeTrue() expect(equals([ true, false ], [ true, true ])).toBeFalse() }) test('works with equal objects within array', () => { const objFirst = { a : { b : 1, c : 2, d : [ 1 ], }, } const objSecond = { a : { b : 1, c : 2, d : [ 1 ], }, } const x = [ 1, 2, objFirst, null, '', [] ] const y = [ 1, 2, objSecond, null, '', [] ] expect(equals(x, y)).toBeTrue() }) test('works with different objects within array', () => { const objFirst = { a : { b : 1 } } const objSecond = { a : { b : 2 } } const x = [ 1, 2, objFirst, null, '', [] ] const y = [ 1, 2, objSecond, null, '', [] ] expect(equals(x, y)).toBeFalse() }) test('works with undefined as second argument', () => { expect(equals(1, undefined)).toBeFalse() expect(equals(undefined, undefined)).toBeTrue() }) test('various examples', () => { expect(equals([ 1, 2, 3 ])([ 1, 2, 3 ])).toBeTrue() expect(equals([ 1, 2, 3 ], [ 1, 2 ])).toBeFalse() expect(equals(1, 1)).toBeTrue() expect(equals(1, '1')).toBeFalse() expect(equals({}, {})).toBeTrue() expect(equals({ a : 1, b : 2, }, { b : 2, a : 1, })).toBeTrue() expect(equals({ a : 1, b : 2, }, { a : 1, b : 1, })).toBeFalse() expect(equals({ a : 1, b : false, }, { a : 1, b : 1, })).toBeFalse() expect(equals({ a : 1, b : 2, }, { b : 2, a : 1, c : 3, })).toBeFalse() expect(equals({ x : { a : 1, b : 2, }, }, { x : { b : 2, a : 1, c : 3, }, })).toBeFalse() expect(equals({ a : 1, b : 2, }, { b : 3, a : 1, })).toBeFalse() expect(equals({ a : { b : { c : 1 } } }, { a : { b : { c : 1 } } })).toBeTrue() expect(equals({ a : { b : { c : 1 } } }, { a : { b : { c : 2 } } })).toBeFalse() expect(equals({ a : {} }, { a : {} })).toBeTrue() expect(equals('', '')).toBeTrue() expect(equals('foo', 'foo')).toBeTrue() expect(equals('foo', 'bar')).toBeFalse() expect(equals(0, false)).toBeFalse() expect(equals(/\s/g, null)).toBeFalse() expect(equals(null, null)).toBeTrue() expect(equals(false)(null)).toBeFalse() }) test('with custom functions', () => { function foo(){ return 1 } foo.prototype.toString = () => '' const result = equals(foo, foo) expect(result).toBeFalse() }) test('with classes', () => { class Foo{} const foo = new Foo() const result = equals(foo, foo) expect(result).toBeTrue() }) test('with negative zero', () => { expect(equals(-0, -0)).toBeTrue() expect(equals(-0, 0)).toBeFalse() expect(equals(0, 0)).toBeTrue() expect(equals(-0, 1)).toBeFalse() })
    Typescript test typescript import {equals} from 'rambda' describe('R.equals', () => { it('happy', () => { const result = equals(4, 1) result // $ExpectType boolean }) it('with object', () => { const foo = {a: 1} const bar = {a: 2} const result = equals(foo, bar) result // $ExpectType boolean }) it('curried', () => { const result = equals(4)(1) result // $ExpectType boolean }) })
    14 failed Ramda.equals specs > :boom: Reason for the failure: Rambda method doesn't support recursive data structures, objects with same enumerable properties, map/weakmap type of variables | Ramda dispatches to equals method recursively | Rambda method doesn't support equality of functions javascript /* global Map, Set, WeakMap, WeakSet */ var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('equals', function() { var a = []; var b = a; it('never considers Boolean primitive equal to Boolean object', function() { eq(R.equals(true, new Boolean(true)), false); eq(R.equals(new Boolean(true), true), false); eq(R.equals(false, new Boolean(false)), false); eq(R.equals(new Boolean(false), false), false); }); it('never considers number primitive equal to Number object', function() { eq(R.equals(0, new Number(0)), false); eq(R.equals(new Number(0), 0), false); }); it('never considers string primitive equal to String object', function() { eq(R.equals('', new String('')), false); eq(R.equals(new String(''), ''), false); eq(R.equals('x', new String('x')), false); eq(R.equals(new String('x'), 'x'), false); }); var supportsSticky = false; try { RegExp('', 'y'); supportsSticky = true; } catch (e) {} var supportsUnicode = false; try { RegExp('', 'u'); supportsUnicode = true; } catch (e) {} var listA = [1, 2, 3]; var listB = [1, 3, 2]; var c = {}; c.v = c; var d = {}; d.v = d; var e = []; e.push(e); var f = []; f.push(f); var nestA = {a:[1, 2, {c:1}], b:1}; var nestB = {a:[1, 2, {c:1}], b:1}; var nestC = {a:[1, 2, {c:2}], b:1}; it('handles recursive data structures', function() { eq(R.equals(c, d), true); eq(R.equals(e, f), true); eq(R.equals(nestA, nestB), true); eq(R.equals(nestA, nestC), false); }); it('requires that both objects have the same enumerable properties with the same values', function() { var a1 = []; var a2 = []; a2.x = 0; var b1 = new Boolean(false); var b2 = new Boolean(false); b2.x = 0; var d1 = new Date(0); var d2 = new Date(0); d2.x = 0; var n1 = new Number(0); var n2 = new Number(0); n2.x = 0; var r1 = /(?:)/; var r2 = /(?:)/; r2.x = 0; var s1 = new String(''); var s2 = new String(''); s2.x = 0; eq(R.equals(a1, a2), false); eq(R.equals(b1, b2), false); eq(R.equals(d1, d2), false); eq(R.equals(n1, n2), false); eq(R.equals(r1, r2), false); eq(R.equals(s1, s2), false); }); if (typeof ArrayBuffer !== 'undefined' && typeof Int8Array !== 'undefined') { var typArr1 = new ArrayBuffer(10); typArr1[0] = 1; var typArr2 = new ArrayBuffer(10); typArr2[0] = 1; var typArr3 = new ArrayBuffer(10); var intTypArr = new Int8Array(typArr1); typArr3[0] = 0; it('handles typed arrays', function() { eq(R.equals(typArr1, typArr2), true); eq(R.equals(typArr1, typArr3), false); eq(R.equals(typArr1, intTypArr), false); }); } if (typeof Promise !== 'undefined') { it('compares Promise objects by identity', function() { var p = Promise.resolve(42); var q = Promise.resolve(42); eq(R.equals(p, p), true); eq(R.equals(p, q), false); }); } if (typeof Map !== 'undefined') { it('compares Map objects by value', function() { eq(R.equals(new Map([]), new Map([])), true); eq(R.equals(new Map([]), new Map([[1, 'a']])), false); eq(R.equals(new Map([[1, 'a']]), new Map([])), false); eq(R.equals(new Map([[1, 'a']]), new Map([[1, 'a']])), true); eq(R.equals(new Map([[1, 'a'], [2, 'b']]), new Map([[2, 'b'], [1, 'a']])), true); eq(R.equals(new Map([[1, 'a']]), new Map([[2, 'a']])), false); eq(R.equals(new Map([[1, 'a']]), new Map([[1, 'b']])), false); eq(R.equals(new Map([[1, 'a'], [2, new Map([[3, 'c']])]]), new Map([[1, 'a'], [2, new Map([[3, 'c']])]])), true); eq(R.equals(new Map([[1, 'a'], [2, new Map([[3, 'c']])]]), new Map([[1, 'a'], [2, new Map([[3, 'd']])]])), false); eq(R.equals(new Map([[[1, 2, 3], [4, 5, 6]]]), new Map([[[1, 2, 3], [4, 5, 6]]])), true); eq(R.equals(new Map([[[1, 2, 3], [4, 5, 6]]]), new Map([[[1, 2, 3], [7, 8, 9]]])), false); }); it('dispatches to `equals` method recursively in Set', function() { var a = new Map(); var b = new Map(); a.set(a, a); eq(R.equals(a, b), false); a.set(b, b); b.set(b, b); b.set(a, a); eq(R.equals(a, b), true); }); } if (typeof Set !== 'undefined') { it('compares Set objects by value', function() { eq(R.equals(new Set([]), new Set([])), true); eq(R.equals(new Set([]), new Set([1])), false); eq(R.equals(new Set([1]), new Set([])), false); eq(R.equals(new Set([1, 2]), new Set([2, 1])), true); eq(R.equals(new Set([1, new Set([2, new Set([3])])]), new Set([1, new Set([2, new Set([3])])])), true); eq(R.equals(new Set([1, new Set([2, new Set([3])])]), new Set([1, new Set([2, new Set([4])])])), false); eq(R.equals(new Set([[1, 2, 3], [4, 5, 6]]), new Set([[1, 2, 3], [4, 5, 6]])), true); eq(R.equals(new Set([[1, 2, 3], [4, 5, 6]]), new Set([[1, 2, 3], [7, 8, 9]])), false); }); it('dispatches to `equals` method recursively in Set', function() { var a = new Set(); var b = new Set(); a.add(a); eq(R.equals(a, b), false); a.add(b); b.add(b); b.add(a); eq(R.equals(a, b), true); }); } if (typeof WeakMap !== 'undefined') { it('compares WeakMap objects by identity', function() { var m = new WeakMap([]); eq(R.equals(m, m), true); eq(R.equals(m, new WeakMap([])), false); }); } if (typeof WeakSet !== 'undefined') { it('compares WeakSet objects by identity', function() { var s = new WeakSet([]); eq(R.equals(s, s), true); eq(R.equals(s, new WeakSet([])), false); }); } it('dispatches to `equals` method recursively', function() { function Left(x) { this.value = x; } Left.prototype.equals = function(x) { return x instanceof Left && R.equals(x.value, this.value); }; function Right(x) { this.value = x; } Right.prototype.equals = function(x) { return x instanceof Right && R.equals(x.value, this.value); }; eq(R.equals(new Left([42]), new Left([42])), true); eq(R.equals(new Left([42]), new Left([43])), false); eq(R.equals(new Left(42), {value: 42}), false); eq(R.equals({value: 42}, new Left(42)), false); eq(R.equals(new Left(42), new Right(42)), false); eq(R.equals(new Right(42), new Left(42)), false); eq(R.equals([new Left(42)], [new Left(42)]), true); eq(R.equals([new Left(42)], [new Right(42)]), false); eq(R.equals([new Right(42)], [new Left(42)]), false); eq(R.equals([new Right(42)], [new Right(42)]), true); }); });

    ---------------

    evolve

    
    evolve<T, U>(rules: Array<(x: T) => U>, list: T[]): U[]
    

    It takes object or array of functions as set of rules. These rules are applied to the iterable input to produce the result.

    :boom: Error handling of this method differs between Ramda and Rambda. Ramda for some wrong inputs returns result and for other - it returns one of the inputs. Rambda simply throws when inputs are not correct. Full details for this mismatch are listed in source/_snapshots/evolve.spec.js.snap file.

    const rules = {
      foo : add(1),
      bar : add(-1),
    }
    const input = {
      a   : 1,
      foo : 2,
      bar : 3,
    }
    const result = evolve(rules, input)
    const expected = {
      a   : 1,
      foo : 3,
      bar : 2,
    })
    // => `result` is equal to `expected`
    

    Try this R.evolve example in Rambda REPL

    All Typescript definitions typescript evolve<T, U>(rules: Array<(x: T) => U>, list: T[]): U[]; evolve<T, U>(rules: Array<(x: T) => U>) : (list: T[]) => U[]; evolve<E extends Evolver, V extends Evolvable<E>>(rules: E, obj: V): Evolve<V, E>; evolve<E extends Evolver>(rules: E): <V extends Evolvable<E>>(obj: V) => Evolve<V, E>;
    R.evolve source javascript import { _isArray } from './_internals/_isArray' import { mapArray, mapObject } from './map' import { type } from './type' export function evolveArray(rules, list){ return mapArray( (x, i) => { if (type(rules[ i ]) === 'Function'){ return rules[ i ](x) } return x }, list, true ) } export function evolveObject(rules, iterable){ return mapObject((x, prop) => { if (type(x) === 'Object'){ const typeRule = type(rules[ prop ]) if (typeRule === 'Function'){ return rules[ prop ](x) } if (typeRule === 'Object'){ return evolve(rules[ prop ], x) } return x } if (type(rules[ prop ]) === 'Function'){ return rules[ prop ](x) } return x }, iterable) } export function evolve(rules, iterable){ if (arguments.length === 1){ return _iterable => evolve(rules, _iterable) } const rulesType = type(rules) const iterableType = type(iterable) if (iterableType !== rulesType){ throw new Error('iterableType !== rulesType') } if (![ 'Object', 'Array' ].includes(rulesType)){ throw new Error(`'iterable' and 'rules' are from wrong type ${ rulesType }`) } if (iterableType === 'Object'){ return evolveObject(rules, iterable) } return evolveArray(rules, iterable) }
    Tests javascript import { evolve as evolveRamda } from "ramda"; import { add } from "../rambda.js"; import { compareCombinations, compareToRamda } from "./_internals/testUtils"; import { evolve } from "./evolve"; test("happy", () => { const rules = { foo: add(1), bar: add(-1), }; const input = { a: 1, foo: 2, bar: 3, }; const result = evolve(rules, input); expect(result).toEqual({ a: 1, foo: 3, bar: 2, }); }); test("is recursive", () => { const rules = { nested: { second: add(-1), third: add(1), }, }; const object = { first: 1, nested: { second: 2, third: 3, }, }; const expected = { first: 1, nested: { second: 1, third: 4, }, }; const result = evolve(rules, object); expect(result).toEqual(expected); }); test("ignores primitive value rulesormations", () => { const rules = { n: 2, m: "foo", }; const object = { n: 0, m: 1, }; const expected = { n: 0, m: 1, }; const result = evolve(rules, object); expect(result).toEqual(expected); }); test("with array", () => { const rules = [add(1), add(-1)]; const list = [100, 1400]; const expected = [101, 1399]; const result = evolve(rules, list); expect(result).toEqual(expected); }); const rulesObject = { a: add(1) }; const rulesList = [add(1)]; const possibleIterables = [null, undefined, "", 42, [], [1], { a: 1 }]; const possibleRules = [...possibleIterables, rulesList, rulesObject]; describe("brute force", () => { compareCombinations({ firstInput: possibleRules, callback: (errorsCounters) => { expect(errorsCounters).toMatchInlineSnapshot(` Object { "ERRORS_MESSAGE_MISMATCH": 0, "ERRORS_TYPE_MISMATCH": 4, "RESULTS_MISMATCH": 0, "SHOULD_NOT_THROW": 51, "SHOULD_THROW": 0, } `); }, secondInput: possibleIterables, fn: evolve, fnRamda: evolveRamda, }); });
    Typescript test typescript import {evolve, add} from 'rambda' describe('R.evolve', () => { it('happy', () => { const input = { foo: 2, nested: { a: 1, bar: 3, }, } const rules = { foo: add(1), nested: { a: add(-1), bar: add(1), }, } const result = evolve(rules, input) const curriedResult = evolve(rules)(input) result.nested.a // $ExpectType number curriedResult.nested.a // $ExpectType number result.nested.bar // $ExpectType number result.foo // $ExpectType number }) it('with array', () => { const rules = [String, String] const input = [100, 1400] const result = evolve(rules, input) const curriedResult = evolve(rules)(input) result // $ExpectType string[] curriedResult // $ExpectType string[] }) })

    1 failed Ramda.evolve specs

    :boom: Reason for the failure: Rambda throws if iterable input is neither array nor object

    ---------------

    F

    
    F(): boolean
    
    F() // => false
    

    Try this R.F example in Rambda REPL

    All Typescript definitions typescript F(): boolean;
    R.F source javascript export function F(){ return false }

    ---------------

    filter

    
    filter<T>(predicate: FilterFunctionArray<T>): (input: readonly T[]) => T[]
    

    It filters list or object input using a predicate function.

    const list = [3, 4, 3, 2]
    const listPredicate = x => x > 2
    
    const object = {abc: 'fo', xyz: 'bar', baz: 'foo'}
    const objectPredicate = (x, prop) => x.length + prop.length > 5
    
    const result = [
      R.filter(listPredicate, list),
      R.filter(objectPredicate, object)
    ]
    // => [ [3, 4], { xyz: 'bar', baz: 'foo'} ]
    

    Try this R.filter example in Rambda REPL

    All Typescript definitions typescript filter<T>(predicate: FilterFunctionArray<T>): (input: readonly T[]) => T[]; filter<T>(predicate: FilterFunctionArray<T>, input: readonly T[]): T[]; filter<T, U>(predicate: FilterFunctionObject<T>): (x: Dictionary<T>) => Dictionary<T>; filter<T>(predicate: FilterFunctionObject<T>, x: Dictionary<T>): Dictionary<T>;
    R.filter source javascript import { _isArray } from './_internals/_isArray' export function filterObject(fn, obj){ const willReturn = {} for (const prop in obj){ if (fn( obj[ prop ], prop, obj )){ willReturn[ prop ] = obj[ prop ] } } return willReturn } export function filterArray( predicate, list, indexed = false ){ let index = 0 const len = list.length const willReturn = [] while (index < len){ const predicateResult = indexed ? predicate(list[ index ], index) : predicate(list[ index ]) if (predicateResult){ willReturn.push(list[ index ]) } index++ } return willReturn } export function filter(predicate, iterable){ if (arguments.length === 1){ return _iterable => filter(predicate, _iterable) } if (!iterable) return [] if (_isArray(iterable)) return filterArray(predicate, iterable) return filterObject(predicate, iterable) }
    Tests javascript import Ramda from 'ramda' import { F } from './F' import { filter } from './filter' import { T } from './T' const sampleObject = { a : 1, b : 2, c : 3, d : 4, } test('happy', () => { const isEven = n => n % 2 === 0 expect(filter(isEven, [ 1, 2, 3, 4 ])).toEqual([ 2, 4 ]) expect(filter(isEven, { a : 1, b : 2, d : 3, })).toEqual({ b : 2 }) }) test('bad inputs difference between Ramda and Rambda', () => { expect(filter(T)(undefined)).toEqual([]) expect(filter(F, null)).toEqual([]) expect(() => Ramda.filter(T, null)).toThrowWithMessage(TypeError, 'Cannot read property \'filter\' of null') expect(() => Ramda.filter(T, undefined)).toThrowWithMessage(TypeError, 'Cannot read property \'filter\' of undefined') }) test('predicate when input is object', () => { const obj = { a : 1, b : 2, } const predicate = ( val, prop, inputObject ) => { expect(inputObject).toEqual(obj) expect(typeof prop).toEqual('string') return val < 2 } expect(filter(predicate, obj)).toEqual({ a : 1 }) }) test('with object', () => { const isEven = n => n % 2 === 0 const result = filter(isEven, sampleObject) const expectedResult = { b : 2, d : 4, } expect(result).toEqual(expectedResult) })
    Typescript test typescript import {filter} from 'rambda' const list = [1, 2, 3] const obj = {a: 1, b: 2} describe('R.filter with array', () => { it('happy', () => { const result = filter<number>(x => { x // $ExpectType number return x > 1 }, list) result // $ExpectType number[] }) it('curried', () => { const result = filter<number>(x => { x // $ExpectType number return x > 1 })(list) result // $ExpectType number[] }) }) describe('R.filter with objects', () => { it('happy', () => { const result = filter<number>((val, prop, origin) => { val // $ExpectType number prop // $ExpectType string origin // $ExpectType Dictionary<number> return val > 1 }, obj) result // $ExpectType Dictionary<number> }) it('curried version requires second dummy type', () => { const result = filter<number, any>((val, prop, origin) => { val // $ExpectType number prop // $ExpectType string origin // $ExpectType Dictionary<number> return val > 1 })(obj) result // $ExpectType Dictionary<number> }) })
    1 failed Ramda.filter specs > :boom: Reason for the failure: Ramda method dispatches to filter method of object javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); var Maybe = require('./shared/Maybe'); describe('filter', function() { var even = function(x) {return x % 2 === 0;}; it('dispatches to passed-in non-Array object with a `filter` method', function() { var f = {filter: function(f) { return f('called f.filter'); }}; eq(R.filter(function(s) { return s; }, f), 'called f.filter'); }); it('correctly uses fantasy-land implementations', function() { var m1 = Maybe.Just(-1); var m2 = R.filter(function(x) { return x > 0; } , m1); eq(m2.isNothing, true); }); });

    ---------------

    find

    
    find<T>(predicate: (x: T) => boolean, list: readonly T[]): T | undefined
    

    It returns the first element of list that satisfy the predicate.

    If there is no such element, it returns undefined.

    const predicate = x => R.type(x.foo) === 'Number'
    const list = [{foo: 'bar'}, {foo: 1}]
    
    const result = R.find(predicate, list)
    // => {foo: 1}
    

    Try this R.find example in Rambda REPL

    All Typescript definitions typescript find<T>(predicate: (x: T) => boolean, list: readonly T[]): T | undefined; find<T>(predicate: (x: T) => boolean): (list: readonly T[]) => T | undefined;
    R.find source javascript export function find(predicate, list){ if (arguments.length === 1) return _list => find(predicate, _list) let index = 0 const len = list.length while (index < len){ const x = list[ index ] if (predicate(x)){ return x } index++ } }
    Tests javascript import { find } from './find' import { propEq } from './propEq' const list = [ { a : 1 }, { a : 2 }, { a : 3 } ] test('happy', () => { const fn = propEq('a', 2) expect(find(fn, list)).toEqual({ a : 2 }) }) test('with curry', () => { const fn = propEq('a', 4) expect(find(fn)(list)).toBeUndefined() }) test('with empty list', () => { expect(find(() => true, [])).toBeUndefined() })
    Typescript test typescript import {find} from 'rambda' const list = [1, 2, 3] describe('R.find', () => { it('happy', () => { const predicate = (x: number) => x > 2 const result = find(predicate, list) result // $ExpectType number | undefined }) it('curried', () => { const predicate = (x: number) => x > 2 const result = find(predicate)(list) result // $ExpectType number | undefined }) })

    ---------------

    findIndex

    
    findIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number
    

    It returns the index of the first element of list satisfying the predicate function.

    If there is no such element, then -1 is returned.

    const predicate = x => R.type(x.foo) === 'Number'
    const list = [{foo: 'bar'}, {foo: 1}]
    
    const result = R.findIndex(predicate, list)
    // => 1
    

    Try this R.findIndex example in Rambda REPL

    All Typescript definitions typescript findIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number; findIndex<T>(predicate: (x: T) => boolean): (list: readonly T[]) => number;
    R.findIndex source javascript export function findIndex(predicate, list){ if (arguments.length === 1) return _list => findIndex(predicate, _list) const len = list.length let index = -1 while (++index < len){ if (predicate(list[ index ])){ return index } } return -1 }
    Tests javascript import { findIndex } from './findIndex' import { propEq } from './propEq' const list = [ { a : 1 }, { a : 2 }, { a : 3 } ] test('happy', () => { expect(findIndex(propEq('a', 2), list)).toEqual(1) expect(findIndex(propEq('a', 1))(list)).toEqual(0) expect(findIndex(propEq('a', 4))(list)).toEqual(-1) })
    Typescript test typescript import {findIndex} from 'rambda' const list = [1, 2, 3] describe('R.findIndex', () => { it('happy', () => { const predicate = (x: number) => x > 2 const result = findIndex(predicate, list) result // $ExpectType number }) it('curried', () => { const predicate = (x: number) => x > 2 const result = findIndex(predicate)(list) result // $ExpectType number }) })

    ---------------

    findLast

    
    findLast<T>(fn: (x: T) => boolean, list: readonly T[]): T | undefined
    

    It returns the last element of list satisfying the predicate function.

    If there is no such element, then undefined is returned.

    const predicate = x => R.type(x.foo) === 'Number'
    const list = [{foo: 0}, {foo: 1}]
    
    const result = R.findLast(predicate, list)
    // => {foo: 1}
    

    Try this R.findLast example in Rambda REPL

    All Typescript definitions typescript findLast<T>(fn: (x: T) => boolean, list: readonly T[]): T | undefined; findLast<T>(fn: (x: T) => boolean): (list: readonly T[]) => T | undefined;
    R.findLast source javascript export function findLast(predicate, list){ if (arguments.length === 1) return _list => findLast(predicate, _list) let index = list.length while (--index >= 0){ if (predicate(list[ index ])){ return list[ index ] } } return undefined }
    Tests javascript import { findLast } from './findLast' test('happy', () => { const result = findLast(x => { return x > 1 }, [ 1, 1, 1, 2, 3, 4, 1 ] ) expect(result).toEqual(4) expect(findLast(x => x === 0, [ 0, 1, 1, 2, 3, 4, 1 ])).toEqual(0) }) test('with curry', () => { expect(findLast(x => x > 1)([ 1, 1, 1, 2, 3, 4, 1 ])).toEqual(4) }) const obj1 = { x : 100 } const obj2 = { x : 200 } const a = [ 11, 10, 9, 'cow', obj1, 8, 7, 100, 200, 300, obj2, 4, 3, 2, 1, 0 ] const even = function (x){ return x % 2 === 0 } const gt100 = function (x){ return x > 100 } const isStr = function (x){ return typeof x === 'string' } const xGt100 = function (o){ return o && o.x > 100 } test('ramda 1', () => { expect(findLast(even, a)).toEqual(0) expect(findLast(gt100, a)).toEqual(300) expect(findLast(isStr, a)).toEqual('cow') expect(findLast(xGt100, a)).toEqual(obj2) }) test('ramda 2', () => { expect(findLast(even, [ 'zing' ])).toEqual(undefined) }) test('ramda 3', () => { expect(findLast(even, [ 2, 3, 5 ])).toEqual(2) }) test('ramda 4', () => { expect(findLast(even, [])).toEqual(undefined) })
    Typescript test typescript import {findLast} from 'rambda' const list = [1, 2, 3] describe('R.findLast', () => { it('happy', () => { const predicate = (x: number) => x > 2 const result = findLast(predicate, list) result // $ExpectType number | undefined }) it('curried', () => { const predicate = (x: number) => x > 2 const result = findLast(predicate)(list) result // $ExpectType number | undefined }) })

    ---------------

    findLastIndex

    
    findLastIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number
    

    It returns the index of the last element of list satisfying the predicate function.

    If there is no such element, then -1 is returned.

    const predicate = x => R.type(x.foo) === 'Number'
    const list = [{foo: 0}, {foo: 1}]
    
    const result = R.findLastIndex(predicate, list)
    // => 1
    

    Try this R.findLastIndex example in Rambda REPL

    All Typescript definitions typescript findLastIndex<T>(predicate: (x: T) => boolean, list: readonly T[]): number; findLastIndex<T>(predicate: (x: T) => boolean): (list: readonly T[]) => number;
    R.findLastIndex source javascript export function findLastIndex(fn, list){ if (arguments.length === 1) return _list => findLastIndex(fn, _list) let index = list.length while (--index >= 0){ if (fn(list[ index ])){ return index } } return -1 }
    Tests javascript import { findLastIndex } from './findLastIndex' test('happy', () => { const result = findLastIndex((x) => { return x > 1 }, [ 1, 1, 1, 2, 3, 4, 1 ]) expect(result).toEqual(5) expect(findLastIndex(x => x === 0, [ 0, 1, 1, 2, 3, 4, 1 ])).toEqual(0) }) test('with curry', () => { expect(findLastIndex(x => x > 1)([ 1, 1, 1, 2, 3, 4, 1 ])).toEqual(5) }) const obj1 = { x : 100 } const obj2 = { x : 200 } const a = [ 11, 10, 9, 'cow', obj1, 8, 7, 100, 200, 300, obj2, 4, 3, 2, 1, 0 ] const even = function (x){ return x % 2 === 0 } const gt100 = function (x){ return x > 100 } const isStr = function (x){ return typeof x === 'string' } const xGt100 = function (o){ return o && o.x > 100 } test('ramda 1', () => { expect(findLastIndex(even, a)).toEqual(15) expect(findLastIndex(gt100, a)).toEqual(9) expect(findLastIndex(isStr, a)).toEqual(3) expect(findLastIndex(xGt100, a)).toEqual(10) }) test('ramda 2', () => { expect(findLastIndex(even, [ 'zing' ])).toEqual(-1) }) test('ramda 3', () => { expect(findLastIndex(even, [ 2, 3, 5 ])).toEqual(0) }) test('ramda 4', () => { expect(findLastIndex(even, [])).toEqual(-1) })
    Typescript test typescript import {findLastIndex} from 'rambda' const list = [1, 2, 3] describe('R.findLastIndex', () => { it('happy', () => { const predicate = (x: number) => x > 2 const result = findLastIndex(predicate, list) result // $ExpectType number }) it('curried', () => { const predicate = (x: number) => x > 2 const result = findLastIndex(predicate)(list) result // $ExpectType number }) })

    ---------------

    flatten

    
    flatten<T>(list: readonly any[]): T[]
    

    It deeply flattens an array.

    const result = R.flatten([
      1, 
      2, 
      [3, 30, [300]], 
      [4]
    ])
    // => [ 1, 2, 3, 30, 300, 4 ]
    

    Try this R.flatten example in Rambda REPL

    All Typescript definitions typescript flatten<T>(list: readonly any[]): T[];
    R.flatten source javascript import { _isArray } from './_internals/_isArray' export function flatten(list, input){ const willReturn = input === undefined ? [] : input for (let i = 0; i < list.length; i++){ if (_isArray(list[ i ])){ flatten(list[ i ], willReturn) } else { willReturn.push(list[ i ]) } } return willReturn }
    Tests javascript import { flatten } from './flatten' test('happy', () => { expect(flatten([ 1, 2, 3, [ [ [ [ [ 4 ] ] ] ] ] ])).toEqual([ 1, 2, 3, 4 ]) expect(flatten([ 1, [ 2, [ [ 3 ] ] ], [ 4 ] ])).toEqual([ 1, 2, 3, 4 ]) expect(flatten([ 1, [ 2, [ [ [ 3 ] ] ] ], [ 4 ] ])).toEqual([ 1, 2, 3, 4 ]) expect(flatten([ 1, 2, [ 3, 4 ], 5, [ 6, [ 7, 8, [ 9, [ 10, 11 ], 12 ] ] ] ])).toEqual([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ]) }) test('readme example', () => { const result = flatten([ 1, 2, [ 3, 30, [ 300 ] ], [ 4 ] ]) expect(result).toEqual([ 1, 2, 3, 30, 300, 4 ]) })
    Typescript test typescript import {flatten} from 'rambda' describe('flatten', () => { it('happy', () => { const result = flatten<number>([1, 2, [3, [4]]]) result // $ExpectType number[] }) })

    ---------------

    flip

    
    flip<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult
    

    It returns function which calls fn with exchanged first and second argument.

    :boom: Rambda's flip will throw if the arity of the input function is greater or equal to 5.

    const subtractFlip = R.flip(R.subtract)
    
    const result = [
      subtractFlip(1,7),
      R.flip(1, 6)
    ]  
    // => [6, -6]
    

    Try this R.flip example in Rambda REPL

    All Typescript definitions typescript flip<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult; flip<F extends (...args: any) => any, P extends FunctionToolbelt.Parameters<F>>(fn: F): FunctionToolbelt.Curry<(...args: ListToolbelt.Merge<[P[1], P[0]], P>) => FunctionToolbelt.Return<F>>;
    R.flip source javascript function flipFn(fn){ return (...input) => { if (input.length === 1){ return holder => fn(holder, input[ 0 ]) } else if (input.length === 2){ return fn(input[ 1 ], input[ 0 ]) } else if (input.length === 3){ return fn( input[ 1 ], input[ 0 ], input[ 2 ] ) } else if (input.length === 4){ return fn( input[ 1 ], input[ 0 ], input[ 2 ], input[ 3 ] ) } throw new Error('R.flip doesn\'t work with arity > 4') } } export function flip(fn){ return flipFn(fn) }
    Tests javascript import { flip } from './flip' import { subtract } from './subtract' import { update } from './update' test('function with arity of 2', () => { const subtractFlipped = flip(subtract) expect(subtractFlipped(1)(7)).toEqual(6) expect(subtractFlipped(1, 7)).toEqual(6) expect(subtractFlipped( 1, 7, 9 )).toEqual(6) }) test('function with arity of 3', () => { const updateFlipped = flip(update) const result = updateFlipped( 88, 0, [ 1, 2, 3 ] ) const curriedResult = updateFlipped(88, 0)([ 1, 2, 3 ]) const tripleCurriedResult = updateFlipped(88)(0)([ 1, 2, 3 ]) expect(result).toEqual([ 88, 2, 3 ]) expect(curriedResult).toEqual([ 88, 2, 3 ]) expect(tripleCurriedResult).toEqual([ 88, 2, 3 ]) }) test('function with arity of 4', () => { const testFunction = ( a, b, c, d ) => `${ a - b }==${ c - d }` const testFunctionFlipped = flip(testFunction) const result = testFunction( 1, 2, 3, 4 ) const flippedResult = testFunctionFlipped( 2, 1, 3, 4 ) expect(result).toEqual(flippedResult) expect(result).toEqual('-1==-1') }) test('function with arity of 5', () => { const testFunction = ( a, b, c, d, e ) => `${ a - b }==${ c - d - e }` const testFunctionFlipped = flip(testFunction) expect(() => testFunctionFlipped( 1, 2, 3, 4, 5 )).toThrowWithMessage(Error, 'R.flip doesn\'t work with arity > 4') })
    Typescript test typescript import * as R from 'ramda' import {flip, subtract} from 'rambda' describe('R.flip', () => { it('function with arity of 2', () => { const subtractFlipped = flip(subtract) const result = subtractFlipped(1, 7) const curriedResult = subtractFlipped(1)(7) curriedResult // $ExpectType number // This is wrong // ============================================ result // $ExpectType (y: number) => number }) it('function with arity of 3', () => { function testFunction(a: number, b: string, c: number): string { return `${b}==${a + c}` } const flippedTestFunction = flip(testFunction) const result = flippedTestFunction('foo', 1, 2) result // $ExpectType string }) }) describe('Ramda.flip', () => { it('function with arity of 2', () => { const subtractFlipped = R.flip(R.subtract) const result = subtractFlipped(1, 7) const curriedResult = subtractFlipped(1)(7) curriedResult // $ExpectType number // This is wrong // ============================================ result // $ExpectType (b: number) => number }) })
    4 failed Ramda.flip specs > :boom: Reason for the failure: Ramda.flip returns a curried function | Rambda.flip work only for functions with arity below 5 javascript var jsv = require('jsverify'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); var funcN = require('./shared/funcN'); describe('flip', function() { it('returns a function which inverts the first two arguments to the supplied function', function() { var f = function(a, b, c) {return a + ' ' + b + ' ' + c;}; var g = R.flip(f); eq(f('a', 'b', 'c'), 'a b c'); eq(g('a', 'b', 'c'), 'b a c'); }); it('returns a curried function', function() { var f = function(a, b, c) {return a + ' ' + b + ' ' + c;}; var g = R.flip(f)('a'); eq(g('b', 'c'), 'b a c'); }); it('returns a function with the correct arity', function() { var f2 = function(a, b) {return a + ' ' + b;}; var f3 = function(a, b, c) {return a + ' ' + b + ' ' + c;}; eq(R.flip(f2).length, 2); eq(R.flip(f3).length, 3); }); }); describe('flip properties', function() { jsv.property('inverts first two arguments', funcN(3), jsv.json, jsv.json, jsv.json, function(f, a, b, c) { var g = R.flip(f); return R.equals(f(a, b, c), g(b, a, c)); }); });

    ---------------

    forEach

    
    forEach<T>(fn: MapFunctionArray<T, void>, list: readonly T[]): T[]
    

    It applies iterable function over all members of list and returns list.

    :boom: It works with objects, unlike Ramda.

    const sideEffect = {}
    const result = R.forEach(
      x => sideEffect[`foo${x}`] = x
    )([1, 2])
    
    sideEffect //=> {foo1: 1, foo2: 2}
    result //=> [1, 2]
    

    Try this R.forEach example in Rambda REPL

    All Typescript definitions typescript forEach<T>(fn: MapFunctionArray<T, void>, list: readonly T[]): T[]; forEach<T>(fn: MapFunctionArray<T, void>): (list: readonly T[]) => T[]; forEach<T>(fn: MapFunctionObject<T, void>, list: Dictionary<T>): Dictionary<T>; forEach<T, U>(fn: MapFunctionObject<T, void>): (list: Dictionary<T>) => Dictionary<T>;
    R.forEach source javascript import { _isArray } from './_internals/_isArray' import { _keys } from './_internals/_keys' export function forEach(fn, list){ if (arguments.length === 1) return _list => forEach(fn, _list) if (list === undefined){ return } if (_isArray(list)){ let index = 0 const len = list.length while (index < len){ fn(list[ index ]) index++ } } else { let index = 0 const keys = _keys(list) const len = keys.length while (index < len){ const key = keys[ index ] fn( list[ key ], key, list ) index++ } } return list }
    Tests javascript import { forEach } from './forEach' import { type } from './type' test('iterate over object', () => { const obj = { a : 1, b : [ 1, 2 ], c : { d : 7 }, f : 'foo', } const result = {} const returned = forEach(( val, prop, inputObj ) => { expect(type(inputObj)).toBe('Object') result[ prop ] = `${ prop }-${ type(val) }` })(obj) const expected = { a : 'a-Number', b : 'b-Array', c : 'c-Object', f : 'f-String', } expect(result).toEqual(expected) expect(returned).toEqual(obj) }) test('happy', () => { const sideEffect = {} forEach(x => sideEffect[ `foo${ x }` ] = x + 10)([ 1, 2 ]) expect(sideEffect).toEqual({ foo1 : 11, foo2 : 12, }) }) test('with empty list', () => { const list = [] const result = forEach(x => x * x)(list) expect(result).toEqual(list) }) test('with wrong input', () => { const list = undefined const result = forEach(x => x * x)(list) expect(result).toBeUndefined() }) test('returns the input', () => { const list = [ 1, 2, 3 ] const result = forEach(x => x * x)(list) expect(result).toEqual(list) })
    Typescript test typescript import {forEach} from 'rambda' const list = [1, 2, 3] const obj = {a: 1, b: 2} describe('R.forEach with arrays', () => { it('happy', () => { const result = forEach(a => { a // $ExpectType number }, list) result // $ExpectType number[] }) it('curried require an explicit typing', () => { const result = forEach<number>(a => { a // $ExpectType number })(list) result // $ExpectType number[] }) }) describe('R.forEach with objects', () => { it('happy', () => { const result = forEach((a, b, c) => { a // $ExpectType number b // $ExpectType string c // $ExpectType Dictionary<number> return `${a}` }, obj) result // $ExpectType Dictionary<number> }) it('curried require an input typing and a dummy third typing', () => { // Required in order all typings to work const result = forEach<number, any>((a, b, c) => { a // $ExpectType number b // $ExpectType string c // $ExpectType Dictionary<number> })(obj) result // $ExpectType Dictionary<number> }) it('iterator without property', () => { const result = forEach(a => { a // $ExpectType number }, obj) result // $ExpectType Dictionary<number> }) })
    1 failed Ramda.forEach specs > :boom: Reason for the failure: Ramda method dispatches to forEach method javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('forEach', function() { var list = [{x: 1, y: 2}, {x: 100, y: 200}, {x: 300, y: 400}, {x: 234, y: 345}]; it('dispatches to `forEach` method', function() { var dispatched = false; var fn = function() {}; function DummyList() {} DummyList.prototype.forEach = function(callback) { dispatched = true; eq(callback, fn); }; R.forEach(fn, new DummyList()); eq(dispatched, true); }); });

    ---------------

    fromPairs

    
    fromPairs<V>(listOfPairs: KeyValuePair<string, V>[]): { [index: string]: V }
    

    It transforms a listOfPairs to an object.

    const listOfPairs = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ] ]
    const expected = {
      a : 1,
      b : 2,
      c : [ 3, 4 ],
    }
    
    const result = R.fromPairs(listOfPairs)
    // => `result` is equal to `expected`
    

    Try this R.fromPairs example in Rambda REPL

    All Typescript definitions typescript fromPairs<V>(listOfPairs: KeyValuePair<string, V>[]): { [index: string]: V }; fromPairs<V>(listOfPairs: KeyValuePair<number, V>[]): { [index: number]: V };
    R.fromPairs source javascript export function fromPairs(listOfPairs){ const toReturn = {} listOfPairs.forEach(([ prop, value ]) => toReturn[ prop ] = value) return toReturn }
    Tests javascript import { fromPairs } from './fromPairs' const list = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ], ] const expected = { a : 1, b : 2, c : [ 3, 4 ], } test('happy', () => { expect(fromPairs(list)).toEqual(expected) })
    Typescript test typescript import {fromPairs} from 'rambda' describe('R.fromPairs - require explicit type for input list', () => { it('with string index', () => { const list: [string, number][] = [ ['a', 1], ['b', 2], ['c', 3], ] const result = fromPairs(list) result // $ExpectType { [index: string]: number; } }) it('with number index', () => { const list: [number, string][] = [ [10, 'foo'], [20, 'bar'], [30, 'baz'], ] const result = fromPairs(list) result // $ExpectType { [index: number]: string; } }) })

    ---------------

    groupBy

    
    groupBy<T>(groupFn: (x: T) => string, list: readonly T[]): { [index: string]: T[] }
    

    It splits list according to a provided groupFn function and returns an object.

    const list = [ 'a', 'b', 'aa', 'bb' ]
    const groupFn = x => x.length
    
    const result = R.groupBy(groupFn, list)
    // => { '1': ['a', 'b'], '2': ['aa', 'bb'] }
    

    Try this R.groupBy example in Rambda REPL

    All Typescript definitions typescript groupBy<T>(groupFn: (x: T) => string, list: readonly T[]): { [index: string]: T[] }; groupBy<T>(groupFn: (x: T) => string): (list: readonly T[]) => { [index: string]: T[] };
    R.groupBy source javascript export function groupBy(groupFn, list){ if (arguments.length === 1) return _list => groupBy(groupFn, _list) const result = {} for (let i = 0; i < list.length; i++){ const item = list[ i ] const key = groupFn(item) if (!result[ key ]){ result[ key ] = [] } result[ key ].push(item) } return result }
    Tests javascript import { groupBy } from './groupBy' import { prop } from './prop' test('groupBy', () => { const list = [ { age : 12, name : 'john', }, { age : 12, name : 'jack', }, { age : 24, name : 'mary', }, { age : 24, name : 'steve', }, ] const expectedResult = { 12 : [ { age : 12, name : 'john', }, { age : 12, name : 'jack', }, ], 24 : [ { age : 24, name : 'mary', }, { age : 24, name : 'steve', }, ], } expect(groupBy(prop('age'))(list)).toEqual(expectedResult) expect(groupBy(prop('age'), list)).toEqual(expectedResult) })
    Typescript test typescript import {groupBy} from 'rambda' describe('R.groupBy', () => { it('happy', () => { const groupByFn = (x: string) => String(x.length) const list = ['foo', 'barr', 'bazzz'] const result = groupBy(groupByFn, list) result // $ExpectType { [index: string]: string[]; } const curriedResult = groupBy(groupByFn)(list) curriedResult // $ExpectType { [index: string]: string[]; } }) })
    1 failed Ramda.groupBy specs > :boom: Reason for the failure: Ramda method support transforms javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); var _isTransformer = require('rambda/internal/_isTransformer'); describe('groupBy', function() { it('dispatches on transformer objects in list position', function() { var byType = R.prop('type'); var xf = { '@@transducer/init': function() { return {}; }, '@@transducer/result': function(x) { return x; }, '@@transducer/step': R.mergeRight }; eq(_isTransformer(R.groupBy(byType, xf)), true); }); });

    ---------------

    groupWith

    
    groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: readonly T[]) => T[][]
    

    It returns separated version of list or string input, where separation is done with equality compareFn function.

    const compareFn = (x, y) => x === y
    const list = [1, 2, 2, 1, 1, 2]
    
    const result = R.groupWith(isConsecutive, list)
    // => [[1], [2,2], [1,1], [2]]
    

    Try this R.groupWith example in Rambda REPL

    All Typescript definitions typescript groupWith<T>(compareFn: (x: T, y: T) => boolean): (input: readonly T[]) => T[][]; groupWith<T>(compareFn: (x: T, y: T) => boolean, input: readonly T[]): T[][]; groupWith<T>(compareFn: (x: T, y: T) => boolean, input: string): string[];
    R.groupWith source javascript import { _isArray } from './_internals/_isArray' export function groupWith(compareFn, list){ if (!_isArray(list)) throw new TypeError('list.reduce is not a function') const clone = list.slice() if (list.length === 1) return [ clone ] const toReturn = [] let holder = [] clone.reduce(( prev, current, i ) => { if (i === 0) return current const okCompare = compareFn(prev, current) const holderIsEmpty = holder.length === 0 const lastCall = i === list.length - 1 if (okCompare){ if (holderIsEmpty) holder.push(prev) holder.push(current) if (lastCall) toReturn.push(holder) return current } if (holderIsEmpty){ toReturn.push([ prev ]) if (lastCall) toReturn.push([ current ]) return current } toReturn.push(holder) if (lastCall) toReturn.push([ current ]) holder = [] return current }, undefined) return toReturn }
    Tests javascript import { equals } from './equals' import { groupWith } from './groupWith' test('issue is fixed', () => { const result = groupWith(equals, [ 1, 2, 2, 3 ]) const expected = [ [ 1 ], [ 2, 2 ], [ 3 ] ] expect(result).toEqual(expected) }) test('long list', () => { const result = groupWith(equals, [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 21, 21, 1, 2, ]) const expected = [ [ 0 ], [ 1, 1 ], [ 2 ], [ 3 ], [ 5 ], [ 8 ], [ 13 ], [ 21, 21, 21 ], [ 1 ], [ 2 ], ] expect(result).toEqual(expected) }) test('readme example', () => { const list = [ 4, 3, 6, 2, 2, 1 ] const result = groupWith((a, b) => a - b === 1, list) const expected = [ [ 4, 3 ], [ 6 ], [ 2 ], [ 2, 1 ] ] expect(result).toEqual(expected) }) test('throw with string as input', () => { expect(() => groupWith(equals, 'Mississippi')).toThrowWithMessage(TypeError, 'list.reduce is not a function') }) const isConsecutive = function (a, b){ return a + 1 === b } test('fix coverage', () => { expect(groupWith(isConsecutive, [ 1, 2, 3, 0 ])).toEqual([ [ 1, 2, 3 ], [ 0 ] ]) }) test('from ramda 0', () => { expect(groupWith(equals, [])).toEqual([]) expect(groupWith(isConsecutive, [])).toEqual([]) }) test('from ramda 1', () => { expect(groupWith(isConsecutive, [ 4, 3, 2, 1 ])).toEqual([ [ 4 ], [ 3 ], [ 2 ], [ 1 ], ]) }) test('from ramda 2', () => { expect(groupWith(isConsecutive, [ 1, 2, 3, 4 ])).toEqual([ [ 1, 2, 3, 4 ] ]) }) test('from ramda 3', () => { expect(groupWith(isConsecutive, [ 1, 2, 2, 3 ])).toEqual([ [ 1, 2 ], [ 2, 3 ], ]) expect(groupWith(isConsecutive, [ 1, 2, 9, 3, 4 ])).toEqual([ [ 1, 2 ], [ 9 ], [ 3, 4 ], ]) }) test('list with single item', () => { const result = groupWith(equals, [ 0 ]) const expected = [ [ 0 ] ] expect(result).toEqual(expected) })
    Typescript test typescript import {groupWith} from 'rambda' describe('R.groupWith', () => { it('happy', () => { const groupWithFn = (x: string, y: string) => x.length === y.length const list = ['foo', 'bar', 'bazzz'] const result = groupWith(groupWithFn, list) const curriedResult = groupWith(groupWithFn)(list) result // $ExpectType string[][] curriedResult // $ExpectType string[][] }) })
    2 failed Ramda.groupWith specs > :boom: Reason for the failure: Ramda method support string javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('groupWith', function() { it('can be turned into the original list through concatenation', function() { var list = [1, 1, 2, 3, 4, 4, 5, 5]; eq(R.unnest(R.groupWith(R.equals, list)), list); eq(R.unnest(R.groupWith(R.complement(R.equals), list)), list); eq(R.unnest(R.groupWith(R.T, list)), list); eq(R.unnest(R.groupWith(R.F, list)), list); }); it('also works on strings', function() { eq(R.groupWith(R.equals)('Mississippi'), ['M','i','ss','i','ss','i','pp','i']); }); });

    ---------------

    has

    
    has<T>(prop: string, obj: T): boolean
    

    It returns true if obj has property prop.

    const obj = {a: 1}
    
    const result = [
      R.has('a', obj),
      R.has('b', obj)
    ]
    // => [true, false]
    

    Try this R.has example in Rambda REPL

    All Typescript definitions typescript has<T>(prop: string, obj: T): boolean; has(prop: string): <T>(obj: T) => boolean;
    R.has source javascript export function has(prop, obj){ if (arguments.length === 1) return _obj => has(prop, _obj) if (!obj) return false return obj[ prop ] !== undefined }
    Tests javascript import { has } from './has' test('happy', () => { expect(has('a')({ a : 1 })).toBeTrue() expect(has('b', { a : 1 })).toBeFalse() }) test('with non-object', () => { expect(has('a', undefined)).toEqual(false) expect(has('a', null)).toEqual(false) expect(has('a', true)).toEqual(false) expect(has('a', '')).toEqual(false) expect(has('a', /a/)).toEqual(false) })
    Typescript test typescript import {has} from 'rambda' describe('R.has', () => { it('happy', () => { const result = has('foo', {a: 1}) const curriedResult = has('bar')({a: 1}) result // $ExpectType boolean curriedResult // $ExpectType boolean }) })
    1 failed Ramda.has specs > :boom: Reason for the failure: Rambda method does check properties from the prototype chain javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('has', function() { var fred = {name: 'Fred', age: 23}; var anon = {age: 99}; it('does not check properties from the prototype chain', function() { var Person = function() {}; Person.prototype.age = function() {}; var bob = new Person(); eq(R.has('age', bob), false); }); });

    ---------------

    hasPath

    
    hasPath<T>(
      path: string | readonly string[],
      input: object
    ): boolean
    

    It will return true, if input object has truthy path(calculated with R.path).

    const path = 'a.b'
    const pathAsArray = ['a', 'b']
    const obj = {a: {b: []}}
    
    const result = [
      R.hasPath(path, obj),
      R.hasPath(pathAsArray, obj),
      R.hasPath('a.c', obj),
    ]
    // => [true, true, false]
    

    Try this R.hasPath example in Rambda REPL

    All Typescript definitions typescript hasPath<T>( path: string | readonly string[], input: object ): boolean; hasPath<T>( path: string | readonly string[] ): (input: object) => boolean;
    R.hasPath source javascript import { path } from './path' export function hasPath(maybePath, obj){ if (arguments.length === 1){ return objHolder => hasPath(maybePath, objHolder) } return path(maybePath, obj) !== undefined }
    Tests javascript import { hasPath } from './hasPath' test('when true', () => { const path = 'a.b' const obj = { a : { b : [] } } const result = hasPath(path)(obj) const expectedResult = true expect(result).toEqual(expectedResult) }) test('when false', () => { const path = 'a.b' const obj = {} const result = hasPath(path, obj) const expectedResult = false expect(result).toEqual(expectedResult) })
    Typescript test typescript import {hasPath} from 'rambda' describe('R.hasPath', () => { it('string path', () => { const obj = {a: {b: 1}} const result = hasPath('a.b', obj) const curriedResult = hasPath('a.c')(obj) result // $ExpectType boolean curriedResult // $ExpectType boolean }) it('array path', () => { const obj = {a: {b: 1}} const result = hasPath(['a', 'b'], obj) const curriedResult = hasPath(['a', 'c'])(obj) result // $ExpectType boolean curriedResult // $ExpectType boolean }) })

    ---------------

    
    head<T>(input: readonly T[]): T | undefined
    

    It returns the first element of list or string input.

    const result = [
      R.head([1, 2, 3]),
      R.head('foo') 
    ]
    // => [1, 'f']
    

    Try this R.head example in Rambda REPL

    All Typescript definitions typescript head<T>(input: readonly T[]): T | undefined; head(input: string): string;
    R.head source javascript export function head(listOrString){ if (typeof listOrString === 'string') return listOrString[ 0 ] || '' return listOrString[ 0 ] }
    Tests javascript import { head } from './head' test('head', () => { expect(head([ 'fi', 'fo', 'fum' ])).toEqual('fi') expect(head([])).toEqual(undefined) expect(head('foo')).toEqual('f') expect(head('')).toEqual('') })
    Typescript test typescript import {head} from 'rambda' describe('R.head', () => { it('string', () => { const result = head('foo') result // $ExpectType string }) it('array', () => { const result = head([1, 2, 3]) result // $ExpectType number | undefined }) })

    ---------------

    identical

    
    identical<T>(x: T, y: T): boolean
    

    It returns true if its arguments a and b are identical.

    Otherwise, it returns false.

    :boom: Values are identical if they reference the same memory. NaN is identical to NaN; 0 and -0 are not identical.

    const obj = {a: 1};
    R.identical(obj, obj); //=> true
    R.identical(1, 1); //=> true
    R.identical(1, '1'); //=> false
    R.identical([], []); //=> false
    R.identical(0, -0); //=> false
    R.identical(NaN, NaN); //=> true
    

    Try this R.identical example in Rambda REPL

    All Typescript definitions typescript identical<T>(x: T, y: T): boolean; identical<T>(x: T): (y: T) => boolean;
    R.identical source javascript import _objectIs from './_internals/_objectIs' export function identical(a, b){ if (arguments.length === 1) return _b => identical(a, _b) return _objectIs(a, b) }
    Tests javascript import { F, T } from '../rambda' import { _isInteger } from './_internals/_isInteger' import { _objectIs } from './_internals/_objectIs' import { identical } from './identical' test('with boolean', () => { expect(F()).toBeFalse() expect(T()).toBeTrue() }) test('internal isInteger', () => { expect(_isInteger(1)).toBeTrue() expect(_isInteger(0.3)).toBeFalse() }) test('internal objectIs', () => { expect(_objectIs(1, 1)).toBeTrue() expect(_objectIs(NaN, NaN)).toBeTrue() }) test('identical', () => { const a = {} expect(identical(100)(100)).toEqual(true) expect(identical(100, '100')).toEqual(false) expect(identical('string', 'string')).toEqual(true) expect(identical([], [])).toEqual(false) expect(identical(a, a)).toEqual(true) expect(identical(undefined, undefined)).toEqual(true) expect(identical(null, undefined)).toEqual(false) })
    Typescript test typescript import {identical} from 'rambda' describe('R.identical', () => { it('happy', () => { const result = identical(4, 1) const curriedResult = identical(4)(1) result // $ExpectType boolean curriedResult // $ExpectType boolean }) it('with object', () => { const result = identical({a: 1}, {b: 2}) result // $ExpectType boolean }) }) /* in curried version Typescript correctly catch errors but it doesn't do so in the standart definition identical({a:1},{b:2}) identical({a:1})({b:2}) */

    ---------------

    identity

    
    identity<T>(input: T): T
    

    It just passes back the supplied input argument.

    :boom: Logic

    R.identity(7) // => 7
    

    Try this R.identity example in Rambda REPL

    All Typescript definitions typescript identity<T>(input: T): T;
    R.identity source javascript export function identity(input){ return input }
    Tests javascript import { identity } from './identity' test('happy', () => { expect(identity(7)).toEqual(7) expect(identity(true)).toEqual(true) expect(identity({ a : 1 })).toEqual({ a : 1 }) })
    Typescript test typescript import {identity} from 'rambda' describe('R.identity', () => { it('happy', () => { const result = identity(4) result // $ExpectType 4 }) })

    ---------------

    ifElse

    
    ifElse<T, U>(
      condition: (x: T) => boolean, 
      onTrue: (x: T) => U, 
      onFalse: (x: T) => U, 
    ): (x: T) => U
    

    It expects condition, onTrue and onFalse functions as inputs and it returns a new function with example name of fn.

    When fn`` is called withinputargument, it will return eitheronTrue(input)oronFalse(input)depending oncondition(input)` evaluation.

    const fn = R.ifElse(
     x => x>10,
     x => x*2,
     x => x*10
    )
    
    const result = [ fn(8), fn(18) ]
    // => [80, 36]
    

    Try this R.ifElse example in Rambda REPL

    All Typescript definitions typescript ifElse<T, U>( condition: (x: T) => boolean, onTrue: (x: T) => U, onFalse: (x: T) => U, ): (x: T) => U; ifElse<T, K, U>( condition: (x: T, y: K) => boolean, onTrue: (x: T, y: K) => U, onFalse: (x: T, y: K) => U, ): (x: T, y: K) => U;
    R.ifElse source javascript import { curry } from './curry' function ifElseFn( condition, onTrue, onFalse ){ return (...input) => { const conditionResult = typeof condition === 'boolean' ? condition : condition(...input) if (conditionResult === true){ return onTrue(...input) } return onFalse(...input) } } export const ifElse = curry(ifElseFn)
    Tests javascript import { always } from './always' import { has } from './has' import { identity } from './identity' import { ifElse } from './ifElse' import { prop } from './prop' const condition = has('foo') const v = function (a){ return typeof a === 'number' } const t = function (a){ return a + 1 } const ifFn = x => prop('foo', x).length const elseFn = () => false test('happy', () => { const fn = ifElse(condition, ifFn)(elseFn) expect(fn({ foo : 'bar' })).toEqual(3) expect(fn({ fo : 'bar' })).toEqual(false) }) test('ramda spec', () => { const ifIsNumber = ifElse(v) expect(ifIsNumber(t, identity)(15)).toEqual(16) expect(ifIsNumber(t, identity)('hello')).toEqual('hello') }) test('pass all arguments', () => { const identity = function (a){ return a } const v = function (){ return true } const onTrue = function (a, b){ expect(a).toEqual(123) expect(b).toEqual('abc') } ifElse( v, onTrue, identity )(123, 'abc') }) test('accept constant as condition', () => { const fn = ifElse(true)(always(true))(always(false)) expect(fn()).toEqual(true) }) test('accept constant as condition - case 2', () => { const fn = ifElse( false, always(true), always(false) ) expect(fn()).toEqual(false) }) test('curry 1', () => { const fn = ifElse(condition, ifFn)(elseFn) expect(fn({ foo : 'bar' })).toEqual(3) expect(fn({ fo : 'bar' })).toEqual(false) }) test('curry 2', () => { const fn = ifElse(condition)(ifFn)(elseFn) expect(fn({ foo : 'bar' })).toEqual(3) expect(fn({ fo : 'bar' })).toEqual(false) }) test('simple arity of 1', () => { const condition = x => x > 5 const onTrue = x => x + 1 const onFalse = x => x + 10 const result = ifElse( condition, onTrue, onFalse )(1) expect(result).toBe(11) }) test('simple arity of 2', () => { const condition = (x, y) => x + y > 5 const onTrue = (x, y) => x + y + 1 const onFalse = (x, y) => x + y + 10 const result = ifElse( condition, onTrue, onFalse )(1, 10) expect(result).toBe(12) })
    Typescript test typescript import {ifElse} from 'rambda' describe('R.ifElse', () => { it('happy', () => { const condition = (x: number) => x > 5 const onTrue = (x: number) => `foo${x}` const onFalse = (x: number) => `bar${x}` const fn = ifElse(condition, onTrue, onFalse) fn // $ExpectType (x: number) => string const result = fn(3) result // $ExpectType string }) it('arity of 2', () => { const condition = (x: number, y: string) => x + y.length > 5 const onTrue = (x: number, y: string) => `foo${x}-${y}` const onFalse = (x: number, y: string) => `bar${x}-${y}` const fn = ifElse(condition, onTrue, onFalse) fn // $ExpectType (x: number, y: string) => string const result = fn(3, 'hello') result // $ExpectType string }) })
    2 failed Ramda.ifElse specs > :boom: Reason for the failure: Rambda method doesn't return a curried function javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('ifElse', function() { var t = function(a) { return a + 1; }; var identity = function(a) { return a; }; var isArray = function(a) { return Object.prototype.toString.call(a) === '[object Array]'; }; it('returns a function whose arity equals the max arity of the three arguments to `ifElse`', function() { function a0() { return 0; } function a1(x) { return x; } function a2(x, y) { return x + y; } eq(R.ifElse(a0, a1, a2).length, 2); eq(R.ifElse(a0, a2, a1).length, 2); eq(R.ifElse(a1, a0, a2).length, 2); eq(R.ifElse(a1, a2, a0).length, 2); eq(R.ifElse(a2, a0, a1).length, 2); eq(R.ifElse(a2, a1, a0).length, 2); }); it('returns a curried function', function() { var v = function(a) { return typeof a === 'number'; }; var ifIsNumber = R.ifElse(v); eq(ifIsNumber(t, identity)(15), 16); eq(ifIsNumber(t, identity)('hello'), 'hello'); var fn = R.ifElse(R.gt, R.subtract, R.add); eq(fn(2)(7), 9); eq(fn(2, 7), 9); eq(fn(7)(2), 5); eq(fn(7, 2), 5); }); });

    ---------------

    inc

    
    inc(x: number): number
    

    It increments a number.

    R.inc(1) // => 2
    

    Try this R.inc example in Rambda REPL

    All Typescript definitions typescript inc(x: number): number;
    R.inc source javascript export const inc = x => x + 1
    Tests javascript import { inc } from './inc' test('happy', () => { expect(inc(1)).toBe(2) })

    ---------------

    includes

    
    includes(valueToFind: string, input: readonly string[] | string): boolean
    

    If input is string, then this method work as native String.includes.

    If input is array, then R.equals is used to define if valueToFind belongs to the list.

    const result = [
      R.includes('oo', 'foo'),
      R.includes({a: 1}, [{a: 1}])
    ]
    // => [true, true ]
    

    Try this R.includes example in Rambda REPL

    All Typescript definitions typescript includes(valueToFind: string, input: readonly string[] | string): boolean; includes(valueToFind: string): (input: readonly string[] | string) => boolean; includes<T>(valueToFind: T, input: readonly T[]): boolean; includes<T>(valueToFind: T): (input: readonly T[]) => boolean;
    R.includes source javascript import { _isArray } from './_internals/_isArray' import { equals } from './equals' export function includes(valueToFind, input){ if (arguments.length === 1) return _input => includes(valueToFind, _input) if (typeof input === 'string'){ return input.includes(valueToFind) } if (!input){ throw new TypeError(`Cannot read property \'indexOf\' of ${ input }`) } if (!_isArray(input)) return false let index = -1 while (++index < input.length){ if (equals(input[ index ], valueToFind)){ return true } } return false }
    Tests javascript import R from 'ramda' import { includes } from './includes' test('includes with string', () => { const str = 'foo bar' expect(includes('bar')(str)).toBeTrue() expect(R.includes('bar')(str)).toBeTrue() expect(includes('never', str)).toBeFalse() expect(R.includes('never', str)).toBeFalse() }) test('includes with array', () => { const arr = [ 1, 2, 3 ] expect(includes(2)(arr)).toBeTrue() expect(R.includes(2)(arr)).toBeTrue() expect(includes(4, arr)).toBeFalse() expect(R.includes(4, arr)).toBeFalse() }) test('with wrong input that does not throw', () => { const result = includes(1, /foo/g) const ramdaResult = R.includes(1, /foo/g) expect(result).toBeFalse() expect(ramdaResult).toBeFalse() }) test('throws on wrong input - match ramda behaviour', () => { expect(() => includes(2, null)).toThrowWithMessage(TypeError, 'Cannot read property \'indexOf\' of null') expect(() => R.includes(2, null)).toThrowWithMessage(TypeError, 'Cannot read property \'indexOf\' of null') expect(() => includes(2, undefined)).toThrowWithMessage(TypeError, 'Cannot read property \'indexOf\' of undefined') expect(() => R.includes(2, undefined)).toThrowWithMessage(TypeError, 'Cannot read property \'indexOf\' of undefined') })
    Typescript test typescript import {includes} from 'rambda' const list = [{a: {b: '1'}}, {a: {c: '2'}}, {a: {b: '3'}}] describe('R.includes', () => { it('happy', () => { const result = includes({a: {b: '1'}}, list) result // $ExpectType boolean }) it('with string', () => { const result = includes('oo', 'foo') const resultCurried = includes('oo')('foo') result // $ExpectType boolean resultCurried // $ExpectType boolean }) })
    1 failed Ramda.includes specs > :boom: Reason for the failure: Ramda method pass to equals method if available javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('includes', function() { it('has R.equals semantics', function() { function Just(x) { this.value = x; } Just.prototype.equals = function(x) { return x instanceof Just && R.equals(x.value, this.value); }; eq(R.includes(0, [-0]), false); eq(R.includes(-0, [0]), false); eq(R.includes(NaN, [NaN]), true); eq(R.includes(new Just([42]), [new Just([42])]), true); }); });

    ---------------

    indexBy

    
    indexBy<T>(condition: (x: T) => string, list: readonly T[]): { [key: string]: T }
    

    It generates object with properties provided by condition and values provided by list array.

    If condition is a function, then all list members are passed through it.

    If condition is a string, then all list members are passed through R.path(condition).

    const list = [ {id: 10}, {id: 20} ]
    
    const withFunction = R.indexBy(
      x => x.id,
      list
    )
    const withString = R.indexBy(
      'id',
      list
    )
    const result = [
      withFunction, 
      R.equals(withFunction, withString)
    ]
    // => [ { 10: {id: 10}, 20: {id: 20} }, true ]
    

    Try this R.indexBy example in Rambda REPL

    All Typescript definitions typescript indexBy<T>(condition: (x: T) => string, list: readonly T[]): { [key: string]: T }; indexBy<T>(condition: string, list: readonly T[]): { [key: string]: T }; indexBy<T>(condition: (x: T) => string): (list: readonly T[]) => { [key: string]: T }; indexBy<T>(condition: string): (list: readonly T[]) => { [key: string]: T };
    R.indexBy source javascript import { path } from './path' function indexByPath(pathInput, list){ const toReturn = {} for (let i = 0; i < list.length; i++){ const item = list[ i ] toReturn[ path(pathInput, item) ] = item } return toReturn } export function indexBy(condition, list){ if (arguments.length === 1){ return _list => indexBy(condition, _list) } if (typeof condition === 'string'){ return indexByPath(condition, list) } const toReturn = {} for (let i = 0; i < list.length; i++){ const item = list[ i ] toReturn[ condition(item) ] = item } return toReturn }
    Tests javascript import { indexBy } from './indexBy' import { prop } from './prop' test('happy', () => { const list = [ { id : 1 }, { id : 1, a : 2, }, { id : 2 }, { id : 10 }, { id : 'a' }, ] expect(indexBy(prop('id'))(list)).toEqual({ 1 : { id : 1, a : 2, }, 2 : { id : 2 }, 10 : { id : 10 }, a : { id : 'a' }, }) }) test('with string as condition', () => { const list = [ { id : 1 }, { id : 2 }, { id : 10 }, { id : 'a' } ] const standardResult = indexBy(obj => obj.id, list) const suggestionResult = indexBy('id', list) expect(standardResult).toEqual(suggestionResult) }) test('with string - bad path', () => { const list = [ { a : { b : 1, c : 2, }, }, { a : { c : 4 } }, {}, { a : { b : 10, c : 20, }, }, ] const result = indexBy('a.b', list) const expected = { 1 : { a : { b : 1, c : 2, }, }, 10 : { a : { b : 10, c : 20, }, }, undefined : {}, } expect(result).toEqual(expected) })
    Typescript test typescript import {indexBy} from 'rambda' const list = [{a: {b: '1'}}, {a: {c: '2'}}, {a: {b: '3'}}] describe('indexBy', () => { it('happy', () => { const result = indexBy<any>(x => x.a.b, list) const resultCurried = indexBy<any>(x => x.a.b)(list) result // $ExpectType { [key: string]: any; } resultCurried // $ExpectType { [key: string]: any; } }) it('with string', () => { const result = indexBy<any>('a.b', list) const resultCurried = indexBy<any>('a.b')(list) result // $ExpectType { [key: string]: any; } resultCurried // $ExpectType { [key: string]: any; } }) it('with interface', () => { interface Foo { a: string, } const interfaceList = [{a: 'foo'}, {a: 'bar'}] const result = indexBy<Foo>(x => { x.a // $ExpectType string return x.a }, interfaceList) const resultCurried = indexBy<Foo>(x => { x.a // $ExpectType string return x.a })(interfaceList) result // $ExpectType { [key: string]: Foo; } resultCurried // $ExpectType { [key: string]: Foo; } }) })
    1 failed Ramda.indexBy specs > :boom: Reason for the failure: Ramda method can act as a transducer javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('indexBy', function() { it('can act as a transducer', function() { var list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}]; var transducer = R.compose( R.indexBy(R.prop('id')), R.map(R.pipe( R.adjust(0, R.toUpper), R.adjust(1, R.omit(['id'])) ))); var result = R.into({}, transducer, list); eq(result, {ABC: {title: 'B'}, XYZ: {title: 'A'}}); }); });

    ---------------

    indexOf

    
    indexOf<T>(valueToFind: T, list: readonly T[]): number
    

    It returns the index of the first element of list equals to valueToFind.

    If there is no such element, it returns -1.

    const list = [0, 1, 2, 3]
    
    const result = [
      R.indexOf(2, list),
      R.indexOf(0, list)
    ]
    // => [2, -1]
    

    Try this R.indexOf example in Rambda REPL

    All Typescript definitions typescript indexOf<T>(valueToFind: T, list: readonly T[]): number; indexOf<T>(valueToFind: T): (list: readonly T[]) => number;
    R.indexOf source javascript export function indexOf(valueToFind, list){ if (arguments.length === 1){ return _list => indexOf(valueToFind, _list) } let index = -1 const { length } = list while (++index < length){ if (list[ index ] === valueToFind){ return index } } return -1 }
    Tests javascript import { indexOf } from './indexOf' test('happy', () => { expect(indexOf(3, [ 1, 2, 3, 4 ])).toEqual(2) expect(indexOf(10)([ 1, 2, 3, 4 ])).toEqual(-1) })
    Typescript test typescript import {indexOf} from 'rambda' describe('R.indexOf', () => { it('happy', () => { const list = [1, 2, 3] const result = indexOf(1, list) const curriedResult = indexOf(1)(list) result // $ExpectType number curriedResult // $ExpectType number }) })
    2 failed Ramda.indexOf specs > :boom: Reason for the failure: Ramda method dispatches to indexOf method javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('indexOf', function() { var input = [1, 2, 3, 4, 5]; var list = [1, 2, 3]; list[-2] = 4; // Throw a wrench in the gears by assigning a non-valid array index as object property. it('has R.equals semantics', function() { function Just(x) { this.value = x; } Just.prototype.equals = function(x) { return x instanceof Just && R.equals(x.value, this.value); }; eq(R.indexOf(0, [-0]), -1); eq(R.indexOf(-0, [0]), -1); eq(R.indexOf(NaN, [NaN]), 0); eq(R.indexOf(new Just([42]), [new Just([42])]), 0); }); it('dispatches to `indexOf` method', function() { function Empty() {} Empty.prototype.indexOf = R.always(-1); function List(head, tail) { this.head = head; this.tail = tail; } List.prototype.indexOf = function(x) { var idx = this.tail.indexOf(x); return this.head === x ? 0 : idx >= 0 ? 1 + idx : -1; }; var list = new List('b', new List('a', new List('n', new List('a', new List('n', new List('a', new Empty() ) ) ) ) ) ); eq(R.indexOf('a', 'banana'), 1); eq(R.indexOf('x', 'banana'), -1); eq(R.indexOf('a', list), 1); eq(R.indexOf('x', list), -1); }); });

    ---------------

    init

    
    init<T>(input: readonly T[]): T[]
    

    It returns all but the last element of list or string input.

    const result = [
      R.init([1, 2, 3]) , 
      R.init('foo')  // => 'fo'
    ]
    // => [[1, 2], 'fo']
    

    Try this R.init example in Rambda REPL

    All Typescript definitions typescript init<T>(input: readonly T[]): T[]; init(input: string): string;
    R.init source javascript import baseSlice from './_internals/baseSlice' export function init(listOrString){ if (typeof listOrString === 'string') return listOrString.slice(0, -1) return listOrString.length ? baseSlice( listOrString, 0, -1 ) : [] }
    Tests javascript import { init } from './init' test('with array', () => { expect(init([ 1, 2, 3 ])).toEqual([ 1, 2 ]) expect(init([ 1, 2 ])).toEqual([ 1 ]) expect(init([ 1 ])).toEqual([]) expect(init([])).toEqual([]) expect(init([])).toEqual([]) expect(init([ 1 ])).toEqual([]) }) test('with string', () => { expect(init('foo')).toEqual('fo') expect(init('f')).toEqual('') expect(init('')).toEqual('') })
    Typescript test typescript import {init} from 'rambda' describe('R.init', () => { it('with string', () => { const result = init('foo') result // $ExpectType string }) it('with list', () => { const result = init([1, 2, 3]) result // $ExpectType number[] }) })

    ---------------

    intersection

    
    intersection<T>(listA: readonly T[], listB: readonly T[]): T[]
    

    It loops throw listA and listB and returns the intersection of the two according to R.equals.

    const listA = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ]
    const listB = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ]
    
    const result = intersection(listA, listB)
    // => [{ id : 3 }, { id : 4 }]
    

    Try this R.intersection example in Rambda REPL

    All Typescript definitions typescript intersection<T>(listA: readonly T[], listB: readonly T[]): T[]; intersection<T>(listA: readonly T[]): (listB: readonly T[]) => T[];
    R.intersection source javascript import { filter } from './filter' import { includes } from './includes' export function intersection(listA, listB){ if (arguments.length === 1) return _list => intersection(listA, _list) return filter(value => includes(value, listB), listA) }
    Tests javascript import { intersection } from './intersection' test('intersection', () => { const list1 = [ 1, 2, 3, 4 ] const list2 = [ 3, 4, 5, 6 ] expect(intersection(list1)(list2)).toEqual([ 3, 4 ]) expect(intersection([], [])).toEqual([]) }) test('intersection with objects', () => { const list1 = [ { id : 1 }, { id : 2 }, { id : 3 }, { id : 4 } ] const list2 = [ { id : 3 }, { id : 4 }, { id : 5 }, { id : 6 } ] expect(intersection(list1)(list2)).toEqual([ { id : 3 }, { id : 4 } ]) })
    Typescript test typescript import {intersection} from 'rambda' const list1 = [1, 2, 3] const list2 = [1, 3, 5] describe('R.intersection', () => { it('happy', () => { const result = intersection(list1, list2) result // $ExpectType number[] const curriedResult = intersection(list1)(list2) curriedResult // $ExpectType number[] }) })

    ---------------

    intersperse

    
    intersperse<T>(separator: T, list: readonly T[]): T[]
    

    It adds a separator between members of list.

    const list = [ 0, 1, 2, 3 ]
    const separator = '|'
    const result = intersperse(separator, list)
    // => [0, '|', 1, '|', 2, '|', 3]
    

    Try this R.intersperse example in Rambda REPL

    All Typescript definitions typescript intersperse<T>(separator: T, list: readonly T[]): T[]; intersperse<T>(separator: T): (list: readonly T[]) => T[];
    R.intersperse source javascript export function intersperse(separator, list){ if (arguments.length === 1) return _list => intersperse(separator, _list) let index = -1 const len = list.length const willReturn = [] while (++index < len){ if (index === len - 1){ willReturn.push(list[ index ]) } else { willReturn.push(list[ index ], separator) } } return willReturn }
    Tests javascript import { intersperse } from './intersperse' test('intersperse', () => { const list = [ { id : 1 }, { id : 2 }, { id : 10 }, { id : 'a' } ] expect(intersperse('!', list)).toEqual([ { id : 1 }, '!', { id : 2 }, '!', { id : 10 }, '!', { id : 'a' }, ]) expect(intersperse('!')([])).toEqual([]) })
    Typescript test typescript import {intersperse} from 'rambda' describe('R.intersperse', () => { it('happy', () => { const result = intersperse(1, [1, 2, 3]) result // $ExpectType number[] }) it('curried', () => { const result = intersperse('|')(['foo', 'bar']) result // $ExpectType string[] }) })

    ---------------

    is

    
    is(targetPrototype: any, x: any): boolean
    

    It returns true if x is instance of targetPrototype.

    const result = [
      R.is(String, 'foo'),  
      R.is(Array, 1)
    ]
    // => [true, false]
    

    Try this R.is example in Rambda REPL

    All Typescript definitions typescript is(targetPrototype: any, x: any): boolean; is(targetPrototype: any): (x: any) => boolean;
    R.is source javascript export function is(targetPrototype, x){ if (arguments.length === 1) return _x => is(targetPrototype, _x) return ( x != null && x.constructor === targetPrototype || x instanceof targetPrototype ) }
    Tests javascript import { is } from './is' test('works with built-in types', () => { expect(is(Array, undefined)).toBeFalse() expect(is(Array)([])).toBeTrue() expect(is(Boolean, new Boolean(false))).toBeTrue() expect(is(Date, new Date())).toBeTrue() expect(is(Function, () => {})).toBeTrue() expect(is(Number, new Number(0))).toBeTrue() expect(is(Object, {})).toBeTrue() expect(is(RegExp, /(?:)/)).toBeTrue() expect(is(String, new String(''))).toBeTrue() }) test('works with user-defined types', () => { function Foo(){} function Bar(){} Bar.prototype = new Foo() const foo = new Foo() const bar = new Bar() expect(is(Foo, foo)).toBeTrue() expect(is(Bar, bar)).toBeTrue() expect(is(Foo, bar)).toBeTrue() expect(is(Bar, foo)).toBeFalse() }) test('does not coerce', () => { expect(is(Boolean, 1)).toBeFalse() expect(is(Number, '1')).toBeFalse() expect(is(Number, false)).toBeFalse() }) test('recognizes primitives as their object equivalents', () => { expect(is(Boolean, false)).toBeTrue() expect(is(Number, 0)).toBeTrue() expect(is(String, '')).toBeTrue() }) test('does not consider primitives to be instances of Object', () => { expect(is(Object, false)).toBeFalse() expect(is(Object, 0)).toBeFalse() expect(is(Object, '')).toBeFalse() })
    Typescript test typescript import {is} from 'rambda' describe('R.is', () => { it('happy', () => { const result = is(String, 'foo') result // $ExpectType boolean }) it('curried', () => { const result = is(Number)(1) result // $ExpectType boolean }) })

    ---------------

    isEmpty

    
    isEmpty<T>(x: T): boolean
    

    It returns true if x is empty.

    const result = [
      R.isEmpty(''),
      R.isEmpty({ x : 0 })
    ]
    // => [true, false]
    

    Try this R.isEmpty example in Rambda REPL

    All Typescript definitions typescript isEmpty<T>(x: T): boolean;
    R.isEmpty source javascript import { type } from './type' export function isEmpty(input){ const inputType = type(input) if ([ 'Undefined', 'NaN', 'Number', 'Null' ].includes(inputType)) return false if (!input) return true if (inputType === 'Object'){ return Object.keys(input).length === 0 } if (inputType === 'Array'){ return input.length === 0 } return false }
    Tests javascript import { isEmpty } from './isEmpty' test('happy', () => { expect(isEmpty(undefined)).toEqual(false) expect(isEmpty('')).toEqual(true) expect(isEmpty(null)).toEqual(false) expect(isEmpty(' ')).toEqual(false) expect(isEmpty(new RegExp(''))).toEqual(false) expect(isEmpty([])).toEqual(true) expect(isEmpty([ [] ])).toEqual(false) expect(isEmpty({})).toEqual(true) expect(isEmpty({ x : 0 })).toEqual(false) expect(isEmpty(0)).toEqual(false) expect(isEmpty(NaN)).toEqual(false) expect(isEmpty([ '' ])).toEqual(false) })
    Typescript test typescript import {isEmpty} from 'rambda' describe('R.isEmpty', () => { it('happy', () => { const result = isEmpty('foo') result // $ExpectType boolean }) })
    1 failed Ramda.isEmpty specs > :boom: Reason for the failure: Ramda method supports typed arrays javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('isEmpty', function() { it('returns true for empty typed array', function() { eq(R.isEmpty(Uint8Array.from('')), true); eq(R.isEmpty(Float32Array.from('')), true); eq(R.isEmpty(new Float32Array([])), true); eq(R.isEmpty(Uint8Array.from('1')), false); eq(R.isEmpty(Float32Array.from('1')), false); eq(R.isEmpty(new Float32Array([1])), false); }); });

    ---------------

    isNil

    
    isNil(x: any): x is null | undefined
    

    It returns true if x is either null or undefined.

    const result = [
      R.isNil(null),
      R.isNil(1),
    ]
    // => [true, false]
    

    Try this R.isNil example in Rambda REPL

    All Typescript definitions typescript isNil(x: any): x is null | undefined;
    R.isNil source javascript export function isNil(x){ return x === undefined || x === null }
    Tests javascript import { isNil } from './isNil' test('happy', () => { expect(isNil(null)).toBeTrue() expect(isNil(undefined)).toBeTrue() expect(isNil([])).toBeFalse() })

    ---------------

    join

    
    join<T>(glue: string, list: readonly T[]): string
    

    It returns a string of all list instances joined with a glue.

    R.join('-', [1, 2, 3])  // => '1-2-3'
    

    Try this R.join example in Rambda REPL

    All Typescript definitions typescript join<T>(glue: string, list: readonly T[]): string; join<T>(glue: string): (list: readonly T[]) => string;
    R.join source javascript export function join(glue, list){ if (arguments.length === 1) return _list => join(glue, _list) return list.join(glue) }
    Tests javascript import { join } from './join' test('curry', () => { expect(join('|')([ 'foo', 'bar', 'baz' ])).toEqual('foo|bar|baz') expect(join('|', [ 1, 2, 3 ])).toEqual('1|2|3') const spacer = join(' ') expect(spacer([ 'a', 2, 3.4 ])).toEqual('a 2 3.4') })
    Typescript test typescript import {join} from 'rambda' describe('R.join', () => { it('happy', () => { const result = join('|', [1, 2, 3]) result // $ExpectType string }) })

    ---------------

    keys

    
    keys<T extends object>(x: T): (keyof T)[]
    

    It applies Object.keys over x and returns its keys.

    R.keys({a:1, b:2})  // => ['a', 'b']
    

    Try this R.keys example in Rambda REPL

    All Typescript definitions typescript keys<T extends object>(x: T): (keyof T)[]; keys<T>(x: T): string[];
    R.keys source javascript export function keys(x){ return Object.keys(x) }
    Tests javascript import { keys } from './keys' test('happy', () => { expect(keys({ a : 1 })).toEqual([ 'a' ]) })
    Typescript test typescript import {keys} from 'rambda' const obj = {a: 1, b: 2} describe('R.keys', () => { it('happy', () => { const result = keys(obj) result // $ExpectType ("b" | "a")[] }) })
    1 failed Ramda.keys specs > :boom: Reason for the failure: Ramda method works for primitives javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('keys', function() { var obj = {a: 100, b: [1, 2, 3], c: {x: 200, y: 300}, d: 'D', e: null, f: undefined}; function C() { this.a = 100; this.b = 200; } C.prototype.x = function() { return 'x'; }; C.prototype.y = 'y'; var cobj = new C(); it('works for primitives', function() { eq(R.keys(null), []); eq(R.keys(undefined), []); eq(R.keys(55), []); eq(R.keys('foo'), []); eq(R.keys(true), []); eq(R.keys(false), []); eq(R.keys(NaN), []); eq(R.keys(Infinity), []); eq(R.keys([]), []); }); });

    ---------------

    last

    
    last(str: string): string
    

    It returns the last element of input, as the input can be either a string or an array.

    const result = [
      R.last([1, 2, 3]),
      R.last('foo'),
    ]
    // => [3, 'o']
    

    Try this R.last example in Rambda REPL

    All Typescript definitions typescript last(str: string): string; last(emptyList: []): undefined; last<T extends any>(list: readonly T[]): T | undefined;
    R.last source javascript export function last(listOrString){ if (typeof listOrString === 'string'){ return listOrString[ listOrString.length - 1 ] || '' } return listOrString[ listOrString.length - 1 ] }
    Tests javascript import { last } from './last' test('happy', () => { expect(last([ 'foo', 'bar', 'baz' ])).toEqual('baz') expect(last([])).toEqual(undefined) expect(last('abc')).toEqual('c') expect(last('')).toEqual('') })
    Typescript test typescript import {last} from 'rambda' describe('R.last', () => { it('string', () => { const result = last('foo') result // $ExpectType string }) it('array', () => { const result = last([1, 2, 3]) result // $ExpectType number | undefined }) it('empty array', () => { const result = last([]) result // $ExpectType undefined }) })

    ---------------

    lastIndexOf

    
    lastIndexOf<T>(target: T, list: readonly T[]): number
    

    It returns the last index of target in list array.

    R.equals is used to determine equality between target and members of list.

    If there is no such index, then -1 is returned.

    const list = [1, 2, 3, 1, 2, 3]
    const result = [
      R.lastIndexOf(2, list),
      R.lastIndexOf(4, list),
    ]
    // => [4, -1]
    

    Try this R.lastIndexOf example in Rambda REPL

    All Typescript definitions typescript lastIndexOf<T>(target: T, list: readonly T[]): number; lastIndexOf<T>(target: T): (list: readonly T[]) => number;
    R.lastIndexOf source javascript import { equals } from './equals' export function lastIndexOf(target, list){ if (arguments.length === 1) return _list => lastIndexOf(target, _list) let index = list.length while (--index > 0){ if (equals(list[ index ], target)){ return index } } return -1 }
    Tests javascript import { lastIndexOf } from './lastIndexOf' test('happy', () => { const a = lastIndexOf(1, [ 1, 2, 3, 1, 2 ]) const b = lastIndexOf(1)([ 1, 2, 3, 1, 2 ]) expect(a).toEqual(3) expect(b).toEqual(3) }) test('false', () => { const a = lastIndexOf(10, [ 1, 2, 3, 1, 2 ]) expect(a).toEqual(-1) })
    Typescript test typescript import {lastIndexOf} from 'rambda' const list = [1, 2, 3] describe('R.lastIndexOf', () => { it('happy', () => { const result = lastIndexOf(2, list) result // $ExpectType number }) it('curried', () => { const result = lastIndexOf(2)(list) result // $ExpectType number }) })
    3 failed Ramda.lastIndexOf specs > :boom: Reason for the failure: Ramda method dispatches to lastIndexOf method javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('lastIndexOf', function() { var input = [1, 2, 3, 4, 5, 1]; var list = ['a', 1, 'a']; list[-2] = 'a'; // Throw a wrench in the gears by assigning a non-valid array index as object property. it('has R.equals semantics', function() { function Just(x) { this.value = x; } Just.prototype.equals = function(x) { return x instanceof Just && R.equals(x.value, this.value); }; eq(R.lastIndexOf(0, [-0]), -1); eq(R.lastIndexOf(-0, [0]), -1); eq(R.lastIndexOf(NaN, [NaN]), 0); eq(R.lastIndexOf(new Just([42]), [new Just([42])]), 0); }); it('dispatches to `lastIndexOf` method', function() { function Empty() {} Empty.prototype.lastIndexOf = R.always(-1); function List(head, tail) { this.head = head; this.tail = tail; } List.prototype.lastIndexOf = function(x) { var idx = this.tail.lastIndexOf(x); return idx >= 0 ? 1 + idx : this.head === x ? 0 : -1; }; var list = new List('b', new List('a', new List('n', new List('a', new List('n', new List('a', new Empty() ) ) ) ) ) ); eq(R.lastIndexOf('a', 'banana'), 5); eq(R.lastIndexOf('x', 'banana'), -1); eq(R.lastIndexOf('a', list), 5); eq(R.lastIndexOf('x', list), -1); }); it('finds function, compared by identity', function() { var f = function() {}; var g = function() {}; var list = [g, f, g, f]; eq(R.lastIndexOf(f, list), 3); }); });

    ---------------

    length

    
    length<T>(input: readonly T[]): number
    

    It returns the length property of list or string input.

    const result = [
      R.length([1, 2, 3, 4]),
      R.length('foo'),
    ]
    // => [4, 3]
    

    Try this R.length example in Rambda REPL

    All Typescript definitions typescript length<T>(input: readonly T[]): number;
    R.length source javascript export function length(x){ if (!x && x !== '' || x.length === undefined){ return NaN } return x.length }
    Tests javascript import { length } from './length' test('happy', () => { expect(length('foo')).toEqual(3) expect(length([ 1, 2, 3 ])).toEqual(3) expect(length([])).toEqual(0) }) test('with empty string', () => { expect(length('')).toEqual(0) }) test('with bad input returns NaN', () => { expect(length(0)).toBeNaN() expect(length({})).toBeNaN() expect(length(null)).toBeNaN() expect(length(undefined)).toBeNaN() })
    1 failed Ramda.length specs > :boom: Reason for the failure: Ramda method supports object with length method javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('length', function() { it('returns the length of a string', function() { eq(R.length(''), 0); eq(R.length('xyz'), 3); }); it('returns NaN for length property of unexpected type', function() { eq(R.identical(NaN, R.length({length: ''})), true); eq(R.identical(NaN, R.length({length: '1.23'})), true); eq(R.identical(NaN, R.length({length: null})), true); eq(R.identical(NaN, R.length({length: undefined})), true); eq(R.identical(NaN, R.length({})), true); }); });

    ---------------

    lens

    
    lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens
    

    It returns a lens for the given getter and setter functions.

    The getter gets the value of the focus; the setter sets the value of the focus.

    The setter should not mutate the data structure.

    const xLens = R.lens(R.prop('x'), R.assoc('x'));
    
    R.view(xLens, {x: 1, y: 2}) // => 1
    R.set(xLens, 4, {x: 1, y: 2}) // => {x: 4, y: 2}
    R.over(xLens, R.negate, {x: 1, y: 2}) // => {x: -1, y: 2}
    

    Try this R.lens example in Rambda REPL

    All Typescript definitions typescript lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
    R.lens source javascript export function lens(getter, setter){ return function (functor){ return function (target){ return functor(getter(target)).map(focus => setter(focus, target)) } } }
    Typescript test typescript import {lens, assoc} from 'rambda' interface Input { foo: string, } describe('R.lens', () => { it('happy', () => { const fn = lens<Input, string, string>((x: Input) => { x.foo // $ExpectType string return x.foo }, assoc('name')) fn // $ExpectType Lens }) })

    ---------------

    lensIndex

    
    lensIndex(index: number): Lens
    

    It returns a lens that focuses on specified index.

    const list = ['a', 'b', 'c']
    const headLens = R.lensIndex(0)
    
    R.view(headLens, list) // => 'a'
    R.set(headLens, 'x', list) // => ['x', 'b', 'c']
    R.over(headLens, R.toUpper, list) // => ['A', 'b', 'c']
    

    Try this R.lensIndex example in Rambda REPL

    All Typescript definitions typescript lensIndex(index: number): Lens;
    R.lensIndex source javascript import { lens } from './lens' import { nth } from './nth' import { update } from './update' export function lensIndex(index){ return lens(nth(index), update(index)) }
    Tests javascript import { compose } from './compose' import { keys } from './keys' import { lensIndex } from './lensIndex' import { over } from './over' import { set } from './set' import { view } from './view' const testList = [ { a : 1 }, { b : 2 }, { c : 3 } ] test('focuses list element at the specified index', () => { expect(view(lensIndex(0), testList)).toEqual({ a : 1 }) }) test('returns undefined if the specified index does not exist', () => { expect(view(lensIndex(10), testList)).toEqual(undefined) }) test('sets the list value at the specified index', () => { expect(set( lensIndex(0), 0, testList )).toEqual([ 0, { b : 2 }, { c : 3 } ]) }) test('applies function to the value at the specified list index', () => { expect(over( lensIndex(2), keys, testList )).toEqual([ { a : 1 }, { b : 2 }, [ 'c' ] ]) }) test('can be composed', () => { const nestedList = [ 0, [ 10, 11, 12 ], 1, 2 ] const composedLens = compose(lensIndex(1), lensIndex(0)) expect(view(composedLens, nestedList)).toEqual(10) }) test('set s (get s) === s', () => { expect(set( lensIndex(0), view(lensIndex(0), testList), testList )).toEqual(testList) }) test('get (set s v) === v', () => { expect(view(lensIndex(0), set( lensIndex(0), 0, testList ))).toEqual(0) }) test('get (set(set s v1) v2) === v2', () => { expect(view(lensIndex(0), set( lensIndex(0), 11, set( lensIndex(0), 10, testList ) ))).toEqual(11) })
    Typescript test typescript import {view, lensIndex} from 'rambda' interface Input { a: number, } const testList: Input[] = [{a: 1}, {a: 2}, {a: 3}] describe('R.lensIndex', () => { it('happy', () => { const result = view<Input[], Input>(lensIndex(0), testList) result // $ExpectType Input result.a // $ExpectType number }) })

    ---------------

    lensPath

    
    lensPath(path: RamdaPath): Lens
    

    It returns a lens that focuses on specified path.

    const lensPath = R.lensPath(['x', 0, 'y'])
    const input = {x: [{y: 2, z: 3}, {y: 4, z: 5}]}
    
    R.view(lensPath, input) //=> 2
    
    R.set(lensPath, 1, input) 
    //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
    
    R.over(xHeadYLens, R.negate, input) 
    //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}
    

    Try this R.lensPath example in Rambda REPL

    All Typescript definitions typescript lensPath(path: RamdaPath): Lens; lensPath(path: string): Lens;
    R.lensPath source javascript import { assocPath } from './assocPath' import { lens } from './lens' import { path } from './path' export function lensPath(key){ return lens(path(key), assocPath(key)) }
    Tests javascript import { compose } from './compose' import { identity } from './identity' import { inc } from './inc' import { lensPath } from './lensPath' import { lensProp } from './lensProp' import { over } from './over' import { set } from './set' import { view } from './view' const testObj = { a : [ { b : 1 }, { b : 2 } ], d : 3, } test('view', () => { expect(view(lensPath('d'), testObj)).toEqual(3) expect(view(lensPath('a.0.b'), testObj)).toEqual(1) // this is different to ramda, as ramda will return a clone of the input object expect(view(lensPath(''), testObj)).toEqual(undefined) }) test('set', () => { expect(set( lensProp('d'), 0, testObj )).toEqual({ a : [ { b : 1 }, { b : 2 } ], d : 0, }) expect(set( lensPath('a.0.b'), 0, testObj )).toEqual({ a : [ { b : 0 }, { b : 2 } ], d : 3, }) expect(set( lensPath('a.0.X'), 0, testObj )).toEqual({ a : [ { b : 1, X : 0, }, { b : 2 }, ], d : 3, }) expect(set( lensPath([]), 0, testObj )).toEqual(0) }) test('over', () => { expect(over( lensPath('d'), inc, testObj )).toEqual({ a : [ { b : 1 }, { b : 2 } ], d : 4, }) expect(over( lensPath('a.1.b'), inc, testObj )).toEqual({ a : [ { b : 1 }, { b : 3 } ], d : 3, }) expect(over( lensProp('X'), identity, testObj )).toEqual({ a : [ { b : 1 }, { b : 2 } ], d : 3, X : undefined, }) expect(over( lensPath('a.0.X'), identity, testObj )).toEqual({ a : [ { b : 1, X : undefined, }, { b : 2 }, ], d : 3, }) }) test('compose', () => { const composedLens = compose(lensPath('a'), lensPath('1.b')) expect(view(composedLens, testObj)).toEqual(2) }) test('set s (get s) === s', () => { expect(set( lensPath([ 'd' ]), view(lensPath([ 'd' ]), testObj), testObj )).toEqual(testObj) expect(set( lensPath([ 'a', 0, 'b' ]), view(lensPath([ 'a', 0, 'b' ]), testObj), testObj )).toEqual(testObj) }) test('get (set s v) === v', () => { expect(view(lensPath([ 'd' ]), set( lensPath([ 'd' ]), 0, testObj ))).toEqual(0) expect(view(lensPath([ 'a', 0, 'b' ]), set( lensPath([ 'a', 0, 'b' ]), 0, testObj ))).toEqual(0) }) test('get (set(set s v1) v2) === v2', () => { const p = [ 'd' ] const q = [ 'a', 0, 'b' ] expect(view(lensPath(p), set( lensPath(p), 11, set( lensPath(p), 10, testObj ) ))).toEqual(11) expect(view(lensPath(q), set( lensPath(q), 11, set( lensPath(q), 10, testObj ) ))).toEqual(11) })
    Typescript test typescript import {lensPath, view} from 'rambda' interface Input { foo: number[], bar: { a: string, b: string, }, } const testObject: Input = { foo: [1, 2], bar: { a: 'x', b: 'y', }, } const path = lensPath(['bar', 'a']) const pathAsString = lensPath('bar.a') describe('R.lensPath', () => { it('happy', () => { const result = view<Input, string>(path, testObject) result // $ExpectType string }) it('using string as path input', () => { const result = view<Input, string>(pathAsString, testObject) result // $ExpectType string }) })

    ---------------

    lensProp

    
    lensProp(prop: string): {
      <T, U>(obj: T): U
    

    It returns a lens that focuses on specified property prop.

    const xLens = R.lensProp('x');
    const input = {x: 1, y: 2}
    
    R.view(xLens, input) // => 1
    
    R.set(xLens, 4, input) 
    // => {x: 4, y: 2}
    
    R.over(xLens, R.negate, input) 
    // => {x: -1, y: 2}
    

    Try this R.lensProp example in Rambda REPL

    All Typescript definitions typescript lensProp(prop: string): { <T, U>(obj: T): U; set<T, U, V>(val: T, obj: U): V; };
    R.lensProp source javascript import { assoc } from './assoc' import { lens } from './lens' import { prop } from './prop' export function lensProp(key){ return lens(prop(key), assoc(key)) }
    Tests javascript import { compose } from './compose' import { identity } from './identity' import { inc } from './inc' import { lensProp } from './lensProp' import { over } from './over' import { set } from './set' import { view } from './view' const testObj = { a : 1, b : 2, c : 3, } test('focuses object the specified object property', () => { expect(view(lensProp('a'), testObj)).toEqual(1) }) test('returns undefined if the specified property does not exist', () => { expect(view(lensProp('X'), testObj)).toEqual(undefined) }) test('sets the value of the object property specified', () => { expect(set( lensProp('a'), 0, testObj )).toEqual({ a : 0, b : 2, c : 3, }) }) test('adds the property to the object if it doesn\'t exist', () => { expect(set( lensProp('d'), 4, testObj )).toEqual({ a : 1, b : 2, c : 3, d : 4, }) }) test('applies function to the value of the specified object property', () => { expect(over( lensProp('a'), inc, testObj )).toEqual({ a : 2, b : 2, c : 3, }) }) test('applies function to undefined and adds the property if it doesn\'t exist', () => { expect(over( lensProp('X'), identity, testObj )).toEqual({ a : 1, b : 2, c : 3, X : undefined, }) }) test('can be composed', () => { const nestedObj = { a : { b : 1 }, c : 2, } const composedLens = compose(lensProp('a'), lensProp('b')) expect(view(composedLens, nestedObj)).toEqual(1) }) test('set s (get s) === s', () => { expect(set( lensProp('a'), view(lensProp('a'), testObj), testObj )).toEqual(testObj) }) test('get (set s v) === v', () => { expect(view(lensProp('a'), set( lensProp('a'), 0, testObj ))).toEqual(0) }) test('get (set(set s v1) v2) === v2', () => { expect(view(lensProp('a'), set( lensProp('a'), 11, set( lensProp('a'), 10, testObj ) ))).toEqual(11) })
    Typescript test typescript import {lensProp, view} from 'rambda' interface Input { foo: string, } const testObject: Input = { foo: 'Led Zeppelin', } const lens = lensProp('foo') describe('R.lensProp', () => { it('happy', () => { const result = view<Input, string>(lens, testObject) result // $ExpectType string }) })

    ---------------

    map

    
    map<T, U>(fn: MapFunctionObject<T, U>, iterable: Dictionary<T>): Dictionary<U>
    

    It returns the result of looping through iterable with fn.

    It works with both array and object.

    :boom: Unlike Ramda's map, here property and input object are passed as arguments to fn, when iterable is an object.

    const fn = x => x * 2
    const fnWhenObject = (val, prop)=>{
      return `${prop}-${val}`
    }
    
    const iterable = [1, 2]
    const obj = {a: 1, b: 2}
    
    const result = [ 
      R.map(fn, list),
      R.map(fnWhenObject, obj)
    ]
    // => [ [1, 4], {a: 'a-1', b: 'b-2'}]
    

    Try this R.map example in Rambda REPL

    All Typescript definitions typescript map<T, U>(fn: MapFunctionObject<T, U>, iterable: Dictionary<T>): Dictionary<U>; map<T, U>(fn: MapIterator<T, U>, iterable: readonly T[]): U[]; map<T, U>(fn: MapIterator<T, U>): (iterable: readonly T[]) => U[]; map<T, U, S>(fn: MapFunctionObject<T, U>): (iterable: Dictionary<T>) => Dictionary<U>; map<T>(fn: MapIterator<T, T>): (iterable: readonly T[]) => T[]; map<T>(fn: MapIterator<T, T>, iterable: readonly T[]): T[];
    R.map source javascript import { _isArray } from './_internals/_isArray' import { _keys } from './_internals/_keys' export function mapArray( fn, list, isIndexed = false ){ let index = 0 const willReturn = Array(list.length) while (index < list.length){ willReturn[ index ] = isIndexed ? fn(list[ index ], index) : fn(list[ index ]) index++ } return willReturn } export function mapObject(fn, obj){ let index = 0 const keys = _keys(obj) const len = keys.length const willReturn = {} while (index < len){ const key = keys[ index ] willReturn[ key ] = fn( obj[ key ], key, obj ) index++ } return willReturn } export function map(fn, list){ if (arguments.length === 1) return _list => map(fn, _list) if (list === undefined) return [] if (_isArray(list)) return mapArray(fn, list) return mapObject(fn, list) }
    Tests javascript import { map } from './map' const double = x => x * 2 const sampleObject = { a : 1, b : 2, c : 3, d : 4, } test('with array', () => { expect(map(double, [ 1, 2, 3 ])).toEqual([ 2, 4, 6 ]) }) test('with object', () => { const obj = { a : 1, b : 2, } expect(map(double, obj)).toEqual({ a : 2, b : 4, }) }) test('pass input object as third argument', () => { const obj = { a : 1, b : 2, } const iterator = ( val, prop, inputObject ) => { expect(inputObject).toEqual(obj) return val * 2 } expect(map(iterator, obj)).toEqual({ a : 2, b : 4, }) }) test('with object passes property as second argument', () => { map((_, prop) => { expect(typeof prop).toEqual('string') })(sampleObject) }) /** * https://github.com/selfrefactor/rambda/issues/77 */ test('when undefined instead of array', () => { expect(map(double, undefined)).toEqual([]) })
    Typescript test typescript import {map} from 'rambda' describe('R.map with arrays', () => { it('iterable returns the same type as the input', () => { const result = map<number>( (x: number) => { x // $ExpectType number return x + 2 }, [1, 2, 3] ) result // $ExpectType number[] }) it('iterable returns the same type as the input - curried', () => { const result = map<number>((x: number) => { x // $ExpectType number return x + 2 })([1, 2, 3]) result // $ExpectType number[] }) }) describe('R.map with objects', () => { it('iterable with all three arguments - curried', () => { // It requires dummy third typing argument // in order to identify compared to curry typings for arrays // ============================================ const result = map<number, string, any>((a, b, c) => { a // $ExpectType number b // $ExpectType string c // $ExpectType Dictionary<number> return `${a}` })({a: 1, b: 2}) result // $ExpectType Dictionary<string> }) it('iterable with all three arguments', () => { const result = map<number, string>( (a, b, c) => { a // $ExpectType number b // $ExpectType string c // $ExpectType Dictionary<number> return `${a}` }, {a: 1, b: 2} ) result // $ExpectType Dictionary<string> }) it('iterable with property argument', () => { const result = map<number, string>( (a, b) => { a // $ExpectType number b // $ExpectType string return `${a}` }, {a: 1, b: 2} ) result // $ExpectType Dictionary<string> }) it('iterable with no property argument', () => { const result = map<number, string>( a => { a // $ExpectType number return `${a}` }, {a: 1, b: 2} ) result // $ExpectType Dictionary<string> }) })

    ---------------

    match

    
    match(regExpression: RegExp, str: string): string[]
    

    Curried version of String.prototype.match which returns empty array, when there is no match.

    const result = [
      R.match('a', 'foo'),
      R.match(/([a-z]a)/g, 'bananas')
    ]
    // => [[], ['ba', 'na', 'na']]
    

    Try this R.match example in Rambda REPL

    All Typescript definitions typescript match(regExpression: RegExp, str: string): string[]; match(regExpression: RegExp): (str: string) => string[];
    R.match source javascript export function match(pattern, input){ if (arguments.length === 1) return _input => match(pattern, _input) const willReturn = input.match(pattern) return willReturn === null ? [] : willReturn }
    Tests javascript import { equals } from './equals' import { match } from './match' test('happy', () => { expect(match(/a./g)('foo bar baz')).toEqual([ 'ar', 'az' ]) }) test('fallback', () => { expect(match(/a./g)('foo')).toEqual([]) }) test('with string', () => { expect(match('a', 'foo')).toEqual([]) expect(equals(match('o', 'foo'), [ 'o' ])).toBeTrue() }) test('throwing', () => { expect(() => { match(/a./g, null) }).toThrowWithMessage(TypeError, 'Cannot read property \'match\' of null') })
    Typescript test typescript import {match} from 'rambda' const str = 'foo bar' describe('R.match', () => { it('happy', () => { const result = match(/foo/, str) result // $ExpectType string[] }) it('curried', () => { const result = match(/foo/)(str) result // $ExpectType string[] }) })

    ---------------

    mathMod

    
    mathMod(x: number, y: number): number
    

    R.mathMod behaves like the modulo operator should mathematically, unlike the % operator (and by extension, R.modulo). So while -17 % 5 is -2, mathMod(-17, 5) is 3.

    :boom: Explanation is taken from Ramda documentation site.

    const result = [
      R.mathMod(-17, 5),
      R.mathMod(17, 5),
      R.mathMod(17, -5),  
      R.mathMod(17, 0)   
    ]
    // => [3, 2, NaN, NaN]
    

    Try this R.mathMod example in Rambda REPL

    All Typescript definitions typescript mathMod(x: number, y: number): number; mathMod(x: number): (y: number) => number;
    R.mathMod source javascript import _isInteger from './_internals/_isInteger' export function mathMod(x, y){ if (arguments.length === 1) return _y => mathMod(x, _y) if (!_isInteger(x) || !_isInteger(y) || y < 1) return NaN return (x % y + y) % y }
    Tests javascript import { mathMod } from './mathMod' test('happy', () => { expect(mathMod(-17)(5)).toEqual(3) expect(mathMod(17, 5)).toEqual(2) expect(mathMod(17, -5)).toBeNaN() expect(mathMod(17, 0)).toBeNaN() expect(mathMod('17', 5)).toBeNaN() expect(mathMod({}, 2)).toBeNaN() expect(mathMod([], 2)).toBeNaN() expect(mathMod(Symbol(), 2)).toBeNaN() })
    Typescript test typescript import {mathMod} from 'rambda' const first = 1 const second = 2 describe('R.mathMod', () => { it('happy', () => { const result = mathMod(first, second) result // $ExpectType number }) it('curried', () => { const result = mathMod(first, second) result // $ExpectType number }) })

    ---------------

    max

    
    max<T extends Ord>(x: T, y: T): T
    

    It returns the greater value between x and y.

    const result = [
      R.max(5, 7),  
      R.max('bar', 'foo'),  
    ]
    // => [7, 'foo']
    

    Try this R.max example in Rambda REPL

    All Typescript definitions typescript max<T extends Ord>(x: T, y: T): T; max<T extends Ord>(x: T): (y: T) => T;
    R.max source javascript export function max(x, y){ if (arguments.length === 1) return _y => max(x, _y) return y > x ? y : x }
    Tests javascript import { max } from './max' test('with number', () => { expect(max(2, 1)).toBe(2) }) test('with string', () => { expect(max('foo')('bar')).toBe('foo') expect(max('bar')('baz')).toBe('baz') })
    Typescript test typescript import {max} from 'rambda' const first = 1 const second = 2 describe('R.max', () => { it('happy', () => { const result = max(first, second) result // $ExpectType 1 | 2 }) it('curried', () => { const result = max(first, second) result // $ExpectType 1 | 2 }) it('curried - cann pass type', () => { const result = max<number>(first, second) result // $ExpectType number }) it('can pass type', () => { const result = max<number>(first, second) result // $ExpectType number }) })

    ---------------

    maxBy

    
    maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T
    

    It returns the greater value between x and y according to compareFn function.

    const compareFn = Math.abs
    
    R.maxBy(compareFn, 5, -7) // => -7
    

    Try this R.maxBy example in Rambda REPL

    All Typescript definitions typescript maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T; maxBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T; maxBy<T>(compareFn: (input: T) => Ord): FunctionToolbelt.Curry<(x: T, y: T) => T>;
    R.maxBy source javascript import { curry } from './curry' export function maxByFn( compareFn, x, y ){ return compareFn(y) > compareFn(x) ? y : x } export const maxBy = curry(maxByFn)
    Tests javascript import { maxBy } from './maxBy' test('happy', () => { expect(maxBy( Math.abs, -5, 2 )).toEqual(-5) }) test('curried', () => { expect(maxBy(Math.abs)(2, -5)).toEqual(-5) expect(maxBy(Math.abs)(2)(-5)).toEqual(-5) })
    Typescript test typescript import {maxBy} from 'rambda' const compareFn = (x: number) => x % 2 === 0 ? 1 : -1 const first = 1 const second = 2 describe('R.maxBy', () => { it('happy', () => { const result = maxBy(compareFn, first, second) result // $ExpectType 1 | 2 }) it('curried 1', () => { const result = maxBy(compareFn)(first, second) result // $ExpectType number }) it('curried 2', () => { const result = maxBy<number>(compareFn, first)(second) result // $ExpectType number }) it('curried 3', () => { const result = maxBy(compareFn)(first)(second) result // $ExpectType number }) })

    ---------------

    mean

    
    mean(list: readonly number[]): number
    

    It returns the mean value of list input.

    R.mean([ 2, 7 ])
    // => 4.5
    

    Try this R.mean example in Rambda REPL

    All Typescript definitions typescript mean(list: readonly number[]): number;
    R.mean source javascript import { sum } from './sum' export function mean(list){ return sum(list) / list.length }
    Tests javascript import { mean } from './mean' test('happy', () => { expect(mean([ 2, 7 ])).toBe(4.5) }) test('with NaN', () => { expect(mean([])).toBeNaN() })
    Typescript test typescript import {mean} from 'rambda' describe('R.mean', () => { it('happy', () => { const result = mean([1, 2, 3]) result // $ExpectType number }) })

    ---------------

    median

    
    median(list: readonly number[]): number
    

    It returns the median value of list input.

    R.median([ 7, 2, 10, 9 ]) // => 8
    

    Try this R.median example in Rambda REPL

    All Typescript definitions typescript median(list: readonly number[]): number;
    R.median source javascript import { mean } from './mean' export function median(list){ const len = list.length if (len === 0) return NaN const width = 2 - len % 2 const idx = (len - width) / 2 return mean(Array.prototype.slice .call(list, 0) .sort((a, b) => { if (a === b) return 0 return a < b ? -1 : 1 }) .slice(idx, idx + width)) }
    Tests javascript import { median } from './median' test('happy', () => { expect(median([ 2 ])).toEqual(2) expect(median([ 7, 2, 10, 2, 9 ])).toEqual(7) }) test('with empty array', () => { expect(median([])).toBeNaN() })
    Typescript test typescript import {median} from 'rambda' describe('R.median', () => { it('happy', () => { const result = median([1, 2, 3]) result // $ExpectType number }) })

    ---------------

    merge

    
    merge<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>
    

    It creates a copy of target object with overidden newProps properties.

    const target = { 'foo': 0, 'bar': 1 }
    const newProps = { 'foo': 7 }
    
    const result = R.merge(target, newProps)
    // => { 'foo': 7, 'bar': 1 }
    

    Try this R.merge example in Rambda REPL

    All Typescript definitions typescript merge<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>; merge<O1 extends object>(target: O1): <O2 extends object>(newProps: O2) => Merge<O2, O1, 'flat'>;
    R.merge source javascript export function merge(target, newProps){ if (arguments.length === 1) return _newProps => merge(target, _newProps) return Object.assign( {}, target || {}, newProps || {} ) }
    Tests javascript import { merge } from './merge' const obj = { foo : 1, bar : 2, } test('happy', () => { expect(merge(obj, { bar : 20 })).toEqual({ foo : 1, bar : 20, }) }) test('curry', () => { expect(merge(obj)({ baz : 3 })).toEqual({ foo : 1, bar : 2, baz : 3, }) }) /** * https://github.com/selfrefactor/rambda/issues/77 */ test('when undefined or null instead of object', () => { expect(merge(null, undefined)).toEqual({}) expect(merge(obj, null)).toEqual(obj) expect(merge(obj, undefined)).toEqual(obj) expect(merge(undefined, obj)).toEqual(obj) })
    Typescript test typescript import {merge} from 'rambda' describe('R.merge', () => { const result = merge({foo: 1}, {bar: 2}) const curriedResult = merge({foo: 1})({bar: 2}) result.foo // $ExpectType number result.bar // $ExpectType number curriedResult.bar // $ExpectType number })

    ---------------

    mergeAll

    
    mergeAll<T>(list: object[]): T
    

    It merges all objects of list array sequentially and returns the result.

    const list = [
      {a: 1},
      {b: 2},
      {c: 3}
    ]
    const result = R.mergeAll(list)
    const expected = {
      a: 1,
      b: 2,
      c: 3
    }
    // => `result` is equal to `expected`
    

    Try this R.mergeAll example in Rambda REPL

    All Typescript definitions typescript mergeAll<T>(list: object[]): T; mergeAll(list: object[]): object;
    R.mergeAll source javascript import { map } from './map' import { merge } from './merge' export function mergeAll(arr){ let willReturn = {} map(val => { willReturn = merge(willReturn, val) }, arr) return willReturn }
    Tests javascript import { mergeAll } from './mergeAll' test('case 1', () => { const arr = [ { a : 1 }, { b : 2 }, { c : 3 } ] const expectedResult = { a : 1, b : 2, c : 3, } expect(mergeAll(arr)).toEqual(expectedResult) }) test('case 2', () => { expect(mergeAll([ { foo : 1 }, { bar : 2 }, { baz : 3 } ])).toEqual({ foo : 1, bar : 2, baz : 3, }) })
    Typescript test typescript import {mergeAll} from 'rambda' describe('R.mergeAll', () => { it('with passing type', () => { interface Output { foo: number, bar: number, } const result = mergeAll<Output>([{foo: 1}, {bar: 2}]) result.foo // $ExpectType number result.bar // $ExpectType number }) it('without passing type', () => { const result = mergeAll([{foo: 1}, {bar: 2}]) result // $ExpectType unknown }) })

    ---------------

    mergeDeepRight

    
    mergeDeepRight<O1 extends object, O2 extends object>(x: O1, y: O2): Merge<O2, O1, 'deep'>
    

    Creates a new object with the own properties of the first object merged with the own properties of the second object. If a key exists in both objects:

    • and both values are objects, the two values will be recursively merged
    • otherwise the value from the second object will be used.
    All Typescript definitions typescript mergeDeepRight<O1 extends object, O2 extends object>(x: O1, y: O2): Merge<O2, O1, 'deep'>; mergeDeepRight<O1 extends object>(x: O1): <O2 extends object>(y: O2) => Merge<O2, O1, 'deep'>;
    R.mergeDeepRight source javascript import { type } from './type' export function mergeDeepRight(target, source){ if (arguments.length === 1){ return sourceHolder => mergeDeepRight(target, sourceHolder) } const willReturn = JSON.parse(JSON.stringify(target)) Object.keys(source).forEach(key => { if (type(source[ key ]) === 'Object'){ if (type(target[ key ]) === 'Object'){ willReturn[ key ] = mergeDeepRight(target[ key ], source[ key ]) } else { willReturn[ key ] = source[ key ] } } else { willReturn[ key ] = source[ key ] } }) return willReturn }
    Tests javascript // import { mergeDeepRight } from 'ramda' import { mergeDeepRight } from './mergeDeepRight' const slave = { name : 'evilMe', age : 10, contact : { a : 1, email : 'foo@example.com', }, } const master = { age : 40, contact : { email : 'baz@example.com' }, songs : { title : 'Remains the same' }, } test('happy', () => { const result = mergeDeepRight(slave, master) const curryResult = mergeDeepRight(slave)(master) const expected = { age : 40, name : 'evilMe', contact : { a : 1, email : 'baz@example.com', }, songs : { title : 'Remains the same' }, } expect(result).toEqual(expected) expect(curryResult).toEqual(expected) }) test('ramda compatible test 1', () => { const a = { w : 1, x : 2, y : { z : 3 }, } const b = { a : 4, b : 5, c : { d : 6 }, } const result = mergeDeepRight(a, b) const expected = { w : 1, x : 2, y : { z : 3 }, a : 4, b : 5, c : { d : 6 }, } expect(result).toEqual(expected) }) test('ramda compatible test 2', () => { const a = { a : { b : 1, c : 2, }, y : 0, } const b = { a : { b : 3, d : 4, }, z : 0, } const result = mergeDeepRight(a, b) const expected = { a : { b : 3, c : 2, d : 4, }, y : 0, z : 0, } expect(result).toEqual(expected) }) test('ramda compatible test 3', () => { const a = { w : 1, x : { y : 2 }, } const result = mergeDeepRight(a, { x : { y : 3 } }) const expected = { w : 1, x : { y : 3 }, } expect(result).toEqual(expected) })
    Typescript test typescript import {mergeDeepRight} from 'rambda' describe('R.mergeDeepRight', () => { const result = mergeDeepRight({foo: {bar: 1}}, {foo: {bar: 2}}) result.foo.bar // $ExpectType number })

    ---------------

    mergeLeft

    
    mergeLeft<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>
    

    Same as R.merge, but in opposite direction.

    const result = R.mergeLeft(
      {a: 10},
      {a: 1, b: 2}
    )
    // => {a:10, b: 2}
    

    Try this R.mergeLeft example in Rambda REPL

    All Typescript definitions typescript mergeLeft<O1 extends object, O2 extends object>(target: O1, newProps: O2): Merge<O2, O1, 'flat'>; mergeLeft<O1 extends object>(target: O1): <O2 extends object>(newProps: O2) => Merge<O2, O1, 'flat'>;
    R.mergeLeft source javascript import { merge } from './merge' export function mergeLeft(x, y){ if (arguments.length === 1) return _y => mergeLeft(x, _y) return merge(y, x) }
    Tests javascript import { mergeLeft } from './mergeLeft' const obj = { foo : 1, bar : 2, } test('happy', () => { expect(mergeLeft({ bar : 20 }, obj)).toEqual({ foo : 1, bar : 20, }) }) test('curry', () => { expect(mergeLeft({ baz : 3 })(obj)).toEqual({ foo : 1, bar : 2, baz : 3, }) }) test('when undefined or null instead of object', () => { expect(mergeLeft(null, undefined)).toEqual({}) expect(mergeLeft(obj, null)).toEqual(obj) expect(mergeLeft(obj, undefined)).toEqual(obj) expect(mergeLeft(undefined, obj)).toEqual(obj) })
    Typescript test typescript import {mergeLeft} from 'rambda' describe('R.mergeLeft', () => { const result = mergeLeft({foo: 1}, {bar: 2}) const curriedResult = mergeLeft({foo: 1})({bar: 2}) result.foo // $ExpectType number result.bar // $ExpectType number curriedResult.bar // $ExpectType number })

    ---------------

    min

    
    min<T extends Ord>(x: T, y: T): T
    

    It returns the lesser value between x and y.

    const result = [
      R.min(5, 7),  
      R.min('bar', 'foo'),  
    ]
    // => [5, 'bar']
    

    Try this R.min example in Rambda REPL

    All Typescript definitions typescript min<T extends Ord>(x: T, y: T): T; min<T extends Ord>(x: T): (y: T) => T;
    R.min source javascript export function min(x, y){ if (arguments.length === 1) return _y => min(x, _y) return y < x ? y : x }
    Tests javascript import { min } from './min' test('happy', () => { expect(min(2, 1)).toBe(1) expect(min(1)(2)).toBe(1) })
    Typescript test typescript import {min} from 'rambda' const first = 1 const second = 2 describe('R.min', () => { it('happy', () => { const result = min(first, second) result // $ExpectType 1 | 2 }) it('curried', () => { const result = min(first, second) result // $ExpectType 1 | 2 }) it('curried - cann pass type', () => { const result = min<number>(first, second) result // $ExpectType number }) it('can pass type', () => { const result = min<number>(first, second) result // $ExpectType number }) })

    ---------------

    minBy

    
    minBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T
    

    It returns the lesser value between x and y according to compareFn function.

    const compareFn = Math.abs
    
    R.minBy(compareFn, -5, 2) // => -5
    

    Try this R.minBy example in Rambda REPL

    All Typescript definitions typescript minBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T; minBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T; minBy<T>(compareFn: (input: T) => Ord): FunctionToolbelt.Curry<(x: T, y: T) => T>;
    R.minBy source javascript import { curry } from './curry' export function minByFn( compareFn, x, y ){ return compareFn(y) < compareFn(x) ? y : x } export const minBy = curry(minByFn)
    Tests javascript import { minBy } from './minBy' test('happy', () => { expect(minBy( Math.abs, -5, 2 )).toEqual(2) }) test('curried', () => { expect(minBy(Math.abs)(2, -5)).toEqual(2) expect(minBy(Math.abs)(2)(-5)).toEqual(2) })
    Typescript test typescript import {minBy} from 'rambda' const compareFn = (x: number) => x % 2 === 0 ? 1 : -1 const first = 1 const second = 2 describe('R.minBy', () => { it('happy', () => { const result = minBy(compareFn, first, second) result // $ExpectType 1 | 2 }) it('curried 1', () => { const result = minBy(compareFn)(first, second) result // $ExpectType number }) it('curried 2', () => { /* Than should be the case, but passing type is required for some reason */ const result = minBy<number>(compareFn, first)(second) result // $ExpectType number }) it('curried 3', () => { const result = minBy(compareFn)(first)(second) result // $ExpectType number }) })

    ---------------

    modulo

    
    modulo(x: number, y: number): number
    

    Curried version of x%y.

    R.modulo(17, 3) // => 2
    

    Try this R.modulo example in Rambda REPL

    All Typescript definitions typescript modulo(x: number, y: number): number; modulo(x: number): (y: number) => number;
    R.modulo source javascript export function modulo(x, y){ if (arguments.length === 1) return _y => modulo(x, _y) return x % y }
    Tests javascript import { modulo } from './modulo' test('happy', () => { expect(modulo(17, 3)).toEqual(2) expect(modulo(15)(6)).toEqual(3) })
    Typescript test typescript import {modulo} from 'rambda' describe('R.modulo', () => { it('happy', () => { const result = modulo(4, 1) result // $ExpectType number }) it('curried', () => { const result = modulo(4)(1) result // $ExpectType number }) })

    ---------------

    move

    
    move<T>(fromIndex: number, toIndex: number, list: readonly T[]): T[]
    

    It returns a copy of list with exchanged fromIndex and toIndex elements.

    :boom: Rambda.move doesn't support negative indexes - it throws an error.

    const list = [1, 2, 3]
    const result = R.move(0, 1, list)
    // => [2, 1, 3]
    

    Try this R.move example in Rambda REPL

    All Typescript definitions typescript move<T>(fromIndex: number, toIndex: number, list: readonly T[]): T[]; move(fromIndex: number, toIndex: number): <T>(list: readonly T[]) => T[]; move(fromIndex: number): { <T>(toIndex: number, list: readonly T[]): T[]; (toIndex: number): <T>(list: readonly T[]) => T[]; };
    R.move source javascript import { curry } from './curry' function moveFn( fromIndex, toIndex, list ){ if (fromIndex < 0 || toIndex < 0){ throw new Error('Rambda.move does not support negative indexes') } if (fromIndex > list.length - 1 || toIndex > list.length - 1) return list const clone = list.slice() clone[ fromIndex ] = list[ toIndex ] clone[ toIndex ] = list[ fromIndex ] return clone } export const move = curry(moveFn)
    Tests javascript import { move } from './move' const list = [ 1, 2, 3, 4 ] test('happy', () => { const result = move( 0, 1, list ) expect(result).toEqual([ 2, 1, 3, 4 ]) }) test('with negative index', () => { const errorMessage = 'Rambda.move does not support negative indexes' expect(() => move( 0, -1, list )).toThrowWithMessage(Error, errorMessage) expect(() => move( -1, 0, list )).toThrowWithMessage(Error, errorMessage) }) test('when indexes are outside the list outbounds', () => { const result1 = move( 10, 1, list ) const result2 = move( 1, 10, list ) expect(result1).toEqual(list) expect(result2).toEqual(list) })
    Typescript test typescript import {move} from 'rambda' const list = [1, 2, 3] describe('R.move', () => { it('happy', () => { const result = move(0, 1, list) result // $ExpectType number[] }) it('curried 1', () => { const result = move(0, 1)(list) result // $ExpectType number[] }) it('curried 2', () => { const result = move(0)(1)(list) result // $ExpectType number[] }) })

    2 failed Ramda.move specs

    :boom: Reason for the failure: Ramda method does not support negative indexes

    ---------------

    multiply

    
    multiply(x: number, y: number): number
    

    Curried version of x*y.

    R.multiply(2, 4) // => 8
    

    Try this R.multiply example in Rambda REPL

    All Typescript definitions typescript multiply(x: number, y: number): number; multiply(x: number): (y: number) => number;
    R.multiply source javascript export function multiply(x, y){ if (arguments.length === 1) return _y => multiply(x, _y) return x * y }
    Tests javascript import { multiply } from './multiply' test('happy', () => { expect(multiply(2, 4)).toEqual(8) expect(multiply(2)(4)).toEqual(8) })
    Typescript test typescript import {multiply} from 'rambda' describe('R.multiply', () => { it('happy', () => { const result = multiply(4, 1) result // $ExpectType number }) it('curried', () => { const result = multiply(4)(1) result // $ExpectType number }) })

    ---------------

    negate

    
    negate(x: number): number
    
    R.negate(420)// => -420
    

    Try this R.negate example in Rambda REPL

    All Typescript definitions typescript negate(x: number): number;
    R.negate source javascript export function negate(x){ return -x }
    Tests javascript import { negate } from './negate' test('negate', () => { expect(negate(420)).toEqual(-420) expect(negate(-13)).toEqual(13) })

    ---------------

    none

    
    none<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean
    

    It returns true, if all members of array list returns false, when applied as argument to predicate function.

    const list = [ 0, 1, 2, 3, 4 ]
    const predicate = x => x > 6
    
    const result = R.none(predicate, arr)
    // => true
    

    Try this R.none example in Rambda REPL

    All Typescript definitions typescript none<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean; none<T>(predicate: (x: T) => boolean): (list: readonly T[]) => boolean;
    R.none source javascript export function none(predicate, list){ if (arguments.length === 1) return _list => none(predicate, _list) for (let i = 0; i < list.length; i++){ if (!predicate(list[ i ])) return true } return false }
    Tests javascript import { none } from './none' const isEven = n => n % 2 === 0 const isOdd = n => n % 2 === 1 const arr = [ 1, 3, 5, 7, 9, 11 ] test('when true', () => { expect(none(isEven, arr)).toBeTrue() }) test('when false curried', () => { expect(none(isOdd)(arr)).toBeFalse() })
    Typescript test typescript import {none} from 'rambda' describe('R.none', () => { it('happy', () => { const result = none( x => { x // $ExpectType number return x > 0 }, [1, 2, 3] ) result // $ExpectType boolean }) it('curried needs a type', () => { const result = none<number>(x => { x // $ExpectType number return x > 0 })([1, 2, 3]) result // $ExpectType boolean }) })

    ---------------

    not

    
    not(input: any): boolean
    

    It returns a boolean negated version of input.

    R.not(false) // true
    

    Try this R.not example in Rambda REPL

    All Typescript definitions typescript not(input: any): boolean;
    R.not source javascript export function not(input){ return !input }
    Tests javascript import { not } from './not' test('not', () => { expect(not(false)).toEqual(true) expect(not(true)).toEqual(false) expect(not(0)).toEqual(true) expect(not(1)).toEqual(false) })
    Typescript test typescript import {not} from 'rambda' describe('R.not', () => { it('happy', () => { const result = not(4) result // $ExpectType boolean }) })

    ---------------

    nth

    
    nth<T>(index: number, list: readonly T[]): T | undefined
    

    Curried version of list[index].

    const list = [1, 2, 3]
    const str = 'foo'
    
    const result = [
      R.nth(2, list),
      R.nth(6, list),
      R.nth(0, str),
    ]
    // => [3, undefined, 'f']
    

    Try this R.nth example in Rambda REPL

    All Typescript definitions typescript nth<T>(index: number, list: readonly T[]): T | undefined; nth(index: number): <T>(list: readonly T[]) => T | undefined;
    R.nth source javascript export function nth(index, list){ if (arguments.length === 1) return _list => nth(index, _list) const idx = index < 0 ? list.length + index : index return Object.prototype.toString.call(list) === '[object String]' ? list.charAt(idx) : list[ idx ] }
    Tests javascript import { nth } from './nth' test('happy', () => { expect(nth(2, [ 1, 2, 3, 4 ])).toEqual(3) }) test('with curry', () => { expect(nth(2)([ 1, 2, 3, 4 ])).toEqual(3) }) test('with string', () => { expect(nth(2)('foo')).toEqual('o') }) test('with negative index', () => { expect(nth(-3)([ 1, 2, 3, 4 ])).toEqual(2) })
    Typescript test typescript import {nth} from 'rambda' const list = [1, 2, 3] describe('R.nth', () => { it('happy', () => { const result = nth(4, list) result // $ExpectType number | undefined }) it('curried', () => { const result = nth(1)(list) result // $ExpectType number | undefined }) })

    ---------------

    of

    
    of<T>(x: T): T[]
    
    R.of(null); //=> [null]
    R.of([42]); //=> [[42]]
    

    Try this R.of example in Rambda REPL

    All Typescript definitions typescript of<T>(x: T): T[];
    R.of source javascript export function of(value){ return [ value ] }
    Tests javascript import { of } from './of' test('happy', () => { expect(of(3)).toEqual([ 3 ]) expect(of(null)).toEqual([ null ]) })
    Typescript test typescript import {of} from 'ramda' const list = [1, 2, 3] describe('R.of', () => { it('happy', () => { const result = of(4) result // $ExpectType number[] }) it('curried', () => { const result = of(list) result // $ExpectType number[][] }) })

    ---------------

    omit

    
    omit<T, K extends string>(propsToOmit: readonly K[], obj: T): Omit<T, K>
    

    It returns a partial copy of an obj without propsToOmit properties.

    :boom: When using this method with TypeScript, it is much easier to pass propsToOmit as an array. If passing a string, you will need to explicitly declare the output type.

    const obj = {a: 1, b: 2, c: 3}
    const propsToOmit = 'a,c,d'
    const propsToOmitList = ['a', 'c', 'd']
    
    const result = [
      R.omit(propsToOmit, obj), 
      R.omit(propsToOmitList, obj) 
    ]
    // => [{b: 2}, {b: 2}]
    

    Try this R.omit example in Rambda REPL

    All Typescript definitions typescript omit<T, K extends string>(propsToOmit: readonly K[], obj: T): Omit<T, K>; omit<K extends string>(propsToOmit: readonly K[]): <T>(obj: T) => Omit<T, K>; omit<T, U>(propsToOmit: string, obj: T): U; omit<T, U>(propsToOmit: string): (obj: T) => U; omit<T>(propsToOmit: string, obj: object): T; omit<T>(propsToOmit: string): (obj: object) => T;
    R.omit source javascript export function omit(propsToOmit, obj){ if (arguments.length === 1) return _obj => omit(propsToOmit, _obj) if (obj === null || obj === undefined){ return undefined } const propsToOmitValue = typeof propsToOmit === 'string' ? propsToOmit.split(',') : propsToOmit const willReturn = {} for (const key in obj){ if (!propsToOmitValue.includes(key)){ willReturn[ key ] = obj[ key ] } } return willReturn }
    Tests javascript import { omit } from './omit' test('with string as condition', () => { const obj = { a : 1, b : 2, c : 3, } const result = omit('a,c', obj) const resultCurry = omit('a,c')(obj) const expectedResult = { b : 2 } expect(result).toEqual(expectedResult) expect(resultCurry).toEqual(expectedResult) }) test('with null', () => { expect(omit('a,b', null)).toEqual(undefined) }) test('doesn\'t work with number as property', () => { expect(omit([ 42 ], { a : 1, 42 : 2, })).toEqual({ 42 : 2, a : 1, }) }) test('happy', () => { expect(omit([ 'a', 'c' ])({ a : 'foo', b : 'bar', c : 'baz', })).toEqual({ b : 'bar' }) })
    Typescript test typescript import {omit} from 'rambda' describe('R.omit with array as props input', () => { it('allow Typescript to infer object type', () => { const input = {a: 'foo', b: 2, c: 3, d: 4} const result = omit(['b,c'], input) result.a // $ExpectType string result.d // $ExpectType number const curriedResult = omit(['a,c'], input) curriedResult.a // $ExpectType string curriedResult.d // $ExpectType number }) it('declare type of input object', () => { interface Input { a: string, b: number, c: number, d: number, } const input: Input = {a: 'foo', b: 2, c: 3, d: 4} const result = omit(['b,c'], input) result // $ExpectType Pick<Input, "b" | "a" | "c" | "d"> result.a // $ExpectType string result.d // $ExpectType number const curriedResult = omit(['a,c'], input) curriedResult.a // $ExpectType string curriedResult.d // $ExpectType number }) }) describe('R.omit with string as props input', () => { interface Output { b: number, d: number, } it('explicitly declare output', () => { const result = omit<Output>('a,c', {a: 1, b: 2, c: 3, d: 4}) result // $ExpectType Output result.b // $ExpectType number const curriedResult = omit<Output>('a,c')({a: 1, b: 2, c: 3, d: 4}) curriedResult.b // $ExpectType number }) it('explicitly declare input and output', () => { interface Input { a: number, b: number, c: number, d: number, } const result = omit<Input, Output>('a,c', {a: 1, b: 2, c: 3, d: 4}) result // $ExpectType Output result.b // $ExpectType number const curriedResult = omit<Input, Output>('a,c')({ a: 1, b: 2, c: 3, d: 4, }) curriedResult.b // $ExpectType number }) it('without passing type', () => { const result = omit('a,c', {a: 1, b: 2, c: 3, d: 4}) result // $ExpectType unknown }) })

    ---------------

    once

    
    once<T extends (...args: any[]) => any>(func: T): T
    

    It returns a function, which invokes only once fn function.

    let result = 0
    const addOnce = R.once((x) => result = result + x)
    
    addOnce(1)
    addOnce(1)
    // => 1
    

    Try this R.once example in Rambda REPL

    All Typescript definitions typescript once<T extends (...args: any[]) => any>(func: T): T;
    R.once source javascript import { curry } from './curry' function onceFn(fn, context){ let result return function (){ if (fn){ result = fn.apply(context || this, arguments) fn = null } return result } } export function once(fn, context){ if (arguments.length === 1){ const wrap = onceFn(fn, context) return curry(wrap) } return onceFn(fn, context) }
    Tests javascript import { once } from './once' test('with counter', () => { let counter = 0 const runOnce = once(x => { counter++ return x + 2 }) expect(runOnce(1)).toEqual(3) runOnce(1) runOnce(1) runOnce(1) expect(counter).toEqual(1) }) test('happy path', () => { const addOneOnce = once(( a, b, c ) => a + b + c, 1) expect(addOneOnce( 10, 20, 30 )).toBe(60) expect(addOneOnce(40)).toEqual(60) })
    Typescript test typescript import {once} from 'rambda' describe('R.once', () => { it('happy', () => { const runOnce = once((x: number) => { return x + 2 }) const result = runOnce(1) result // $ExpectType number }) })

    1 failed Ramda.once specs

    :boom: Reason for the failure: Ramda method retains arity

    ---------------

    or

    
    or<T, U>(a: T, b: U): T | U
    

    Logical OR

    R.or(false, true); // => true
    R.or(false, false); // => false
    R.or(false, 'foo'); // => 'foo'
    

    Try this R.or example in Rambda REPL

    All Typescript definitions typescript or<T, U>(a: T, b: U): T | U; or<T>(a: T): <U>(b: U) => T | U;
    R.or source javascript export function or(a, b){ if (arguments.length === 1) return _b => or(a, _b) return a || b }
    Tests javascript import { or } from './or' test('happy', () => { expect(or(0, 'foo')).toBe('foo') expect(or(true, true)).toBeTrue() expect(or(false)(true)).toBeTrue() expect(or(false, false)).toBeFalse() })
    Typescript test typescript import {or} from 'ramda' describe('R.or', () => { it('happy', () => { const result = or(true, false) result // $ExpectType boolean }) it('curried', () => { const result = or(1)('foo') result // $ExpectType number | "foo" }) })

    ---------------

    over

    
    over<T>(lens: Lens, fn: Arity1Fn, value: T): T
    

    It returns a copied Object or Array with modified value received by applying function fn to lens focus.

    const headLens = R.lensIndex(0)
    
    R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']) //=> ['FOO', 'bar', 'baz']
    

    Try this R.over example in Rambda REPL

    All Typescript definitions typescript over<T>(lens: Lens, fn: Arity1Fn, value: T): T; over<T>(lens: Lens, fn: Arity1Fn, value: readonly T[]): T[]; over(lens: Lens, fn: Arity1Fn): <T>(value: T) => T; over(lens: Lens, fn: Arity1Fn): <T>(value: readonly T[]) => T[]; over(lens: Lens): <T>(fn: Arity1Fn, value: T) => T; over(lens: Lens): <T>(fn: Arity1Fn, value: readonly T[]) => T[];
    R.over source javascript import { curry } from './curry' const Identity = x => ({ x, map : fn => Identity(fn(x)), }) function overFn( lens, fn, object ){ return lens(x => Identity(fn(x)))(object).x } export const over = curry(overFn)
    Tests javascript import { assoc } from './assoc' import { lens } from './lens' import { lensIndex } from './lensIndex' import { lensPath } from './lensPath' import { over } from './over' import { prop } from './prop' import { toUpper } from './toUpper' const testObject = { foo : 'bar', baz : { a : 'x', b : 'y', }, } test('assoc lens', () => { const assocLens = lens(prop('foo'), assoc('foo')) const result = over( assocLens, toUpper, testObject ) const expected = { ...testObject, foo : 'BAR', } expect(result).toEqual(expected) }) test('path lens', () => { const pathLens = lensPath('baz.a') const result = over( pathLens, toUpper, testObject ) const expected = { ...testObject, baz : { a : 'X', b : 'y', }, } expect(result).toEqual(expected) }) test('index lens', () => { const indexLens = lensIndex(0) const result = over(indexLens, toUpper)(['foo', 'bar']) expect(result).toEqual([ 'FOO', 'bar' ]) })

    ---------------

    partial

    
    partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T
    

    It is very similar to R.curry, but you can pass initial arguments when you create the curried function.

    R.partial will keep returning a function until all the arguments that the function fn expects are passed. The name comes from the fact that you partially inject the inputs.

    :boom: Rambda's partial doesn't need the input arguments to be wrapped as array.

    const fn = (title, firstName, lastName) => {
      return title + ' ' + firstName + ' ' + lastName + '!'
    }
    
    const canPassAnyNumberOfArguments = R.partial(fn, 'Hello')
    const ramdaStyle = R.partial(fn, ['Hello'])
    
    const finalFn = canPassAnyNumberOfArguments('Foo')
    
    finalFn('Bar') // =>  'Hello, Foo Bar!'
    

    Try this R.partial example in Rambda REPL

    All Typescript definitions typescript partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T; partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0, V1]): (x2: V2) => T; partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0]): (x1: V1, x2: V2) => T; partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1, V2]): (x2: V3) => T; partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1]): (x2: V2, x3: V3) => T; partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0]): (x1: V1, x2: V2, x3: V3) => T; partial<T>(fn: (...a: any[]) => T, args: any[]): (...x: any[]) => T;
    R.partial source javascript export function partial(fn, ...args){ const len = fn.length return (...rest) => { if (args.length + rest.length >= len){ return fn(...args, ...rest) } return partial(fn, ...[ ...args, ...rest ]) } }
    Tests javascript import { partial } from './partial' import { type } from './type' const greet = ( salutation, title, firstName, lastName ) => salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!' test('happy', () => { const canPassAnyNumberOfArguments = partial( greet, 'Hello', 'Ms.' ) const fn = canPassAnyNumberOfArguments('foo') const sayHello = partial(greet, [ 'Hello' ]) const sayHelloRamda = partial(sayHello, [ 'Ms.' ]) expect(type(fn)).toBe('Function') expect(fn('bar')).toBe('Hello, Ms. foo bar!') expect(sayHelloRamda('foo', 'bar')).toBe('Hello, Ms. foo bar!') }) test('extra arguments are ignored', () => { const canPassAnyNumberOfArguments = partial( greet, 'Hello', 'Ms.' ) const fn = canPassAnyNumberOfArguments('foo') expect(type(fn)).toBe('Function') expect(fn( 'bar', 1, 2 )).toBe('Hello, Ms. foo bar!') }) test('when array is input', () => { const fooFn = ( a, b, c, d ) => ({ a, b, c, d, }) const barFn = partial( fooFn, [ 1, 2 ], [] ) expect(barFn(1, 2)).toEqual({ a : [ 1, 2 ], b : [], c : 1, d : 2, }) }) test('ramda spec', () => { const sayHello = partial(greet, 'Hello') const sayHelloToMs = partial(sayHello, 'Ms.') expect(sayHelloToMs('Jane', 'Jones')).toBe('Hello, Ms. Jane Jones!') })
    Typescript test typescript import {partial} from 'rambda' describe('R.partial', () => { it('happy', () => { function greet( salutation: string, title: string, firstName: string, lastName: string ) { return `${salutation}, ${title} ${firstName} ${lastName}!` } const sayHello = partial(greet, ['Hello']) const sayHelloToMs = partial(sayHello, ['Ms.']) const result = sayHelloToMs('Jane', 'Jones') result // $ExpectType string }) })

    ---------------

    partition

    
    partition<T>(
      predicate: Predicate<T>,
      input: readonly T[]
    ): [T[], T[]]
    

    It will return array of two objects/arrays according to predicate function. The first member holds all instanses of input that pass the predicate function, while the second member - those who doesn't.

    const list = [1, 2, 3]
    const obj = {a: 1, b: 2, c: 3}
    const predicate = x => x > 2
    
    const result = [
      R.partition(predicate, list),
      R.partition(predicate, obj)
    ]
    const expected = [
      [[3], [1, 2]],
      [{c: 3},  {a: 1, b: 2}],
    ]
    // `result` is equal to `expected`
    

    Try this R.partition example in Rambda REPL

    All Typescript definitions typescript partition<T>( predicate: Predicate<T>, input: readonly T[] ): [T[], T[]]; partition<T>( predicate: Predicate<T> ): (input: readonly T[]) => [T[], T[]]; partition<T>( predicate: (x: T, prop?: string) => boolean, input: { [key: string]: T} ): [{ [key: string]: T}, { [key: string]: T}]; partition<T>( predicate: (x: T, prop?: string) => boolean ): (input: { [key: string]: T}) => [{ [key: string]: T}, { [key: string]: T}];
    R.partition source javascript import { _isArray } from './_internals/_isArray' export function partitionObject(predicate, iterable){ const yes = {} const no = {} Object.entries(iterable).forEach(([ prop, value ]) => { if (predicate(value, prop)){ yes[ prop ] = value } else { no[ prop ] = value } }) return [ yes, no ] } export function partitionArray(predicate, list){ const yes = [] const no = [] let counter = -1 while (counter++ < list.length - 1){ if (predicate(list[ counter ])){ yes.push(list[ counter ]) } else { no.push(list[ counter ]) } } return [ yes, no ] } export function partition(predicate, iterable){ if (arguments.length === 1){ return listHolder => partition(predicate, listHolder) } if (!_isArray(iterable)) return partitionObject(predicate, iterable) return partitionArray(predicate, iterable) }
    Tests javascript import { partition } from './partition' test('with array', () => { const predicate = (x) => { return x > 2 } const list = [ 1, 2, 3, 4 ] const result = partition(predicate, list) const expectedResult = [ [ 3, 4 ], [ 1, 2 ], ] expect(result).toEqual(expectedResult) }) test('with object', () => { const predicate = (value, prop) => { expect(typeof prop).toBe('string') return value > 2 } const hash = { a : 1, b : 2, c : 3, d : 4, } const result = partition(predicate)(hash) const expectedResult = [ { c : 3, d : 4, }, { a : 1, b : 2, }, ] expect(result).toEqual(expectedResult) }) test('readme example', () => { const list = [ 1, 2, 3 ] const obj = { a : 1, b : 2, c : 3, } const predicate = x => x > 2 const result = [ partition(predicate, list), partition(predicate, obj) ] const expected = [ [ [ 3 ], [ 1, 2 ] ], [ { c : 3 }, { a : 1, b : 2, }, ], ] expect(result).toEqual(expected) })
    Typescript test typescript import {partition} from 'rambda' describe('R.partition', () => { it('with array', () => { const predicate = (x: number) => { return x > 2 } const list = [1, 2, 3, 4] const result = partition(predicate, list) const curriedResult = partition(predicate)(list) result // $ExpectType [number[], number[]] curriedResult // $ExpectType [number[], number[]] }) it('with object', () => { const predicate = (value: number, prop?: string) => { return value > 2 } const hash = { a: 1, b: 2, c: 3, d: 4, } const result = partition(predicate, hash) const curriedResult = partition(predicate)(hash) result[0] // $ExpectType { [key: string]: number; } result[1] // $ExpectType { [key: string]: number; } curriedResult[0] // $ExpectType { [key: string]: number; } curriedResult[1] // $ExpectType { [key: string]: number; } }) })

    1 failed Ramda.partition specs

    :boom: Reason for the failure: Ramda library supports fantasy-land

    ---------------

    path

    
    path<Input, T>(pathToSearch: Path, obj: Input): T | undefined
    

    If pathToSearch is 'a.b' then it will return 1 if obj is {a:{b:1}}.

    It will return undefined, if such path is not found.

    :boom: String anotation of pathToSearch is one of the differences between Rambda and Ramda.

    const obj = {a: {b: 1}}
    const pathToSearch = 'a.b'
    const pathToSearchList = ['a', 'b']
    
    const result = [
      R.path(pathToSearch, obj),
      R.path(pathToSearchList, obj),
      R.path('a.b.c.d', obj)
    ]
    // => [1, 1, undefined]
    

    Try this R.path example in Rambda REPL

    All Typescript definitions typescript path<Input, T>(pathToSearch: Path, obj: Input): T | undefined; path<T>(pathToSearch: Path, obj: any): T | undefined; path<T>(pathToSearch: Path): (obj: any) => T | undefined; path<Input, T>(pathToSearch: Path): (obj: Input) => T | undefined;
    R.path source javascript export function path(pathInput, obj){ if (arguments.length === 1) return _obj => path(pathInput, _obj) if (obj === null || obj === undefined){ return undefined } let willReturn = obj let counter = 0 const pathArrValue = typeof pathInput === 'string' ? pathInput.split('.') : pathInput while (counter < pathArrValue.length){ if (willReturn === null || willReturn === undefined){ return undefined } willReturn = willReturn[ pathArrValue[ counter ] ] counter++ } return willReturn }
    Tests javascript import { path } from './path' test('with array inside object', () => { const obj = { a : { b : [ 1, { c : 1 } ] } } expect(path('a.b.1.c', obj)).toBe(1) }) test('works with undefined', () => { const obj = { a : { b : { c : 1 } } } expect(path('a.b.c.d.f', obj)).toBeUndefined() expect(path('foo.babaz', undefined)).toBeUndefined() expect(path('foo.babaz')(undefined)).toBeUndefined() }) test('works with string instead of array', () => { expect(path('foo.bar.baz')({ foo : { bar : { baz : 'yes' } } })).toEqual('yes') }) test('path', () => { expect(path([ 'foo', 'bar', 'baz' ])({ foo : { bar : { baz : 'yes' } } })).toEqual('yes') expect(path([ 'foo', 'bar', 'baz' ])(null)).toBeUndefined() expect(path([ 'foo', 'bar', 'baz' ])({ foo : { bar : 'baz' } })).toBeUndefined() })
    Typescript test typescript import {path} from 'rambda' interface Input { a: number, b: { c: boolean, }, } describe('R.path', () => { it('without specified input type', () => { const input = {a: 1, b: {c: true}} const result = path<boolean>('a.b.c', input) const resultCurried = path<boolean>('a.b.c')(input) result // $ExpectType boolean | undefined resultCurried // $ExpectType boolean | undefined }) it('without specified output type', () => { const input = {a: 1, b: {c: true}} const result = path('a.b.c', input) result // $ExpectType unknown }) it('with string as path', () => { const input: Input = {a: 1, b: {c: true}} const resultA = path<boolean>('a.b.c', input) const resultB = path<boolean>('a.b.c')(input) resultA // $ExpectType boolean | undefined resultB // $ExpectType boolean | undefined }) it('with array as path', () => { const input: Input = {a: 1, b: {c: true}} const resultA = path<boolean>(['a', 'b', 'c'], input) const resultB = path<boolean>(['a', 'b', 'c'])(input) resultA // $ExpectType boolean | undefined resultB // $ExpectType boolean | undefined }) }) describe('path with specified input', () => { it('with string as path', () => { const input: Input = {a: 1, b: {c: true}} // const wrongInput = { a: 1, b: true } // const resultA = path<Input, boolean>('a.b.c', wrongInput) const resultA = path<Input, boolean>('a.b.c', input) const resultB = path<Input, boolean>('a.b.c')(input) resultA // $ExpectType boolean | undefined resultB // $ExpectType boolean | undefined }) it('with array as path', () => { const input: Input = {a: 1, b: {c: true}} const resultA = path<Input, boolean>(['a', 'b', 'c'], input) const resultB = path<Input, boolean>(['a', 'b', 'c'])(input) resultA // $ExpectType boolean | undefined resultB // $ExpectType boolean | undefined }) })
    1 failed Ramda.path specs > :boom: Reason for the failure: Ramda method supports negative indexes javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('path', function() { var deepObject = {a: {b: {c: 'c'}}, falseVal: false, nullVal: null, undefinedVal: undefined, arrayVal: ['arr']}; it('takes a path that contains negative indices into arrays', function() { eq(R.path(['x', -2], {x: ['a', 'b', 'c', 'd']}), 'c'); eq(R.path([-1, 'y'], [{x: 1, y: 99}, {x: 2, y: 98}, {x: 3, y: 97}]), 97); }); });

    ---------------

    pathEq

    
    pathEq(pathToSearch: Path, target: any, input: any): boolean
    

    It returns true if pathToSearch of input object is equal to target value.

    pathToSearch is passed to R.path, which means that it can be either a string or an array. Also equality between target and the found value is determined by R.equals.

    const path = 'a.b'
    const target = {c: 1}
    const input = {a: {b: {c: 1}}}
    
    const result = R.pathEq(
      path,
      target,
      input
    )
    // => true
    

    Try this R.pathEq example in Rambda REPL

    All Typescript definitions typescript pathEq(pathToSearch: Path, target: any, input: any): boolean; pathEq(pathToSearch: Path, target: any): (input: any) => boolean; pathEq(pathToSearch: Path): FunctionToolbelt.Curry<(a: any, b: any) => boolean>;
    R.pathEq source javascript import { curry } from './curry' import { equals } from './equals' import { path } from './path' function pathEqFn( pathToSearch, target, input ){ return equals(path(pathToSearch, input), target) } export const pathEq = curry(pathEqFn)
    Tests javascript import { pathEq } from './pathEq' test('when true', () => { const path = 'a.b' const obj = { a : { b : { c : 1 } } } const target = { c : 1 } expect(pathEq( path, target, obj )).toBeTrue() }) test('when false', () => { const path = 'a.b' const obj = { a : { b : 1 } } const target = 2 expect(pathEq(path, target)(obj)).toBeFalse() }) test('when wrong path', () => { const path = 'foo.bar' const obj = { a : { b : 1 } } const target = 2 expect(pathEq( path, target, obj )).toBeFalse() })
    Typescript test typescript import {pathEq} from 'rambda' describe('R.pathEq', () => { it('with string path', () => { const pathToSearch = 'a.b.c' const input = {a: {b: {c: 1}}} const target = {c: 1} const result = pathEq(pathToSearch, input, target) const curriedResult = pathEq(pathToSearch, input, target) result // $ExpectType boolean curriedResult // $ExpectType boolean }) it('with array path', () => { const pathToSearch = ['a', 'b', 'c'] const input = {a: {b: {c: 1}}} const target = {c: 1} const result = pathEq(pathToSearch, input, target) const curriedResult = pathEq(pathToSearch, input, target) result // $ExpectType boolean curriedResult // $ExpectType boolean }) }) describe('with ramda specs', () => { const testPath = ['x', 0, 'y'] const testObj = { x: [ {y: 2, z: 3}, {y: 4, z: 5}, ], } const result1 = pathEq(testPath, 2, testObj) const result2 = pathEq(testPath, 2)(testObj) const result3 = pathEq(testPath)(2)(testObj) const result4 = pathEq(testPath)(2, testObj) result1 // $ExpectType boolean result2 // $ExpectType boolean result3 // $ExpectType boolean result4 // $ExpectType boolean })

    1 failed Ramda.pathEq specs

    :boom: Reason for the failure: Ramda library supports fantasy-land

    ---------------

    pathOr

    
    pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T
    

    It reads obj input and returns either R.path(pathToSearch, obj) result or defaultValue input.

    const defaultValue = 'DEFAULT_VALUE'
    const pathToSearch = 'a.b'
    const pathToSearchList = ['a', 'b']
    
    const obj = {
      a : {
        b : 1
      }
    }
    
    const result = [
      R.pathOr(DEFAULT_VALUE, pathToSearch, obj) 
      R.pathOr(DEFAULT_VALUE, pathToSearchList, obj) 
      R.pathOr(DEFAULT_VALUE, 'a.b.c', obj) 
    ]
    // => [1, 1, 'DEFAULT_VALUE']
    

    Try this R.pathOr example in Rambda REPL

    All Typescript definitions typescript pathOr<T>(defaultValue: T, pathToSearch: Path, obj: any): T; pathOr<T>(defaultValue: T, pathToSearch: Path): (obj: any) => T; pathOr<T>(defaultValue: T): FunctionToolbelt.Curry<(a: Path, b: any) => T>;
    R.pathOr source javascript import { curry } from './curry' import { defaultTo } from './defaultTo' import { path } from './path' function pathOrFn( defaultValue, list, obj ){ return defaultTo(defaultValue, path(list, obj)) } export const pathOr = curry(pathOrFn)
    Tests javascript import { pathOr } from './pathOr' test('with undefined', () => { const result = pathOr( 'foo', 'x.y', { x : { y : 1 } } ) expect(result).toEqual(1) }) test('with null', () => { const result = pathOr( 'foo', 'x.y', null ) expect(result).toEqual('foo') }) test('with NaN', () => { const result = pathOr( 'foo', 'x.y', NaN ) expect(result).toEqual('foo') }) test('curry case (x)(y)(z)', () => { const result = pathOr('foo')('x.y.z')({ x : { y : { a : 1 } } }) expect(result).toEqual('foo') }) test('curry case (x)(y,z)', () => { const result = pathOr('foo', 'x.y.z')({ x : { y : { a : 1 } } }) expect(result).toEqual('foo') }) test('curry case (x,y)(z)', () => { const result = pathOr('foo')('x.y.z', { x : { y : { a : 1 } } }) expect(result).toEqual('foo') })
    Typescript test typescript import {pathOr} from 'rambda' describe('R.pathOr', () => { it('with string path', () => { const x = pathOr<string>('foo', 'x.y', {x: {y: 'bar'}}) x // $ExpectType string }) it('with array path', () => { const x = pathOr<string>('foo', ['x', 'y'], {x: {y: 'bar'}}) x // $ExpectType string }) it('without passing type looks bad', () => { const x = pathOr('foo', 'x.y', {x: {y: 'bar'}}) x // $ExpectType "foo" }) it('curried', () => { const x = pathOr<string>('foo', 'x.y')({x: {y: 'bar'}}) x // $ExpectType string }) })

    ---------------

    paths

    
    paths<Input, T>(pathsToSearch: Path[], obj: Input): (T | undefined)[]
    

    It loops over members of pathsToSearch as singlePath and returns the array produced by R.path(singlePath, obj).

    Because it calls R.path, then singlePath can be either string or a list.

    const obj = {
      a : {
        b : {
          c : 1,
          d : 2
        }
      }
    }
    
    const result = R.paths([
      'a.b.c',
      'a.b.c.d',
      'a.b.c.d.e',
    ], obj)
    // => [1, 2, undefined]
    

    Try this R.paths example in Rambda REPL

    All Typescript definitions typescript paths<Input, T>(pathsToSearch: Path[], obj: Input): (T | undefined)[]; paths<Input, T>(pathsToSearch: Path[]): (obj: Input) => (T | undefined)[]; paths<T>(pathsToSearch: Path[], obj: any): (T | undefined)[]; paths<T>(pathsToSearch: Path[]): (obj: any) => (T | undefined)[];
    R.paths source javascript import { path } from './path' export function paths(pathsToSearch, obj){ if (arguments.length === 1){ return _obj => paths(pathsToSearch, _obj) } return pathsToSearch.map(singlePath => path(singlePath, obj)) }
    Tests javascript import { paths } from './paths' const obj = { a : { b : { c : 1, d : 2, }, }, p : [ { q : 3 } ], x : { y : 'FOO', z : [ [ {} ] ], }, } test('with string path + curry', () => { const pathsInput = [ 'a.b.d', 'p.q' ] const expected = [ 2, undefined ] const result = paths(pathsInput, obj) const curriedResult = paths(pathsInput)(obj) expect(result).toEqual(expected) expect(curriedResult).toEqual(expected) }) test('with array path', () => { const result = paths([ [ 'a', 'b', 'c' ], [ 'x', 'y' ], ], obj) expect(result).toEqual([ 1, 'FOO' ]) }) test('takes a paths that contains indices into arrays', () => { expect(paths([ [ 'p', 0, 'q' ], [ 'x', 'z', 0, 0 ], ], obj)).toEqual([ 3, {} ]) expect(paths([ [ 'p', 0, 'q' ], [ 'x', 'z', 2, 1 ], ], obj)).toEqual([ 3, undefined ]) }) test('gets a deep property\'s value from objects', () => { expect(paths([ [ 'a', 'b' ] ], obj)).toEqual([ obj.a.b ]) expect(paths([ [ 'p', 0 ] ], obj)).toEqual([ obj.p[ 0 ] ]) }) test('returns undefined for items not found', () => { expect(paths([ [ 'a', 'x', 'y' ] ], obj)).toEqual([ undefined ]) expect(paths([ [ 'p', 2 ] ], obj)).toEqual([ undefined ]) })
    Typescript test typescript import {paths} from 'rambda' interface Input { a: number, b: number, c: number, } const input: Input = {a: 1, b: 2, c: 3} describe('R.paths', () => { it('with dot notation', () => { const result = paths<number>(['a.b.c', 'foo.bar'], input) result // $ExpectType (number | undefined)[] }) it('without type', () => { const result = paths(['a.b.c', 'foo.bar'], input) result // $ExpectType unknown[] }) it('with array as path', () => { const result = paths<number>([['a', 'b', 'c'], ['foo.bar']], input) result // $ExpectType (number | undefined)[] }) it('curried', () => { const result = paths<number>([['a', 'b', 'c'], ['foo.bar']])(input) result // $ExpectType (number | undefined)[] }) })
    1 failed Ramda.paths specs > :boom: Reason for the failure: Ramda method supports negative indexes javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('paths', function() { var obj = { a: { b: { c: 1, d: 2 } }, p: [{q: 3}, 'Hi'], x: { y: 'Alice', z: [[{}]] } }; it('takes a path that contains negative indices into arrays', function() { eq(R.paths([['p', -2, 'q'], ['p', -1]], obj), [3, 'Hi']); eq(R.paths([['p', -4, 'q'], ['x', 'z', -1, 0]], obj), [undefined, {}]); }); });

    ---------------

    pick

    
    pick<T, K extends string | number | symbol>(propsToPick: readonly K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>
    

    It returns a partial copy of an input containing only propsToPick properties.

    input can be either an object or an array.

    String anotation of propsToPick is one of the differences between Rambda and Ramda.

    :boom: When using this method with TypeScript, it is much easier to pass propsToPick as an array. If passing a string, you will need to explicitly declare the output type.

    const obj = {
      a : 1,
      b : false,
      foo: 'cherry'
    }
    const list = [1, 2, 3, 4]
    const propsToPick = 'a,foo'
    const propsToPickList = ['a', 'foo']
    
    const result = [
      R.pick(propsToPick, obj),
      R.pick(propsToPickList, obj),
      R.pick('a,bar', obj),
      R.pick('bar', obj),
      R.pick([0, 3], list),
      R.pick('0,3', list),
    ]
    
    const expected = [
      {a:1, foo: 'cherry'},
      {a:1, foo: 'cherry'},
      {a:1},
      {},
      [1,4],
      [1,4]
    ]
    // => `result` is equal to `expected`
    

    Try this R.pick example in Rambda REPL

    All Typescript definitions typescript pick<T, K extends string | number | symbol>(propsToPick: readonly K[], input: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>; pick<K extends string | number | symbol>(propsToPick: readonly K[]): <T>(input: T) => Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>; pick<T, U>(propsToPick: string, input: T): U; pick<T, U>(propsToPick: string): (input: T) => U; pick<T>(propsToPick: string, input: object): T; pick<T>(propsToPick: string): (input: object) => T;
    R.pick source javascript export function pick(propsToPick, input){ if (arguments.length === 1) return _input => pick(propsToPick, _input) if (input === null || input === undefined){ return undefined } const keys = typeof propsToPick === 'string' ? propsToPick.split(',') : propsToPick const willReturn = {} let counter = 0 while (counter < keys.length){ if (keys[ counter ] in input){ willReturn[ keys[ counter ] ] = input[ keys[ counter ] ] } counter++ } return willReturn }
    Tests javascript import { pick } from './pick' const obj = { a : 1, b : 2, c : 3, } test('props to pick is a string', () => { const result = pick('a,c', obj) const resultCurry = pick('a,c')(obj) const expectedResult = { a : 1, c : 3, } expect(result).toEqual(expectedResult) expect(resultCurry).toEqual(expectedResult) }) test('when prop is missing', () => { const result = pick('a,d,f', obj) expect(result).toEqual({ a : 1 }) }) test('props to pick is an array', () => { expect(pick([ 'a', 'c' ])({ a : 'foo', b : 'bar', c : 'baz', })).toEqual({ a : 'foo', c : 'baz', }) expect(pick([ 'a', 'd', 'e', 'f' ])({ a : 'foo', b : 'bar', c : 'baz', })).toEqual({ a : 'foo' }) expect(pick('a,d,e,f')(null)).toEqual(undefined) }) test('works with list as input and number as props - props to pick is an array', () => { const result = pick([ 1, 2 ], [ 'a', 'b', 'c', 'd' ]) expect(result).toEqual({ 1 : 'b', 2 : 'c', }) }) test('works with list as input and number as props - props to pick is a string', () => { const result = pick('1,2', [ 'a', 'b', 'c', 'd' ]) expect(result).toEqual({ 1 : 'b', 2 : 'c', }) }) test('with symbol', () => { const symbolProp = Symbol('s') expect(pick([ symbolProp ], { [ symbolProp ] : 'a' })).toMatchInlineSnapshot(` Object { Symbol(s): "a", } `) })
    Typescript test typescript import {pick} from 'rambda' const input = {a: 'foo', b: 2, c: 3, d: 4} describe('R.pick with array as props input', () => { it('without passing type', () => { const result = pick(['a', 'c'], input) result.a // $ExpectType string result.c // $ExpectType number }) }) describe('R.pick with string as props input', () => { interface Input { a: string, b: number, c: number, d: number, } interface Output { a: string, c: number, } it('explicitly declare output', () => { const result = pick<Output>('a,c', input) result // $ExpectType Output result.a // $ExpectType string result.c // $ExpectType number const curriedResult = pick<Output>('a,c')(input) curriedResult.a // $ExpectType string }) it('explicitly declare input and output', () => { const result = pick<Input, Output>('a,c', input) result // $ExpectType Output result.a // $ExpectType string const curriedResult = pick<Input, Output>('a,c')(input) curriedResult.a // $ExpectType string }) it('without passing type', () => { const result = pick('a,c', input) result // $ExpectType unknown }) })

    ---------------

    pickAll

    
    pickAll<T, U>(propsToPick: readonly string[], input: T): U
    

    Same as R.pick but it won't skip the missing props, i.e. it will assign them to undefined.

    :boom: When using this method with TypeScript, it is much easier to pass propsToPick as an array. If passing a string, you will need to explicitly declare the output type.

    const obj = {
      a : 1,
      b : false,
      foo: 'cherry'
    }
    const propsToPick = 'a,foo,bar'
    const propsToPickList = ['a', 'foo', 'bar']
    
    const result = [
      R.pickAll(propsToPick, obj),
      R.pickAll(propsToPickList, obj),
      R.pickAll('a,bar', obj),
      R.pickAll('bar', obj),
    ]
    const expected = [
      {a:1, foo: 'cherry', bar: undefined},
      {a:1, foo: 'cherry', bar: undefined},
      {a:1, bar: undefined},
      {bar: undefined}
    ]
    // => `result` is equal to `expected`
    

    Try this R.pickAll example in Rambda REPL

    All Typescript definitions typescript pickAll<T, U>(propsToPick: readonly string[], input: T): U; pickAll<T, U>(propsToPick: readonly string[]): (input: T) => U; pickAll<T, U>(propsToPick: string, input: T): U; pickAll<T, U>(propsToPick: string): (input: T) => U;
    R.pickAll source javascript export function pickAll(propsToPick, obj){ if (arguments.length === 1) return _obj => pickAll(propsToPick, _obj) if (obj === null || obj === undefined){ return undefined } const keysValue = typeof propsToPick === 'string' ? propsToPick.split(',') : propsToPick const willReturn = {} let counter = 0 while (counter < keysValue.length){ if (keysValue[ counter ] in obj){ willReturn[ keysValue[ counter ] ] = obj[ keysValue[ counter ] ] } else { willReturn[ keysValue[ counter ] ] = undefined } counter++ } return willReturn }
    Tests javascript import { pickAll } from './pickAll' test('when input is undefined or null', () => { expect(pickAll('a', null)).toBe(undefined) expect(pickAll('a', undefined)).toBe(undefined) }) test('with string as condition', () => { const obj = { a : 1, b : 2, c : 3, } const result = pickAll('a,c', obj) const resultCurry = pickAll('a,c')(obj) const expectedResult = { a : 1, b : undefined, c : 3, } expect(result).toEqual(expectedResult) expect(resultCurry).toEqual(expectedResult) }) test('with array as condition', () => { expect(pickAll([ 'a', 'b', 'c' ], { a : 'foo', c : 'baz', })).toEqual({ a : 'foo', b : undefined, c : 'baz', }) })
    Typescript test typescript import {pickAll} from 'rambda' interface Input { a: string, b: number, c: number, d: number, } interface Output { a?: string, c?: number, } const input = {a: 'foo', b: 2, c: 3, d: 4} describe('R.pickAll with array as props input', () => { it('without passing type', () => { const result = pickAll(['a', 'c'], input) result // $ExpectType unknown }) it('without passing type + curry', () => { const result = pickAll(['a', 'c'])(input) result // $ExpectType unknown }) it('explicitly passing types', () => { const result = pickAll<Input, Output>(['a', 'c'], input) result.a // $ExpectType string | undefined result.c // $ExpectType number | undefined }) it('explicitly passing types + curry', () => { const result = pickAll<Input, Output>(['a', 'c'])(input) result.a // $ExpectType string | undefined result.c // $ExpectType number | undefined }) }) describe('R.pickAll with string as props input', () => { it('without passing type', () => { const result = pickAll('a,c', input) result // $ExpectType unknown }) it('without passing type + curry', () => { const result = pickAll('a,c')(input) result // $ExpectType unknown }) it('explicitly passing types', () => { const result = pickAll<Input, Output>('a,c', input) result.a // $ExpectType string | undefined result.c // $ExpectType number | undefined }) it('explicitly passing types + curry', () => { const result = pickAll<Input, Output>('a,c')(input) result.a // $ExpectType string | undefined result.c // $ExpectType number | undefined }) })

    ---------------

    pipe

    
    pipe<T1>(fn0: () => T1): () => T1
    

    It performs left-to-right function composition.

    const result = R.pipe(
      R.filter(val => val > 2),
      R.map(a => a * 2)
    )([1, 2, 3, 4])
    
    // => [6, 8]
    

    Try this R.pipe example in Rambda REPL

    All Typescript definitions typescript pipe<T1>(fn0: () => T1): () => T1; pipe<V0, T1>(fn0: (x0: V0) => T1): (x0: V0) => T1; pipe<V0, V1, T1>(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1; pipe<V0, V1, V2, T1>(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1; pipe<T1, T2>(fn0: () => T1, fn1: (x: T1) => T2): () => T2; pipe<V0, T1, T2>(fn0: (x0: V0) => T1, fn1: (x: T1) => T2): (x0: V0) => T2; pipe<V0, V1, T1, T2>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1) => T2; pipe<V0, V1, V2, T1, T2>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1, x2: V2) => T2; pipe<T1, T2, T3>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): () => T3; pipe<V0, T1, T2, T3>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x: V0) => T3; pipe<V0, V1, T1, T2, T3>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1) => T3; pipe<V0, V1, V2, T1, T2, T3>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1, x2: V2) => T3; pipe<T1, T2, T3, T4>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): () => T4; pipe<V0, T1, T2, T3, T4>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x: V0) => T4; pipe<V0, V1, T1, T2, T3, T4>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1) => T4; pipe<V0, V1, V2, T1, T2, T3, T4>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1, x2: V2) => T4; pipe<T1, T2, T3, T4, T5>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): () => T5; pipe<V0, T1, T2, T3, T4, T5>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x: V0) => T5; pipe<V0, V1, T1, T2, T3, T4, T5>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1) => T5; pipe<V0, V1, V2, T1, T2, T3, T4, T5>(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1, x2: V2) => T5; pipe<T1, T2, T3, T4, T5, T6>(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): () => T6; pipe<V0, T1, T2, T3, T4, T5, T6>(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x: V0) => T6; pipe<V0, V1, T1, T2, T3, T4, T5, T6>(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x0: V0, x1: V1) => T6; pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6>( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x0: V0, x1: V1, x2: V2) => T6; pipe<T1, T2, T3, T4, T5, T6, T7>( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn: (x: T6) => T7): () => T7; pipe<V0, T1, T2, T3, T4, T5, T6, T7>( fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn: (x: T6) => T7): (x: V0) => T7; pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7>( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7): (x0: V0, x1: V1) => T7; pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7>( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7): (x0: V0, x1: V1, x2: V2) => T7; pipe<T1, T2, T3, T4, T5, T6, T7, T8>( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn: (x: T7) => T8): () => T8; pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8>( fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn: (x: T7) => T8): (x: V0) => T8; pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8>( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8): (x0: V0, x1: V1) => T8; pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8>( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8): (x0: V0, x1: V1, x2: V2) => T8; pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): () => T9; pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8, T9>( fn0: (x0: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): (x0: V0) => T9; pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8, T9>( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): (x0: V0, x1: V1) => T9; pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8, T9>( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): (x0: V0, x1: V1, x2: V2) => T9; pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): () => T10; pipe<V0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( fn0: (x0: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): (x0: V0) => T10; pipe<V0, V1, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): (x0: V0, x1: V1) => T10; pipe<V0, V1, V2, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): (x0: V0, x1: V1, x2: V2) => T10;
    R.pipe source javascript import { compose } from './compose' export function pipe(...fns){ if (fns.length === 0) throw new Error('pipe requires at least one argument') return compose(...fns.reverse()) }
    Tests javascript import { add, last, map } from '../rambda' import { pipe } from './pipe' test('happy', () => { const list = [ 1, 2, 3 ] const result = pipe( map(add(1)), map(add(10)), last )(list) expect(result).toEqual(14) }) test('with bad input', () => { expect(() => pipe()).toThrowWithMessage(Error, 'pipe requires at least one argument') })
    Typescript test typescript import {add, subtract, pipe} from 'rambda' describe('R.pipe', () => { it('happy', () => { const result = pipe(subtract(11), add(1), add(1))(1) result // $ExpectType number }) it('with void', () => { const result = pipe( () => {}, () => {} )() result // $ExpectType void }) })
    3 failed Ramda.pipe specs > :boom: Reason for the failure: Ramda method passes context to functions | Rambda composed functions have no length javascript var assert = require('assert'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('pipe', function() { it('performs left-to-right function composition', function() { // f :: (String, Number?) -> ([Number] -> [Number]) var f = R.pipe(parseInt, R.multiply, R.map); eq(f.length, 2); eq(f('10')([1, 2, 3]), [10, 20, 30]); eq(f('10', 2)([1, 2, 3]), [2, 4, 6]); }); it('passes context to functions', function() { function x(val) { return this.x * val; } function y(val) { return this.y * val; } function z(val) { return this.z * val; } var context = { a: R.pipe(x, y, z), x: 4, y: 2, z: 1 }; eq(context.a(5), 40); }); it('can be applied to one argument', function() { var f = function(a, b, c) { return [a, b, c]; }; var g = R.pipe(f); eq(g.length, 3); eq(g(1, 2, 3), [1, 2, 3]); }); });

    ---------------

    pluck

    
    pluck<K extends keyof T, T>(property: K, list: readonly T[]): Array<T[K]>
    

    It returns list of the values of property taken from the all objects inside list.

    const list = [{a: 1}, {a: 2}, {b: 3}]
    const property = 'a'
    
    R.pluck(list, property) 
    // => [1, 2]
    

    Try this R.pluck example in Rambda REPL

    All Typescript definitions typescript pluck<K extends keyof T, T>(property: K, list: readonly T[]): Array<T[K]>; pluck<T>(property: number, list: ReadonlyArray<{ [k: number]: T }>): T[]; pluck<P extends string>(property: P): <T>(list: ReadonlyArray<Record<P, T>>) => T[]; pluck(property: number): <T>(list: ReadonlyArray<{ [k: number]: T }>) => T[];
    R.pluck source javascript import { map } from './map' export function pluck(property, list){ if (arguments.length === 1) return _list => pluck(property, _list) const willReturn = [] map(x => { if (x[ property ] !== undefined){ willReturn.push(x[ property ]) } }, list) return willReturn }
    Tests javascript import { pluck } from './pluck' test('happy', () => { expect(pluck('a')([ { a : 1 }, { a : 2 }, { b : 1 } ])).toEqual([ 1, 2 ]) }) test('with number', () => { const input = [ [ 1, 2 ], [ 3, 4 ], ] expect(pluck(0, input)).toEqual([ 1, 3 ]) })
    Typescript test typescript import {pluck} from 'rambda' describe('R.pluck', () => { it('with object', () => { interface ListMember { a: number, b: string, } const input: ListMember[] = [ {a: 1, b: 'foo'}, {a: 2, b: 'bar'}, ] const resultA = pluck('a', input) const resultB = pluck('b')(input) resultA // $ExpectType number[] resultB // $ExpectType string[] }) it('with array', () => { const input = [ [1, 2], [3, 4], [5, 6], ] const result = pluck(0, input) const resultCurry = pluck(0)(input) result // $ExpectType number[] resultCurry // $ExpectType number[] }) })
    1 failed Ramda.pluck specs > :boom: Reason for the failure: Ramda method behaves as a transducer javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('pluck', function() { var people = [ {name: 'Fred', age: 23}, {name: 'Wilma', age: 21}, {name: 'Pebbles', age: 2} ]; it('behaves as a transducer when given a transducer in list position', function() { var numbers = [{a: 1}, {a: 2}, {a: 3}, {a: 4}]; var transducer = R.compose(R.pluck('a'), R.map(R.add(1)), R.take(2)); eq(R.transduce(transducer, R.flip(R.append), [], numbers), [2, 3]); }); });

    ---------------

    prepend

    
    prepend<T>(x: T, input: T[]): T[]
    

    It adds element x at the beginning of list.

    const result = R.prepend('foo', ['bar', 'baz'])
    // => ['foo', 'bar', 'baz']
    

    Try this R.prepend example in Rambda REPL

    All Typescript definitions typescript prepend<T>(x: T, input: T[]): T[]; prepend<T>(x: T): (input: T[]) => T[];
    R.prepend source javascript export function prepend(x, input){ if (arguments.length === 1) return _input => prepend(x, _input) if (typeof input === 'string') return [ x ].concat(input.split('')) return [ x ].concat(input) }
    Tests javascript import { prepend } from './prepend' test('happy', () => { expect(prepend('yes', [ 'foo', 'bar', 'baz' ])).toEqual([ 'yes', 'foo', 'bar', 'baz', ]) }) test('with empty list', () => { expect(prepend('foo')([])).toEqual([ 'foo' ]) }) test('with string instead of array', () => { expect(prepend('foo')('bar')).toEqual([ 'foo', 'b', 'a', 'r' ]) })
    Typescript test typescript import {prepend} from 'rambda' const list = [1, 2, 3] describe('R.prepend', () => { it('happy', () => { const result = prepend(4, list) result // $ExpectType number[] }) it('curried', () => { const result = prepend(4)(list) result // $ExpectType number[] }) })

    ---------------

    product

    
    product(list: readonly number[]): number
    
    R.product([ 2, 3, 4 ])
    // => 24)
    

    Try this R.product example in Rambda REPL

    All Typescript definitions typescript product(list: readonly number[]): number;
    R.product source javascript import { multiply } from './multiply' import { reduce } from './reduce' export const product = reduce(multiply, 1)
    Tests javascript import { product } from './product' test('happy', () => { expect(product([ 2, 3, 4 ])).toEqual(24) }) test('bad input', () => { expect(product([ null ])).toEqual(0) expect(product([])).toEqual(1) })
    Typescript test typescript import {product} from 'rambda' describe('R.product', () => { it('happy', () => { const result = product([1, 2, 3]) result // $ExpectType number }) })

    ---------------

    prop

    
    prop<P extends keyof T, T>(propToFind: P, obj: T): T[P]
    

    It returns the value of property propToFind in obj.

    If there is no such property, it returns undefined.

    const result = [
      R.prop('x', {x: 100}), 
      R.prop('x', {a: 1}) 
    ]
    // => [100, undefined]
    

    Try this R.prop example in Rambda REPL

    All Typescript definitions typescript prop<P extends keyof T, T>(propToFind: P, obj: T): T[P]; prop<P extends string>(p: P): <T>(propToFind: Record<P, T>) => T; prop<P extends string, T>(p: P): (propToFind: Record<P, T>) => T;
    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) })
    Typescript test typescript import {prop} from 'rambda' const obj = {a: 1, b: 'foo'} describe('R.prop', () => { it('happy', () => { const result = prop('a', obj) result // $ExpectType number }) it('curried', () => { const result = prop('b')(obj) result // $ExpectType string }) })

    ---------------

    propEq

    
    propEq<T, K extends keyof T>(propToFind: K, valueToMatch: T[K], obj: T): boolean
    

    It returns true if obj has property propToFind and its value is equal to valueToMatch.

    const obj = { foo: 'bar' }
    const secondObj = { foo: 1 }
    
    const propToFind = 'foo'
    const valueToMatch = 'bar'
    
    const result = [
      R.propEq(propToFind, valueToMatch, obj),
      R.propEq(propToFind, valueToMatch, secondObj)
    ]
    // => [true, false]
    

    Try this R.propEq example in Rambda REPL

    All Typescript definitions typescript propEq<T, K extends keyof T>(propToFind: K, valueToMatch: T[K], obj: T): boolean; propEq<T, K extends keyof T>(propToFind: K, valueToMatch: T[K]): (obj: T) => boolean; propEq<T, K extends keyof T>(propToFind: K): { (valueToMatch: T[K], obj: T): boolean; (valueToMatch: T[K]): (obj: T) => boolean; };
    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() })
    Typescript test typescript import {propEq} from 'rambda' const property = 'foo' const numberProperty = 1 const value = 'bar' const obj = {[property]: value} const objWithNumberIndex = {[numberProperty]: value} describe('R.propEq', () => { it('happy', () => { const result = propEq(property, value, obj) result // $ExpectType boolean }) it('number is property', () => { const result = propEq(1, value, objWithNumberIndex) result // $ExpectType boolean }) it('with optional property', () => { interface MyType { optional?: string | number, } const myObject: MyType = {} const valueToFind = '1111' const optionalValueToFind: string | number | undefined = '1111' const result = propEq('optional', valueToFind, myObject) const result2 = propEq('optional', optionalValueToFind, myObject) result // $ExpectType boolean result2 // $ExpectType boolean }) })
    1 failed Ramda.propEq specs > :boom: Reason for the failure: Ramda method pass to equals method if available javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('propEq', function() { var obj1 = {name: 'Abby', age: 7, hair: 'blond'}; var obj2 = {name: 'Fred', age: 12, hair: 'brown'}; it('handles number as property', function() { var deities = ['Cthulhu', 'Dagon', 'Yog-Sothoth']; eq(R.propEq(0, 'Cthulhu', deities), true); eq(R.propEq(1, 'Dagon', deities), true); eq(R.propEq(2, 'Yog-Sothoth', deities), true); eq(R.propEq(-1, 'Yog-Sothoth', deities), true); eq(R.propEq(3, undefined, deities), true); }); it('has R.equals semantics', function() { function Just(x) { this.value = x; } Just.prototype.equals = function(x) { return x instanceof Just && R.equals(x.value, this.value); }; eq(R.propEq('value', 0, {value: -0}), false); eq(R.propEq('value', -0, {value: 0}), false); eq(R.propEq('value', NaN, {value: NaN}), true); eq(R.propEq('value', new Just([42]), {value: new Just([42])}), true); }); });

    ---------------

    propIs

    
    propIs(type: any, name: string, obj: any): boolean
    

    It returns true if property of obj is from target type.

    const obj = {a:1, b: 'foo'}
    const property = 'foo'
    
    const result = [
      R.propIs(String, property, obj),
      R.propIs(Number, property, obj)
    ]
    // => [true, false]
    

    Try this R.propIs example in Rambda REPL

    All Typescript definitions typescript propIs(type: any, name: string, obj: any): boolean; propIs(type: any, name: string): (obj: any) => boolean; propIs(type: any): { (name: string, obj: any): boolean; (name: string): (obj: any) => boolean; };
    R.propIs source javascript import { curry } from './curry' import { is } from './is' function propIsFn( targetPrototype, property, obj ){ return is(targetPrototype, obj[ property ]) } export const propIs = curry(propIsFn)
    Tests javascript import { propIs } from './propIs' const obj = { value : 1 } const property = 'value' test('when true', () => { expect(propIs( Number, property, obj )).toBeTrue() }) test('when false', () => { expect(propIs( String, property, obj )).toBeFalse() expect(propIs( String, property, {} )).toBeFalse() })
    Typescript test typescript import {propIs} from 'rambda' const property = 'a' const obj = {a: 1} describe('R.propIs', () => { it('happy', () => { const result = propIs(Number, property, obj) result // $ExpectType boolean }) it('curried', () => { const result = propIs(Number, property)(obj) result // $ExpectType boolean }) })

    ---------------

    propOr

    
    propOr<T>(defaultValue: T, property: string, obj: { [key: string]: T}): T
    

    It returns either defaultValue or the value of property in obj.

    const obj = {a: 1}
    const defaultValue = 'DEFAULT_VALUE'
    const property = 'a'
    
    const result = [
      R.propOr(defaultValue, property, obj),
      R.propOr(defaultValue, 'foo', obj)
    ]
    // => [1, 'DEFAULT_VALUE']
    

    Try this R.propOr example in Rambda REPL

    All Typescript definitions typescript propOr<T>(defaultValue: T, property: string, obj: { [key: string]: T}): T; propOr<T>(defaultValue: T, property: string): (obj: { [key: string]: T}) => T; propOr<T>(defaultValue: T): FunctionToolbelt.Curry<(property: string, obj: { [key: string]: T}) => T>;
    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') })
    Typescript test typescript import {propOr} from 'rambda' const obj = {foo: 'bar'} const property = 'foo' const fallback = 'fallback' describe('R.propOr', () => { it('happy', () => { const result = propOr(fallback, property, obj) result // $ExpectType string }) it('curry 1', () => { const result = propOr(fallback)(property, obj) result // $ExpectType string }) it('curry 2', () => { const result = propOr(fallback, property)(obj) result // $ExpectType string }) it('curry 3', () => { const result = propOr(fallback)(property)(obj) result // $ExpectType string }) })

    ---------------

    props

    
    props<P extends string, T>(propsToPick: P[], obj: Record<P, T>): T[]
    

    It takes list with properties propsToPick and returns a list with property values in obj.

    const result = [
      R.props(['a', 'b'], {a:1, c:3})
    // => [1, undefined]
    

    Try this R.props example in Rambda REPL

    All Typescript definitions typescript props<P extends string, T>(propsToPick: P[], obj: Record<P, T>): T[]; props<P extends string>(propsToPick: P[]): <T>(obj: Record<P, T>) => T[]; props<P extends string, T>(propsToPick: P[]): (obj: Record<P, T>) => T[];
    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 ]) })
    Typescript test typescript import {props} from 'rambda' const obj = {a: 1, b: 2} describe('R.props', () => { it('happy', () => { const result = props(['a', 'b'], obj) result // $ExpectType number[] }) it('curried', () => { const result = props(['a', 'b'])(obj) result // $ExpectType number[] }) })

    ---------------

    range

    
    range(startInclusive: number, endExclusive: number): number[]
    

    It returns list of numbers between startInclusive to endExclusive markers.

    R.range(0, 5)
    // => [0, 1, 2, 3, 4]
    

    Try this R.range example in Rambda REPL

    All Typescript definitions typescript range(startInclusive: number, endExclusive: number): number[]; range(startInclusive: number): (endExclusive: number) => number[];
    R.range source javascript export function range(start, end){ if (arguments.length === 1) return _end => range(start, _end) if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){ throw new TypeError('Both arguments to range must be numbers') } if (end < start) return [] const len = end - start const willReturn = Array(len) for (let i = 0; i < len; i++){ willReturn[ i ] = start + i } return willReturn }
    Tests javascript import { range } from './range' test('happy', () => { expect(range(0, 10)).toEqual([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]) }) test('end range is bigger than start range', () => { expect(range(7, 3)).toEqual([]) expect(range(5, 5)).toEqual([]) }) test('with bad input', () => { const throwMessage = 'Both arguments to range must be numbers' expect(() => range('a', 6)).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 ]) })
    Typescript test typescript import {range} from 'rambda' describe('R.range', () => { it('happy', () => { const result = range(1, 4) result // $ExpectType number[] }) it('curried', () => { const result = range(1)(4) result // $ExpectType number[] }) })

    ---------------

    reduce

    
    reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: readonly T[]): TResult
    

    :boom: It passes index of the list as third argument to reducer function.

    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

    All Typescript definitions typescript reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: readonly T[]): TResult; reduce<T, TResult>(reducer: (prev: TResult, current: T) => TResult, initialValue: TResult, list: readonly T[]): TResult; reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult): (initialValue: TResult, list: readonly T[]) => TResult; reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult, initialValue: TResult): (list: readonly T[]) => TResult;
    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') })
    Typescript test typescript import {reduce} from 'rambda' describe('R.reduce', () => { it('happy', () => { const result = reduce<number, number>( (acc, elem) => { acc // $ExpectType number elem // $ExpectType number return acc + elem }, 1, [1, 2, 3] ) result // $ExpectType number }) it('with two types', () => { const result = reduce<number, string>( (acc, elem) => { acc // $ExpectType string elem // $ExpectType number return `${acc}${elem}` }, 'foo', [1, 2, 3] ) result // $ExpectType string }) it('with index', () => { const result = reduce<number, number>( (acc, elem, i) => { acc // $ExpectType number elem // $ExpectType number i // $ExpectType number return acc + elem }, 1, [1, 2, 3] ) result // $ExpectType number }) it('fallback', () => { const result = reduce( (acc, val) => { acc // $ExpectType number return acc + val }, 1, [1, 2, 3] ) result // $ExpectType number }) it('fallback with index', () => { const result = reduce( (acc, val, i) => { acc // $ExpectType number i // $ExpectType number return acc + val }, 1, [1, 2, 3] ) result // $ExpectType number }) it('fallback with two types', () => { const result = reduce( (acc, val) => { acc // $ExpectType string return acc + val }, 'foo', [1, 2, 3] ) result // $ExpectType string }) })
    2 failed Ramda.reduce specs > :boom: Reason for the failure: Rambda library doesn't have R.reduced method | Ramda method pass to reduce method javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('reduce', function() { var add = function(a, b) {return a + b;}; var mult = function(a, b) {return a * b;}; it('Prefers the use of the iterator of an object over reduce (and handles short-circuits)', function() { var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator'; function Reducible(arr) { this.arr = arr; } Reducible.prototype.reduce = function(f, init) { var acc = init; for (var i = 0; i < this.arr.length; i += 1) { acc = f(acc, this.arr[i]); } return acc; }; Reducible.prototype[symIterator] = function() { var a = this.arr; return { _pos: 0, next: function() { if (this._pos < a.length) { var v = a[this._pos]; this._pos += 1; return { value: v, done: false }; } else { return { done: true }; } } }; }; var xf = R.take(2); var apendingT = { }; apendingT['@@transducer/result'] = R.identity; apendingT['@@transducer/step'] = R.flip(R.append); var rfn = xf(apendingT); var list = new Reducible([1, 2, 3, 4, 5, 6]); eq(R.reduce(rfn, [], list), [1, 2]); }); it('short circuits with reduced', function() { var addWithMaxOf10 = function(acc, val) {return acc + val > 10 ? R.reduced(acc) : acc + val;}; eq(R.reduce(addWithMaxOf10, 0, [1, 2, 3, 4]), 10); eq(R.reduce(addWithMaxOf10, 0, [2, 4, 6, 8]), 6); }); });

    ---------------

    reject

    
    reject<T>(predicate: FilterFunctionArray<T>, list: readonly T[]): T[]
    

    It has the opposite effect of R.filter.

    const list = [1, 2, 3, 4]
    const obj = {a: 1, b: 2}
    const predicate = x => x > 1
    
    const result = [
      R.reject(predicate, list)
      R.reject(predicate, obj)
    ]
    // => [[1, 2], {a: 1}]
    

    Try this R.reject example in Rambda REPL

    All Typescript definitions typescript reject<T>(predicate: FilterFunctionArray<T>, list: readonly T[]): T[]; reject<T>(predicate: FilterFunctionArray<T>): (list: readonly T[]) => T[]; reject<T>(predicate: FilterFunctionArray<T>, obj: Dictionary<T>): Dictionary<T>; reject<T, U>(predicate: FilterFunctionArray<T>): (obj: Dictionary<T>) => Dictionary<T>;
    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, }) })
    Typescript test typescript import {reject} from 'rambda' describe('R.reject with array', () => { it('happy', () => { const result = reject( x => { x // $ExpectType number return x > 1 }, [1, 2, 3] ) result // $ExpectType number[] }) it('curried require explicit type', () => { const result = reject<number>(x => { x // $ExpectType number return x > 1 })([1, 2, 3]) result // $ExpectType number[] }) }) describe('R.reject with objects', () => { it('happy', () => { const result = reject( x => { x // $ExpectType number return x > 1 }, {a: 1, b: 2} ) result // $ExpectType Dictionary<number> }) it('curried require dummy type', () => { const result = reject<number, any>(x => { return x > 1 })({a: 1, b: 2}) result // $ExpectType Dictionary<number> }) })
    1 failed Ramda.reject specs > :boom: Reason for the failure: Ramda method dispatches to filter method javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('reject', function() { var even = function(x) {return x % 2 === 0;}; it('dispatches to `filter` method', function() { function Nothing() {} Nothing.value = new Nothing(); Nothing.prototype.filter = function() { return this; }; function Just(x) { this.value = x; } Just.prototype.filter = function(pred) { return pred(this.value) ? this : Nothing.value; }; var m = new Just(42); eq(R.filter(R.T, m), m); eq(R.filter(R.F, m), Nothing.value); eq(R.reject(R.T, m), Nothing.value); eq(R.reject(R.F, m), m); }); });

    ---------------

    repeat

    
    repeat<T>(x: T): (timesToRepeat: number) => T[]
    
    R.repeat('foo', 3)
    // => ['foo', 'foo', 'foo']
    

    Try this R.repeat example in Rambda REPL

    All Typescript definitions typescript repeat<T>(x: T): (timesToRepeat: number) => T[]; repeat<T>(x: T, timesToRepeat: number): T[];
    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() })
    Typescript test typescript import {repeat} from 'rambda' describe('R.repeat', () => { it('happy', () => { const result = repeat(4, 7) result // $ExpectType number[] }) it('curried', () => { const result = repeat(4)(7) result // $ExpectType number[] }) })

    ---------------

    replace

    
    replace(strOrRegex: RegExp | string, replacer: string, str: string): string
    

    It replaces strOrRegex found in str with replacer.

    const strOrRegex = /o/g
    
    const result = R.replace(strOrRegex, '|0|', 'foo')
    // => 'f|0||0|'
    

    Try this R.replace example in Rambda REPL

    All Typescript definitions typescript replace(strOrRegex: RegExp | string, replacer: string, str: string): string; replace(strOrRegex: RegExp | string, replacer: string): (str: string) => string; replace(strOrRegex: RegExp | string): (replacer: string) => (str: string) => string;
    R.replace source javascript 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') })
    Typescript test typescript import {replace} from 'rambda' const str = 'foo bar foo' const replacer = 'bar' describe('R.replace', () => { it('happy', () => { const result = replace(/foo/g, replacer, str) result // $ExpectType string }) it('with string as search pattern', () => { const result = replace('foo', replacer, str) result // $ExpectType string }) }) describe('R.replace - curried', () => { it('happy', () => { const result = replace(/foo/g, replacer)(str) result // $ExpectType string }) it('with string as search pattern', () => { const result = replace('foo', replacer)(str) result // $ExpectType string }) })

    ---------------

    reverse

    
    reverse<T>(input: readonly T[]): T[]
    

    It returns a reversed copy of list or string input.

    const result = [
      R.reverse('foo'),
      R.reverse([1, 2, 3])
    ]
    // => ['oof', [3, 2, 1]
    

    Try this R.reverse example in Rambda REPL

    All Typescript definitions typescript reverse<T>(input: readonly T[]): T[]; reverse(input: string): string;
    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 ]) })
    Typescript test typescript import {reverse} from 'rambda' const list = [1, 2, 3, 4, 5] describe('R.reverse', () => { it('happy', () => { const result = reverse(list) result // $ExpectType number[] }) })

    ---------------

    set

    
    set<T, U>(lens: Lens, replacer: U, obj: T): T
    

    It returns a copied Object or Array with modified lens focus set to replacer value.

    const input = {x: 1, y: 2}
    const xLens = R.lensProp('x')
    
    R.set(xLens, 4, input) //=> {x: 4, y: 2}
    R.set(xLens, 8, input) //=> {x: 8, y: 2}
    

    Try this R.set example in Rambda REPL

    All Typescript definitions typescript set<T, U>(lens: Lens, replacer: U, obj: T): T; set<U>(lens: Lens, replacer: U): <T>(obj: T) => T; set(lens: Lens): <T, U>(replacer: U, obj: T) => T;
    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 ]) })

    ---------------

    slice

    
    slice(from: number, to: number, input: string): string
    
    const list = [0, 1, 2, 3, 4, 5]
    const str = 'FOO_BAR'
    const from = 1
    const to = 4
    
    const result = [
      R.slice(str, to, list),
      R.slice(from, to, list)
    ]
    // => ['OO_', [1, 2, 3]]
    

    Try this R.slice example in Rambda REPL

    All Typescript definitions typescript slice(from: number, to: number, input: string): string; slice<T>(from: number, to: number, input: readonly T[]): T[]; slice(from: number, to: number): { (input: string): string; <T>(input: readonly T[]): T[]; }; slice(from: number): { (to: number, input: string): string; <T>(to: number, input: readonly T[]): T[]; };
    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') })
    Typescript test typescript import {slice} from 'rambda' const list = [1, 2, 3, 4, 5] describe('R.slice', () => { it('happy', () => { const result = slice(1, 3, list) result // $ExpectType number[] }) it('curried', () => { const result = slice(1, 3)(list) result // $ExpectType number[] }) })

    ---------------

    sort

    
    sort<T>(sortFn: (a: T, b: T) => number, list: readonly T[]): T[]
    

    It returns copy of list sorted by sortFn function.

    :boom: sortFn function must return a number.

    const list = [
      {a: 2},
      {a: 3},
      {a: 1}
    ]
    const sortFn = (x, y) => {
      return x.a > y.a ? 1 : -1
    }
    
    const result = R.sort(sortFn, list)
    const expected = [
      {a: 1},
      {a: 2},
      {a: 3}
    ]
    // => `result` is equal to `expected`
    

    Try this R.sort example in Rambda REPL

    All Typescript definitions typescript sort<T>(sortFn: (a: T, b: T) => number, list: readonly T[]): T[]; sort<T>(sortFn: (a: T, b: T) => number): (list: readonly T[]) => T[];
    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') })
    Typescript test typescript import {sort} from 'rambda' const list = [3, 0, 5, 2, 1] function sortFn(a: number, b: number): number { return a > b ? 1 : -1 } describe('R.sort', () => { it('happy', () => { const result = sort(sortFn, list) result // $ExpectType number[] }) it('curried', () => { const result = sort(sortFn)(list) result // $ExpectType number[] }) })

    ---------------

    sortBy

    
    sortBy<T>(sortFn: (a: T) => Ord, list: readonly T[]): T[]
    

    It returns copy of list sorted by sortFn function.

    :boom: sortFn function must return a value to compare.

    const list = [
      {a: 2},
      {a: 3},
      {a: 1}
    ]
    const sortFn = x => x.a
    
    const result = R.sortBy(sortFn, list)
    const expected = [
      {a: 1},
      {a: 2},
      {a: 3}
    ]
    // => `result` is equal to `expected`
    

    Try this R.sortBy example in Rambda REPL

    All Typescript definitions typescript sortBy<T>(sortFn: (a: T) => Ord, list: readonly T[]): T[]; sortBy(sortFn: (a: any) => Ord): <T>(list: readonly T[]) => T[];
    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 ]) })
    Typescript test typescript import {sortBy} from 'rambda' interface Input { a: number, } describe('R.sortBy', () => { it('passing type to sort function', () => { function fn(x: any): number { return x.a } function fn2(x: Input): number { return x.a } const input = [{a: 2}, {a: 1}, {a: 0}] const result = sortBy(fn, input) const curriedResult = sortBy(fn2)(input) result // $ExpectType { a: number; }[] curriedResult // $ExpectType { a: number; }[] result[0].a // $ExpectType number }) it('passing type to sort function and list', () => { function fn(x: Input): number { return x.a } const input: Input[] = [{a: 2}, {a: 1}, {a: 0}] const result = sortBy(fn, input) const curriedResult = sortBy(fn)(input) result // $ExpectType Input[] curriedResult // $ExpectType Input[] result[0].a // $ExpectType number }) })
    1 failed Ramda.sortBy specs > :boom: Reason for the failure: Ramda method works with array-like objects javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); var albums = [ {title: 'Art of the Fugue', artist: 'Glenn Gould', genre: 'Baroque'}, {title: 'A Farewell to Kings', artist: 'Rush', genre: 'Rock'}, {title: 'Timeout', artist: 'Dave Brubeck Quartet', genre: 'Jazz'}, {title: 'Fly By Night', artist: 'Rush', genre: 'Rock'}, {title: 'Goldberg Variations', artist: 'Daniel Barenboim', genre: 'Baroque'}, {title: 'New World Symphony', artist: 'Leonard Bernstein', genre: 'Romantic'}, {title: 'Romance with the Unseen', artist: 'Don Byron', genre: 'Jazz'}, {title: 'Somewhere In Time', artist: 'Iron Maiden', genre: 'Metal'}, {title: 'In Times of Desparation', artist: 'Danny Holt', genre: 'Modern'}, {title: 'Evita', artist: 'Various', genre: 'Broadway'}, {title: 'Five Leaves Left', artist: 'Nick Drake', genre: 'Folk'}, {title: 'The Magic Flute', artist: 'John Eliot Gardiner', genre: 'Classical'} ]; describe('sortBy', function() { it('sorts array-like object', function() { var args = (function() { return arguments; }('c', 'a', 'b')); var result = R.sortBy(R.identity, args); eq(result[0], 'a'); eq(result[1], 'b'); eq(result[2], 'c'); }); });

    ---------------

    split

    
    split(separator: string | RegExp): (str: string) => string[]
    

    Curried version of String.prototype.split

    const str = 'foo|bar|baz'
    const separator = |'
    const result = R.split(separator, str))
    // => [ 'foo', 'bar', 'baz' ]
    

    Try this R.split example in Rambda REPL

    All Typescript definitions typescript split(separator: string | RegExp): (str: string) => string[]; split(separator: string | RegExp, str: string): string[];
    R.split source javascript export function split(separator, str){ if (arguments.length === 1) return _str => split(separator, _str) return str.split(separator) }
    Tests javascript import { split } from './split' 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) })
    Typescript test typescript import {split} from 'rambda' const str = 'foo|bar|baz' const splitChar = '|' describe('R.split', () => { it('happy', () => { const result = split(splitChar, str) result // $ExpectType string[] }) it('curried', () => { const result = split(splitChar)(str) result // $ExpectType string[] }) })

    ---------------

    splitAt

    
    splitAt<T>(index: number, input: T[]): [T[], T[]]
    

    It splits string or array at a given index.

    const list = [ 1, 2, 3 ]
    const result = splitAt(2, list)
    // => [[ 1, 2 ], [ 3 ]]
    

    Try this R.splitAt example in Rambda REPL

    All Typescript definitions typescript splitAt<T>(index: number, input: T[]): [T[], T[]]; splitAt(index: number, input: string): [string, string]; splitAt(index: number): { <T>(input: T[]): [T[], T[]]; (input: string): [string, string]; };
    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) }) })
    Typescript test typescript import {splitAt} from 'ramda' const index = 1 const str = 'foo' const list = [1, 2, 3] describe('R.splitAt with array', () => { it('happy', () => { const result = splitAt(index, list) result // $ExpectType [number[], number[]] }) it('curried', () => { const result = splitAt(index)(list) result // $ExpectType [number[], number[]] }) }) describe('R.splitAt with string', () => { it('happy', () => { const result = splitAt(index, str) result // $ExpectType [string, string] }) it('curried', () => { const result = splitAt(index)(str) result // $ExpectType [string, string] }) })

    ---------------

    splitEvery

    
    splitEvery<T>(sliceLength: number, input: readonly T[]): T[][]
    

    It splits input into slices of sliceLength.

    const result = [
      R.splitEvery(2, [1, 2, 3]), 
      R.splitEvery(3, 'foobar') 
    ]
    
    const expected = [
      [[1, 2], [3]],
      ['foo', 'bar']
    ]
    // => `result` is equal to `expected`
    

    Try this R.splitEvery example in Rambda REPL

    All Typescript definitions typescript splitEvery<T>(sliceLength: number, input: readonly T[]): T[][]; splitEvery(sliceLength: number, input: string): string[]; splitEvery(sliceLength: number): { (input: string): string[]; <T>(input: readonly T[]): T[][]; };
    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') })
    Typescript test typescript import {splitEvery} from 'rambda' const list = [1, 2, 3, 4, 5, 6, 7] describe('R.splitEvery', () => { it('happy', () => { const result = splitEvery(3, list) result // $ExpectType number[][] }) it('curried', () => { const result = splitEvery(3)(list) result // $ExpectType number[][] }) })

    ---------------

    splitWhen

    
    splitWhen<T, U>(predicate: Predicate<T>, list: U[]): U[][]
    

    It splits list to two arrays according to a predicate function.

    The first array contains all members of list before predicate returns true.

    const list = [1, 2, 1, 2]
    const result = R.splitWhen(R.equals(2), list)
    // => [[1], [2, 1, 2]]
    

    Try this R.splitWhen example in Rambda REPL

    All Typescript definitions typescript splitWhen<T, U>(predicate: Predicate<T>, list: U[]): U[][]; splitWhen<T>(predicate: Predicate<T>): <U>(list: U[]) => U[][];
    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) }) })
    Typescript test typescript import {splitWhen} from 'rambda' const list = [1, 2, 1, 2] const predicate = (x: number) => x === 2 describe('R.splitWhen', () => { it('happy', () => { const result = splitWhen(predicate, list) result // $ExpectType number[][] }) it('curried', () => { const result = splitWhen(predicate)(list) result // $ExpectType number[][] }) })

    ---------------

    startsWith

    
    startsWith(target: string, str: string): boolean
    

    Curried version of String.prototype.startsWith

    :boom: It doesn't work with arrays unlike its corresponding Ramda method.

    const str = 'foo-bar'
    
    const result = [
      R.startsWith('foo', str),
      R.startsWith('bar', str)
    ]
    // => [true, false]
    

    Try this R.startsWith example in Rambda REPL

    All Typescript definitions typescript startsWith(target: string, str: string): boolean; startsWith(target: string): (str: string) => boolean;
    R.startsWith source javascript export function startsWith(target, str){ if (arguments.length === 1) return _str => startsWith(target, _str) return str.startsWith(target) }
    Tests javascript import { startsWith } from './startsWith' test('true', () => { const result = startsWith('foo', 'foo-bar') expect(result).toBeTrue() }) test('false', () => { const result = startsWith('baz')('foo-bar') expect(result).toBeFalse() })
    Typescript test typescript import {startsWith} from 'rambda' const target = 'foo' const input = 'foo bar' describe('R.startsWith', () => { it('happy', () => { const result = startsWith(target, input) result // $ExpectType boolean }) it('curried', () => { const result = startsWith(target)(input) result // $ExpectType boolean }) })
    4 failed Ramda.startsWith specs > :boom: Reason for the failure: Rambda method doesn't support arrays javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('startsWith', function() { it('should return true when an array starts with the provided value', function() { eq(R.startsWith(['a'], ['a', 'b', 'c']), true); }); it('should return true when an array starts with the provided values', function() { eq(R.startsWith(['a', 'b'], ['a', 'b', 'c']), true); }); it('should return false when an array does not start with the provided value', function() { eq(R.startsWith(['b'], ['a', 'b', 'c']), false); }); it('should return false when an array does not start with the provided values', function() { eq(R.startsWith(['b', 'c'], ['a', 'b', 'c']), false); }); });

    ---------------

    subtract

    
    subtract(x: number, y: number): number
    

    Curried version of x - y

    const x = 3
    const y = 1
    
    R.subtract(x, y) 
    // => 2
    

    Try this R.subtract example in Rambda REPL

    All Typescript definitions typescript subtract(x: number, y: number): number; subtract(x: number): (y: number) => number;
    R.subtract source javascript export function subtract(a, b){ if (arguments.length === 1) return _b => subtract(a, _b) return a - b }
    Tests javascript import { subtract } from './subtract' test('happy', () => { expect(subtract(2, 1)).toEqual(1) expect(subtract(2)(1)).toEqual(1) })

    ---------------

    sum

    
    sum(list: readonly number[]): number
    
    R.sum([1, 2, 3, 4, 5]) 
    // => 15
    

    Try this R.sum example in Rambda REPL

    All Typescript definitions typescript sum(list: readonly number[]): number;
    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) })

    ---------------

    symmetricDifference

    
    symmetricDifference<T>(x: readonly T[], y: readonly T[]): T[]
    

    It returns a merged list of x and y with all equal elements removed.

    :boom: R.equals is used to determine equality, i.e. it can be safely used with list of objects.

    const x = [ 1, 2, 3, 4 ]
    const y = [ 3, 4, 5, 6 ]
    
    const result = symmetricDifference(x, y)
    // => [ 1, 2, 5, 6 ]
    

    Try this R.symmetricDifference example in Rambda REPL

    All Typescript definitions typescript symmetricDifference<T>(x: readonly T[], y: readonly T[]): T[]; symmetricDifference<T>(x: readonly T[]): <T>(y: readonly T[]) => T[];
    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 }, ]) })
    Typescript test typescript import {symmetricDifference} from 'rambda' describe('R.symmetricDifference', () => { it('happy', () => { const list1 = [1, 2, 3, 4] const list2 = [3, 4, 5, 6] const result = symmetricDifference(list1, list2) result // $ExpectType number[] }) it('curried', () => { const list1 = [{id: 1}, {id: 2}, {id: 3}, {id: 4}] const list2 = [{id: 3}, {id: 4}, {id: 5}, {id: 6}] const result = symmetricDifference(list1)(list2) result // $ExpectType { id: number; }[] }) })

    ---------------

    T

    
    T(): boolean
    
    R.T() 
    // => true
    

    Try this R.T example in Rambda REPL

    All Typescript definitions typescript T(): boolean;
    R.T source javascript export function T(){ return true }

    ---------------

    tail

    
    tail<T>(input: readonly T[]): T[]
    

    It returns all but the first element of input.

    const result = [
      R.tail([1, 2, 3]),  
      R.tail('foo') 
    ]
    // => [[2, 3], 'oo']
    

    Try this R.tail example in Rambda REPL

    All Typescript definitions typescript tail<T>(input: readonly T[]): T[]; tail(input: string): string;
    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('') })
    Typescript test typescript import {tail} from 'rambda' describe('R.tail', () => { it('with string', () => { const result = tail('foo') result // $ExpectType string }) it('with list', () => { const result = tail([1, 2, 3]) result // $ExpectType number[] }) })

    ---------------

    take

    
    take<T>(howMany: number, input: readonly T[]): T[]
    

    It returns the first howMany elements of input.

    const howMany = 2
    
    const result = [
      R.take(howMany, [1, 2, 3]),
      R.take(howMany, 'foobar'),
    ]
    // => [[1, 2], 'fo']
    

    Try this R.take example in Rambda REPL

    All Typescript definitions typescript take<T>(howMany: number, input: readonly T[]): T[]; take(howMany: number, input: string): string; take<T>(howMany: number): { <T>(input: readonly T[]): T[]; (input: string): string; };
    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([]) })
    Typescript test typescript import {take} from 'rambda' const list = [1, 2, 3, 4] const str = 'foobar' const howMany = 2 describe('R.take - array', () => { it('happy', () => { const result = take(howMany, list) result // $ExpectType number[] }) it('curried', () => { const result = take(howMany)(list) result // $ExpectType number[] }) }) describe('R.take - string', () => { it('happy', () => { const result = take(howMany, str) result // $ExpectType string }) it('curried', () => { const result = take(howMany)(str) result // $ExpectType string }) })
    3 failed Ramda.take specs > :boom: Reason for the failure: Rambda library doesn't have 'R.intomethod </summary> ```javascript var assert = require('assert'); var sinon = require('sinon'); var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('take', function() { it('handles zero correctly (#1224)', function() { eq(R.into([], R.take(0), [1, 2, 3]), []); }); it('steps correct number of times', function() { var spy = sinon.spy(); R.into([], R.compose(R.map(spy), R.take(2)), [1, 2, 3]); sinon.assert.calledTwice(spy); }); it('transducer called for every member of list ifn` is < 0', function() { var spy = sinon.spy(); R.into([], R.compose(R.map(spy), R.take(-1)), [1, 2, 3]); sinon.assert.calledThrice(spy); }); }); ```

    ---------------

    takeLast

    
    takeLast<T>(howMany: number, input: readonly T[]): T[]
    

    It returns the last howMany elements of input.

    const howMany = 2
    
    const result = [
      R.takeLast(howMany, [1, 2, 3]),
      R.takeLast(howMany, 'foobar'),
    ]
    // => [[2, 3], 'ar']
    

    Try this R.takeLast example in Rambda REPL

    All Typescript definitions typescript takeLast<T>(howMany: number, input: readonly T[]): T[]; takeLast(howMany: number, input: string): string; takeLast<T>(howMany: number): { <T>(input: readonly T[]): T[]; (input: string): string; };
    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 ]) })
    Typescript test typescript import {takeLast} from 'rambda' const list = [1, 2, 3, 4] const str = 'foobar' const howMany = 2 describe('R.takeLast - array', () => { it('happy', () => { const result = takeLast(howMany, list) result // $ExpectType number[] }) it('curried', () => { const result = takeLast(howMany)(list) result // $ExpectType number[] }) }) describe('R.takeLast - string', () => { it('happy', () => { const result = takeLast(howMany, str) result // $ExpectType string }) it('curried', () => { const result = takeLast(howMany)(str) result // $ExpectType string }) })

    ---------------

    takeLastWhile

    
    takeLastWhile(predicate: (x: string) => boolean, input: string): string
    
    const result = R.takeLastWhile(
      x => x > 2,
      [1, 2, 3, 4]
    )
    // => [3, 4]
    

    Try this R.takeLastWhile example in Rambda REPL

    All Typescript definitions typescript takeLastWhile(predicate: (x: string) => boolean, input: string): string; takeLastWhile(predicate: (x: string) => boolean): (input: string) => string; takeLastWhile<T>(predicate: (x: T) => boolean, input: readonly T[]): T[]; takeLastWhile<T>(predicate: (x: T) => boolean): <T>(input: readonly T[]) => T[];
    R.takeLastWhile source javascript import { _isArray } from './_internals/_isArray.js' 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') })
    Typescript test typescript import {takeLastWhile} from 'rambda' const list = [1, 2, 3] const str = 'FOO' describe('R.takeLastWhile', () => { it('with array', () => { const result = takeLastWhile(x => x > 1, list) result // $ExpectType number[] }) it('with array - curried', () => { const result = takeLastWhile(x => x > 1, list) result // $ExpectType number[] }) it('with string', () => { const result = takeLastWhile(x => x !== 'F', str) result // $ExpectType string }) it('with string - curried', () => { const result = takeLastWhile(x => x !== 'F')(str) result // $ExpectType string }) })

    ---------------

    takeWhile

    
    takeWhile(fn: Predicate<string>, iterable: string): string
    
    const list = [1, 2, 3, 4]
    const predicate = x => x < 3
    
    const result = R.takeWhile(predicate, list)
    // => [1, 2]
    

    Try this R.takeWhile example in Rambda REPL

    All Typescript definitions typescript takeWhile(fn: Predicate<string>, iterable: string): string; takeWhile(fn: Predicate<string>): (iterable: string) => string; takeWhile<T>(fn: Predicate<T>, iterable: readonly T[]): T[]; takeWhile<T>(fn: Predicate<T>): (iterable: readonly T[]) => T[];
    R.takeWhile source javascript import { _isArray } from '../src/_internals/_isArray' export function takeWhile(predicate, iterable){ if (arguments.length === 1){ return _iterable => takeWhile(predicate, _iterable) } const isArray = _isArray(iterable) if (!isArray && typeof iterable !== 'string'){ throw new Error('`iterable` is neither list nor a string') } let flag = true const holder = [] let counter = -1 while (counter++ < iterable.length - 1){ if (!predicate(iterable[ counter ])){ if (flag) flag = false } else if (flag){ holder.push(iterable[ counter ]) } } holder return isArray ? holder : holder.join('') }
    Tests javascript import { takeWhile as takeWhileRamda } from "ramda"; import { takeWhile } from "./takeWhile"; import { compareCombinations } from "./_internals/testUtils"; const list = [1, 2, 3, 4, 5]; test("happy", () => { const result = takeWhile((x) => x < 3, list); expect(result).toEqual([1, 2]); }); test("always true", () => { const result = takeWhile((x) => true, list); expect(result).toEqual(list); }); test("always false", () => { const result = takeWhile((x) => 0, list); expect(result).toEqual([]); }); test("with string", () => { const result = takeWhile((x) => x !== "b", "foobar"); console.log(result); expect(result).toBe("foo"); }); const possiblePredicates = [ null, undefined, () => 0, () => true, (x) => x !== "b", /foo/g, {}, [], ]; const possibleIterables = [ null, undefined, [], {}, 1, "", "foobar", [""], [1, 2, 3, 4, 5], ]; describe("brute force", () => { compareCombinations({ firstInput: possiblePredicates, callback: (errorsCounters) => { expect(errorsCounters).toMatchInlineSnapshot(` Object { "ERRORS_MESSAGE_MISMATCH": 15, "ERRORS_TYPE_MISMATCH": 16, "RESULTS_MISMATCH": 0, "SHOULD_NOT_THROW": 16, "SHOULD_THROW": 0, } `); }, secondInput: possibleIterables, fn: takeWhile, fnRamda: takeWhileRamda, }); });
    Typescript test typescript import {takeWhile} from 'rambda' const list = [1, 2, 3, 4] describe('R.takeWhile', () => { it('happy', () => { const result = takeWhile(x => x > 2, list) result // $ExpectType number[] }) it('curried require explicit type', () => { const result = takeWhile<number>(x => x > 2)(list) result // $ExpectType number[] }) }) describe('with string as iterable', () => { const str = 'foobar' it('happy', () => { const result = takeWhile(x => x !== 'b', str) result // $ExpectType string }) it('curried require explicit type', () => { const result = takeWhile(x => x !== 'b')(str) result // $ExpectType string }) })

    2 failed Ramda.takeWhile specs

    :boom: Reason for the failure: Ramda method works with strings not only arrays

    ---------------

    tap

    
    tap<T>(fn: (x: T) => void, input: T): T
    

    It applies function fn to input x and returns x.

    One use case is debuging in the middle of R.compose.

    const list = [1, 2, 3]
    
    R.compose(
      R.map(x => x * 2)
      R.tap(console.log),
      R.filter(x => x > 1)
    )(list)
    // => `2` and `3` will be logged
    

    Try this R.tap example in Rambda REPL

    All Typescript definitions typescript tap<T>(fn: (x: T) => void, input: T): T; tap<T>(fn: (x: T) => void): (input: T) => T;
    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) })
    Typescript test typescript import {tap, pipe} from 'rambda' describe('R.tap', () => { it('happy', () => { pipe( tap(x => { x // $ExpectType number[] }), (x: number[]) => x.length )([1, 2]) }) })
    2 failed Ramda.tap specs > :boom: Reason for the failure: Ramda method can act as a transducer javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); var listXf = require('./helpers/listXf'); var _curry2 = require('rambda/internal/_curry2'); describe('tap', function() { var pushToList = _curry2(function(lst, x) { lst.push(x); }); it('can act as a transducer', function() { var sideEffect = []; var numbers = [1,2,3,4,5]; var xf = R.compose(R.map(R.identity), R.tap(pushToList(sideEffect))); eq(R.into([], xf, numbers), numbers); eq(sideEffect, numbers); }); it('dispatches to transformer objects', function() { var sideEffect = []; var pushToSideEffect = pushToList(sideEffect); eq(R.tap(pushToSideEffect, listXf), { f: pushToSideEffect, xf: listXf }); }); });

    ---------------

    test

    
    test(regExpression: RegExp): (str: string) => boolean
    

    It determines whether str matches regExpression.

    R.test(/^f/, 'foo')
    // => true
    

    Try this R.test example in Rambda REPL

    All Typescript definitions typescript test(regExpression: RegExp): (str: string) => boolean; test(regExpression: RegExp, str: string): boolean;
    R.test source javascript export function test(pattern, str){ if (arguments.length === 1) return _str => test(pattern, _str) if (typeof pattern === 'string'){ throw new TypeError(`‘test’ requires a value of type RegExp as its first argument; received "${ pattern }"`) } return str.search(pattern) !== -1 }
    Tests javascript import { test as testMethod } from './test' test('happy', () => { expect(testMethod(/^x/, 'xyz')).toBeTrue() expect(testMethod(/^y/)('xyz')).toBeFalse() }) test('throws if first argument is not regex', () => { expect(() => testMethod('foo', 'bar')).toThrowWithMessage(TypeError, '‘test’ requires a value of type RegExp as its first argument; received "foo"') })
    Typescript test typescript import {test} from 'rambda' const input = 'foo ' const regex = /foo/ describe('R.test', () => { it('happy', () => { const result = test(regex, input) result // $ExpectType boolean }) it('curried', () => { const result = test(regex)(input) result // $ExpectType boolean }) })

    ---------------

    times

    
    times<T>(fn: (i: number) => T, howMany: number): T[]
    

    It returns the result of applying function fn over members of range array.

    The range array includes numbers between 0 and howMany(exclusive).

    const fn = x => x * 2
    const howMany = 5
    
    R.times(fn, howMany)
    //=> [0, 2, 4, 6, 8]
    

    Try this R.times example in Rambda REPL

    All Typescript definitions typescript times<T>(fn: (i: number) => T, howMany: number): T[]; times<T>(fn: (i: number) => T): (howMany: number) => T[];
    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 ]) })
    Typescript test typescript import {times, identity} from 'rambda' describe('R.times', () => { it('happy', () => { const result = times(identity, 5) result // $ExpectType number[] }) })

    ---------------

    toLower

    
    toLower(str: string): string
    
    R.toLower('FOO')
    // => 'foo'
    

    Try this R.toLower example in Rambda REPL

    All Typescript definitions typescript toLower(str: string): string;
    R.toLower source javascript export function toLower(str){ return str.toLowerCase() }
    Tests javascript import { toLower } from './toLower' test('toLower', () => { expect(toLower('FOO|BAR|BAZ')).toEqual('foo|bar|baz') })

    ---------------

    toPairs

    
    toPairs<S>(obj: { [k: string]: S } | { [k: number]: S }): [string, S][]
    

    It transforms an object to a list.

    const list = {
      a : 1,
      b : 2,
      c : [ 3, 4 ],
    }
    const expected = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ] ]
    
    const result = R.toPairs(list)
    // => `result` is equal to `expected`
    

    Try this R.toPairs example in Rambda REPL

    All Typescript definitions typescript toPairs<S>(obj: { [k: string]: S } | { [k: number]: S }): [string, S][];
    R.toPairs source javascript export function toPairs(obj){ return Object.entries(obj) }
    Tests javascript import { toPairs } from './toPairs' const obj = { a : 1, b : 2, c : [ 3, 4 ], } const expected = [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', [ 3, 4 ] ], ] test('happy', () => { expect(toPairs(obj)).toEqual(expected) })
    Typescript test typescript import {toPairs} from 'rambda' const obj = { a: 1, b: 2, c: [3, 4], } describe('R.toPairs', () => { it('happy', () => { const result = toPairs(obj) result // $ExpectType [string, number | number[]][] }) })

    ---------------

    toString

    
    toString<T>(x: T): string
    
    R.toString([1, 2]) 
    // => '1,2'
    

    Try this R.toString example in Rambda REPL

    All Typescript definitions typescript toString<T>(x: T): string;
    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') })

    ---------------

    toUpper

    
    toUpper(str: string): string
    
    R.toUpper('foo')
    // => 'FOO'
    

    Try this R.toUpper example in Rambda REPL

    All Typescript definitions typescript toUpper(str: string): string;
    R.toUpper source javascript export function toUpper(str){ return str.toUpperCase() }
    Tests javascript import { toUpper } from './toUpper' test('toUpper', () => { expect(toUpper('foo|bar|baz')).toEqual('FOO|BAR|BAZ') })

    ---------------

    transpose

    
    transpose<T>(list: readonly T[][]): T[][]
    
    const list = [[10, 11], [20], [], [30, 31, 32]]
    const expected = [[10, 20, 30], [11, 31], [32]]
    
    const result = R.transpose(list)
    // => `result` is equal to `expected`
    

    Try this R.transpose example in Rambda REPL

    All Typescript definitions typescript transpose<T>(list: readonly T[][]): T[][];
    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) })
    Typescript test typescript import {transpose} from 'rambda' const input = [ ['a', 1], ['b', 2], ['c', 3], ] describe('R.transpose', () => { it('happy', () => { const result = transpose(input) result // $ExpectType (string | number)[][] }) })

    ---------------

    trim

    
    trim(str: string): string
    
    R.trim('  foo  ') 
    // => 'foo'
    

    Try this R.trim example in Rambda REPL

    All Typescript definitions typescript trim(str: string): string;
    R.trim source javascript export function trim(str){ return str.trim() }
    Tests javascript import { trim } from './trim' test('trim', () => { expect(trim(' foo ')).toEqual('foo') })
    1 failed Ramda.trim specs > :boom: Reason for the failure: Ramda method trims all ES5 whitespace javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('trim', function() { var test = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFFHello, World!\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; it('trims all ES5 whitespace', function() { eq(R.trim(test), 'Hello, World!'); eq(R.trim(test).length, 13); }); if (typeof String.prototype.trim !== 'function') { it('falls back to a shim if String.prototype.trim is not present', function() { eq(R.trim(' xyz '), 'xyz'); eq(R.trim(test), 'Hello, World!'); eq(R.trim(test).length, 13); eq(R.trim('\u200b'), '\u200b'); eq(R.trim('\u200b').length, 1); }); } });

    ---------------

    tryCatch

    
    tryCatch<T, U>(
      fn: (input: T) => U,
      fallback: U
    ): (input: T) => U
    

    It returns function that runs fn in try/catch block. If there was an error, then fallback is used to return the result. Note that fn can be value or asynchronous/synchronous function(unlike Ramda where fallback can only be a synchronous function).

    :boom: Please check the tests of R.tryCatch to fully understand how this method works.

    const fn = x => x.foo
    
    const result = [
      R.tryCatch(fn, false)(null),
      R.tryCatch(fn, false)({foo: 'bar'})
    ]
    // => [false, 'bar']
    

    Try this R.tryCatch example in Rambda REPL

    All Typescript definitions typescript tryCatch<T, U>( fn: (input: T) => U, fallback: U ): (input: T) => U; tryCatch<T, U>( fn: (input: T) => U, fallback: (input: T) => U ): (input: T) => U; tryCatch<T>( fn: (input: any) => Promise<any>, fallback: T ): (input: any) => Promise<T>; tryCatch<T>( fn: (input: any) => Promise<any>, fallback: (input: any) => Promise<any>, ): (input: any) => Promise<T>;
    R.tryCatch source javascript import { isFunction } from './isFunction' import { isPromise } from './isPromise' export function tryCatch(fn, fallback){ if (!isFunction(fn)){ throw new Error(`R.tryCatch | fn '${ fn }'`) } const passFallback = isFunction(fallback) if (!isPromise(fn)){ return (...inputs) => { try { return fn(...inputs) } catch (e){ return passFallback ? fallback(e, ...inputs) : fallback } } } return (...inputs) => new Promise(resolve => { fn(...inputs) .then(resolve) .catch(() => { if (!passFallback){ return resolve(fallback) } if (!isPromise(fallback)){ return resolve(fallback(...inputs)) } fallback(...inputs).then(resolve) }) }) }
    Tests javascript import { delay } from './delay' import { prop } from './prop' import { tryCatch } from './tryCatch' test('throws when fn is not function', () => { const fn = 'foo' expect(() => tryCatch(fn, false)(null)).toThrowWithMessage(Error, 'R.tryCatch | fn \'foo\'') }) test('when fallback is used', () => { const fn = x => x.x expect(tryCatch(fn, false)(null)).toBeFalse() }) test('with json parse', () => { const good = () => JSON.parse(JSON.stringify({ a : 1 })) const bad = () => JSON.parse('a{a') expect(tryCatch(good, 1)(null)).toEqual({ a : 1 }) expect(tryCatch(bad, 1)(null)).toBe(1) }) test('when fallback is function', () => { const fn = x => x.x expect(tryCatch(fn, () => 1)(null)).toBe(1) }) test('when fn is used', () => { const fn = prop('x') expect(tryCatch(fn, false)({})).toBe(undefined) expect(tryCatch(fn, false)({ x : 1 })).toBe(1) }) test('fallback receives error object and all initial inputs', () => { function thrower( a, b, c ){ void c throw new Error('throwerError') } function catchFn( e, a, b, c ){ return [ e.message, a, b, c ].join('|') } const willThrow = tryCatch(thrower, catchFn) const result = willThrow( 'A', 'B', 'C' ) expect(result).toBe('throwerError|A|B|C') }) test('fallback receives error object', () => { function throwFn(){ throw new Error(10) } function eCatcher( e, a, b ){ return e.message } const willThrow = tryCatch(throwFn, eCatcher) expect(willThrow([])).toBe('10') expect(willThrow([ {}, {}, {} ])).toBe('10') }) test('when async + fallback', async () => { let called = false const fn = async input => { await delay(input) called = true return JSON.parse('{a:') } expect(await tryCatch(fn, 'fallback')(100)).toBe('fallback') expect(called).toBeTrue() }) test('when async + fallback is function', async () => { let called = false const fn = async input => { await delay(input) called = true return JSON.parse('{a:') } expect(await tryCatch(fn, x => x + 1)(100)).toBe(101) expect(called).toBeTrue() }) test('when async + fallback is async', async () => { let called = false const fn = async input => { await delay(input) called = true return JSON.parse('{a:') } const fallback = async input => { await delay(10) return input + 1 } expect(await tryCatch(fn, fallback)(100)).toBe(101) expect(called).toBeTrue() }) test('when async + fn', async () => { let called = false const fn = async input => { await delay(input) called = true return input + 1 } expect(await tryCatch(fn, 'fallback')(100)).toBe(101) expect(called).toBeTrue() })
    Typescript test typescript import {tryCatch, delay} from 'rambda' describe('R.tryCatch', () => { it('synchronous', () => { const fn = (x: any) => x.x === 1 const result = tryCatch(fn, false)(null) result // $ExpectType boolean }) it('synchronous + fallback is function', () => { const fn = (x: any) => typeof x.x const fallback = (x: any) => typeof x const result = tryCatch<any, string>(fn, fallback)(null) result // $ExpectType string }) it('asynchronous', async() => { const fn = async(input: any) => { return typeof JSON.parse('{a:') } const result = await tryCatch<string>(fn, 'fallback')(100) result // $ExpectType string }) it('asynchronous + fallback is asynchronous', async() => { const fn = async(input: any) => { await delay(100) return JSON.parse(`{a:${input}`) } const fallback = async(input: any) => { await delay(100) return 'foo' } const result = await tryCatch<string>(fn, fallback)(100) result // $ExpectType string }) })

    1 failed Ramda.tryCatch specs

    :boom: Reason for the failure: Ramda method returns a function with the same arity

    ---------------

    type

    
    type(x: any): "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "Function" | "Undefined" | "Async" | "Promise" | "RegExp" | "NaN"
    

    It accepts any input and it returns its type.

    :boom: NaN, Promise and Async are types specific for Rambda.

    R.type(() => {}) // => 'Function'
    R.type(async () => {}) // => 'Async'
    R.type([]) // => 'Array'
    R.type({}) // => 'Object'
    R.type('foo') // => 'String'
    R.type(1) // => 'Number'
    R.type(true) // => 'Boolean'
    R.type(null) // => 'Null'
    R.type(/[A-z]/) // => 'RegExp'
    R.type('foo'*1) // => 'NaN'
    
    const delay = ms => new Promise(resolve => {
      setTimeout(function () {
        resolve()
      }, ms)
    })
    R.type(delay) // => 'Promise'
    

    Try this R.type example in Rambda REPL

    All Typescript definitions typescript type(x: any): "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "Function" | "Undefined" | "Async" | "Promise" | "RegExp" | "NaN";
    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 (input instanceof RegExp){ return 'RegExp' } const asStr = input && input.toString ? input.toString() : '' if ([ 'true', 'false' ].includes(asStr)) return 'Boolean' if (!Number.isNaN(Number(asStr))) return 'Number' if (asStr.startsWith('async')) return 'Async' if (asStr === '[object Promise]') return 'Promise' if (typeOf === 'function') return 'Function' if (input instanceof String) return 'String' return 'Object' }
    Tests javascript import { type as ramdaType } from 'ramda' import { type } from './type' test('with simple promise', () => { expect(type(Promise.resolve(1))).toBe('Promise') }) test('with new Boolean', () => { expect(type(new Boolean(true))).toBe('Boolean') }) test('with new String', () => { expect(type(new String('I am a String object'))).toEqual('String') }) test('with new Number', () => { expect(type(new Number(1))).toBe('Number') }) test('with new promise', () => { const delay = ms => new Promise(resolve => { setTimeout(() => { resolve(ms + 110) }, ms) }) expect(type(delay(10))).toEqual('Promise') }) test('async function', () => { expect(type(async () => {})).toEqual('Async') }) test('async arrow', () => { const asyncArrow = async () => {} expect(type(asyncArrow)).toBe('Async') }) test('function', () => { const fn1 = () => {} const fn2 = function (){} function fn3(){} ;[ () => {}, fn1, fn2, fn3 ].map(val => { expect(type(val)).toEqual('Function') }) }) test('object', () => { expect(type({})).toEqual('Object') }) test('number', () => { expect(type(1)).toEqual('Number') }) test('boolean', () => { expect(type(false)).toEqual('Boolean') }) test('string', () => { expect(type('foo')).toEqual('String') }) test('null', () => { expect(type(null)).toEqual('Null') }) test('array', () => { expect(type([])).toEqual('Array') expect(type([ 1, 2, 3 ])).toEqual('Array') }) test('regex', () => { expect(type(/\s/g)).toEqual('RegExp') }) test('undefined', () => { expect(type(undefined)).toEqual('Undefined') }) test('not a number', () => { expect(type(Number('s'))).toBe('NaN') }) test('function inside object 1', () => { const obj = { f(){ return 4 }, } expect(type(obj.f)).toBe('Function') expect(ramdaType(obj.f)).toBe('Function') }) test('function inside object 2', () => { const name = 'f' const obj = { [ name ](){ return 4 }, } expect(type(obj.f)).toBe('Function') expect(ramdaType(obj.f)).toBe('Function') })
    Typescript test typescript import {type} from 'rambda' describe('R.type', () => { it('happy', () => { const result = type(4) result // $ExpectType RambdaTypes }) })
    1 failed Ramda.type specs > :boom: Reason for the failure: Ramda method returns 'Number' type to NaN input, while Rambda method returns 'NaN' javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('type', function() { // it('"Arguments" if given an arguments object', function() { // var args = (function() { return arguments; }()); // eq(R.type(args), 'Arguments'); // }); it('"Number" if given the NaN value', function() { eq(R.type(NaN), 'Number'); }); });

    ---------------

    union

    
    union<T>(x: readonly T[], y: readonly T[]): T[]
    

    It takes two lists and return a new list containing a merger of both list with removed duplicates.

    R.equals is used to compare for duplication, which means that it can be safely used with array of objects.

    const result = R.union([1,2,3], [3,4,5]);
    //=> [1, 2, 3, 4, 5]
    

    Try this R.union example in Rambda REPL

    All Typescript definitions typescript union<T>(x: readonly T[], y: readonly T[]): T[]; union<T>(x: readonly T[]): (y: readonly T[]) => T[];
    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) })
    Typescript test typescript import {union} from 'rambda' describe('R.union', () => { it('happy', () => { const result = union([1, 2], [2, 3]) result // $ExpectType number[] }) it('with array of objects - case 1', () => { const list1 = [{a: 1}, {a: 2}] const list2 = [{a: 2}, {a: 3}] const result = union(list1, list2) result // $ExpectType { a: number; }[] }) it('with array of objects - case 2', () => { const list1 = [{a: 1, b: 1}, {a: 2}] const list2 = [{a: 2}, {a: 3, b: 3}] const result = union(list1, list2) result[0].a // $ExpectType number result[0].b // $ExpectType number | undefined }) }) describe('R.union - curried', () => { it('happy', () => { const result = union([1, 2])([2, 3]) result // $ExpectType number[] }) it('with array of objects - case 1', () => { const list1 = [{a: 1}, {a: 2}] const list2 = [{a: 2}, {a: 3}] const result = union(list1)(list2) result // $ExpectType { a: number; }[] }) it('with array of objects - case 2', () => { const list1 = [{a: 1, b: 1}, {a: 2}] const list2 = [{a: 2}, {a: 3, b: 3}] const result = union(list1)(list2) result[0].a // $ExpectType number result[0].b // $ExpectType number | undefined }) })

    1 failed Ramda.union specs

    :boom: Reason for the failure: Ramda library supports fantasy-land

    ---------------

    uniq

    
    uniq<T>(list: readonly T[]): T[]
    

    It returns a new array containing only one copy of each element of list.

    :boom: R.equals is used to determine equality

    const list = [1, 1, {a: 1}, {a: 2}, {a:1}]
    
    R.uniq(list)
    // => [1, {a: 1}, {a: 2}]
    

    Try this R.uniq example in Rambda REPL

    All Typescript definitions typescript uniq<T>(list: readonly T[]): T[];
    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 ] ]) })
    Typescript test typescript import {uniq} from 'rambda' describe('R.uniq', () => { it('happy', () => { const result = uniq([1, 2, 3, 3, 3, 1, 2, 0]) result // $ExpectType number[] }) })
    2 failed Ramda.uniq specs > :boom: Reason for the failure: Ramda method pass to uniq method | Ramda method uses reference equality for functions javascript var R = require('../../../../dist/rambda.js'); var eq = require('./shared/eq'); describe('uniq', function() { it('has R.equals semantics', function() { function Just(x) { this.value = x; } Just.prototype.equals = function(x) { return x instanceof Just && R.equals(x.value, this.value); }; eq(R.uniq([-0, -0]).length, 1); eq(R.uniq([0, -0]).length, 2); eq(R.uniq([NaN, NaN]).length, 1); eq(R.uniq([[1], [1]]).length, 1); eq(R.uniq([new Just([42]), new Just([42])]).length, 1); it('handles null and undefined elements', function() { eq(R.uniq([void 0, null, void 0, null]), [void 0, null]); it('uses reference equality for functions', function() { eq(R.uniq([R.add, R.identity, R.add, R.identity, R.add, R.identity]).length, 2); });

    ---------------

    uniqWith

    
    uniqWith<T, U>(uniqFn: (x: T, y: T) => boolean, list: readonly T[]): T[]
    

    It returns a new array containing only one copy of each element in list according to boolean returning function uniqFn.

    const list = [
      {id: 0, title:'foo'},
      {id: 1, title:'bar'},
      {id: 2, title:'baz'},
      {id: 3, title:'foo'},
      {id: 4, title:'bar'},
    ]
    
    const expected = [
      {id: 0, title:'foo'},
      {id: 1, title:'bar'},
      {id: 2, title:'baz'},
    ]
    
    const uniqFn = (x,y) => x.title === y.title
    
    const result = R.uniqWith(uniqFn, list)
    // => `result` is equal to `expected`
    

    Try this R.uniqWith example in Rambda REPL

    All Typescript definitions typescript uniqWith<T, U>(uniqFn: (x: T, y: T) => boolean, list: readonly T[]): T[]; uniqWith<T, U>(uniqFn: (x: T, y: T) => boolean): (list: readonly T[]) => T[];
    R.uniqWith source javascript import { any } from './any' export function uniqWith(fn, list){ if (arguments.length === 1) return _list => uniqWith(fn, _list) let index = -1 const len = list.length const willReturn = [] while (++index < len){ const value = list[ index ] const flag = any(willReturnInstance => fn(value, willReturnInstance), willReturn) if (!flag){ willReturn.push(value) } } return willReturn }
    Tests javascript import { uniqWith } from './uniqWith' test('happy', () => { const input = [ { id : 0, title : 'foo', }, { id : 1, title : 'bar', }, { id : 2, title : 'baz', }, { id : 3, title : 'foo', }, { id : 4, title : 'bar', }, ] const expectedResult = [ { id : 0, title : 'foo', }, { id : 1, title : 'bar', }, { id : 2, title : 'baz', }, ] const fn = (x, y) => x.title === y.title const result = uniqWith(fn, input) const curriedResult = uniqWith(fn)(input) expect(result).toEqual(expectedResult) expect(curriedResult).toEqual(expectedResult) }) test('uniqWith', () => { const input = [ { id : 0, title : 'foo', }, { id : 1, title : 'bar', }, { id : 2, title : 'baz', }, { id : 3, title : 'foo', }, { id : 4, title : 'bar', }, ] const expectedResult = [ { id : 0, title : 'foo', }, { id : 1, title : 'bar', }, { id : 2, title : 'baz', }, ] const fn = (x, y) => x.title === y.title const result = uniqWith(fn, input) //const result = uniqWith(Ramda.eqBy(Ramda.prop('title')), input) expect(result).toEqual(expectedResult) })
    Typescript test typescript import {uniqWith} from 'rambda' describe('R.uniqWith', () => { it('happy', () => { const input = [ { id: 0, title: 'foo', }, { id: 1, title: 'bar', }, { id: 2, title: 'baz', }, { id: 3, title: 'foo', }, { id: 4, title: 'bar', }, ] const fn = (x: any, y: any) => x.title === y.title const result = uniqWith(fn, input) result // $ExpectType { id: number; title: string; }[] }) })

    ---------------

    unless

    
    unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, obj: T): U
    

    The method returns function that will be called with argument input.

    If predicate(input) returns false, then the end result will be the outcome of whenFalse(input).

    In the other case, the final output will be the input itself.

    const fn = R.unless(
      x => x > 2,
      x => x + 10
    )
    
    const result = [
      fn(1),
      fn(5)
    ]
    // => [11, 5]
    

    Try this R.unless example in Rambda REPL

    All Typescript definitions typescript unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U, obj: T): U; unless<T, U>(predicate: (x: T) => boolean, whenFalseFn: (x: T) => U): (obj: T) => U;
    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

    Show All