Package Exports

rambdax

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (rambdax) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Rambdax

Extended version of Rambda(utility library) - Documentation

Simple example

const R = require("rambdax")
const result = R.compose(
  R.filter(val => val>2),
  R.flatten,
)([ [1], [2], [3], 4])
console.log(result) // => [3, 4]

How to use it?

Simple yarn add rambdax is sufficient

ES5 compatible version - yarn add rambdax#0.8.0

Differences between Rambda and Ramdax

Rambdax passthrough all Rambda methods and introduce some new functions.

The idea of Rambdax is to extend Rambda without worring for Ramda compatibility.

API

API part I - Rambdax own methods

assocPath

assocPath(path: string[]|string, x: any, obj: object): object

It creates a shallow copy of object obj with value x and object path path. If the object don't have object path path, then this path is created.

R.assocPath('a.b.c', 42, {a: {b: {c: 0}}})
//=> {a: {b: {c: 42} } }

compact

compact(arr: Array)

It removes the empty values from an array.

const arr = [
  1,
  null,
  undefined,
  false,
  "",
  " ",
  "foo",
  {},
  [],
  [1],
  /\s/g
]
const result = R.compact(arr)
const expectedResult = [1, false, " ", "foo", [1]]
// result === expectedResult

composeAsync

composeAsync(...fns: Array<Function|Async>)(startValue: any): Promise

Asyncronous version of R.compose.

const fn = async x => {
  await R.delay(x)
  return x+1
}

const result = await composeAsync(
  fn,
  async x => fn(x),
)(await fn(0))

console.log(result) //=> 3

debounce

debounce(fn: Function, ms: Number): any

Creates a debounced function that delays invoking fn until after wait milliseconds ms have elapsed since the last time the debounced function was invoked.

Description is taken from Lodash docs.

let counter = 0
const inc = () => {
  counter++
}
const fn = debounce(inc, 1000)
fn()
await R.delay(500)
console.log(counter) //=> 0
await R.delay(1000)
console.log(counter) //=> 1

delay

delay(ms: Number): Promise<R.DELAY>

setTimeout as a promise that resolves toR.DELAY variable.

R.delay(1000).then( result => {
  console.assert( result === R.DELAY )
})

The value of R.DELAY is 'RAMBDAX_DELAY'

evolve

evolve (rules: Object, input: Object): Object

Properties of input object are transformed according to rules object that contains functions as values.

If property prop of rules is a function and also a property of input, then input[prop] will be equal to the result of rules[prop](input[prop]).

rules[prop] can be also a object that contains functions, as you can see in the example below:

const input = {
    firstName : "  Tomato ",
    data      : {
      elapsed   : 100,
      remaining : 1400,
    },
    id : 123,
  }
const rules = {
    firstName : R.trim,
    lastName  : R.trim, //Will not get invoked.
    data      : {
      elapsed   : R.add(1),
      remaining : R.add(-1),
    },
  }

const result = R.evolve(transformations, tomato)
const expectedResult = {
  firstName: "Tomato",
  data: {
    elapsed: 101,
    remaining: 1399,
  },
  id: 123,
})
// result === expectedResult

greater

greater(x: number, y: number)

It return true if the second argument is greater than the first argument. Note that this is opposite direction compared to Rambda's gt method, because it makes more sense in R.compose context.

R.greater(1,2) // => true

intersection

intersection(a: Array, b: Array): Array

It returns array with the overlapped members of a and b.

R.intersection([ 1, 3, 5 ], [ 2, 3, 5 ]) //=> [3, 5]

It returns true if R.type of x is equal to xType.

isPromiseLike

isPromiseLike(x: any): Boolean

It returns true if x is either async function or unresolved promise.

isValid

isValid({input: Object, schema: Object}): Boolean

It checks if input is following schema specifications.

This is modified version of json-validity library.

const schema = {
  published: "number",
  style: [ "rock", "jazz" ],
  title: "string",
}

const song = {
  published: 1975,
  style: "rock",
  title: "In my time of dying",
}

R.isValid({input,schema}) // => true

less

less(x: number, y: number)

It return true if the second argument is less than the first argument. Note that this is opposite direction compared to Rambda's lt method, because it makes more sense in R.compose context.

R.less(2,1) // => true

mapAsync

mapAsync(fn: Async|Promise, arr: Array): Promise

Sequential asynchronous mapping with fn over members of arr.

const fn = a => new Promise(resolve => {
  setTimeout(() => {
    resolve(a + 1)
  }, 100)
})

const result = await R.composeAsync(
  R.mapAsync(fn),
  R.map(a => a * 10)
)([1, 2, 3])
console.log(result) //=> [11, 21, 31]

mapFastAsync

mapFastAsync(fn: Async|Promise, arr: Array): Promise

Parrallel asynchronous mapping with fn over members of arr.

const fn = a => new Promise(resolve => {
  setTimeout(() => {
    resolve(a + 1)
  }, 100)
})

const result = await R.composeAsync(
  R.mapFastAsync(fn),
  R.map(a => a * 10)
)([1, 2, 3])
console.log(result) //=> [11, 21, 31]

memoize

memoize(fn: Function|Promise): any

When fn is called for a second time with the same input, then the cache result is returned instead of calling fn.

let counter = 0
const fn = (a,b) =>{
  counter++
  return a+b
}
const memoized = R.memoize(fn)
memoized(1,2)
memoized(1,2)
console.log(counter) //=> 1

mergeAll

mergeAll(input: object[]): object

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

const arr = [
  {a:1},
  {b:2},
  {c:3}
]
const expectedResult = {
  a:1,
  b:2,
  c:3
}
const result = R.mergeAll(arr)
// result === expectedResult

omitBy

omitBy(fn: function, input: Object): Object

It returns only those properties of input that return false when passed to fn.

const input = {
  a: 1,
  b: 2,
  c: 3,
  d: 4,
}
const fn = (prop, val) => val < 3
const expectedResult = {
  c: 3,
  d: 4,
}
const result = R.omitBy(fn, input)
// result === expectedResult

once

once(fn: Function): Function

It returns a function, which invokes only oncefn.

const addOneOnce = R.once((a, b, c) => a + b + c)

console.log(addOneOnce(10,20,30)) //=> 60
console.log(addOneOnce(1,2,3)) //=> 60

pickBy

pickBy(fn: Function, input: Object): Object

It returns only those properties of input that return true when passed to fn.

const input = {
  a: 1,
  b: 2,
  c: 3,
  d: 4,
}
const fn = (prop,val) => val > 3 || prop === 'a'
const expectedResult = {
  a: 1,
  d: 4,
}
const result = R.pickBy(fn, input)
// result === expectedResult

produce

produce(conditions: Object, input: any): Promise|Object

const conditions = {
  foo: a => a > 10,
  bar: a => ({baz:a})
}

const result = R.produce(conditions, 7)

const expectedResult = {
  foo: false,
  bar: {baz: 7}
}
// result === expectedResult

conditions is an object with sync or async functions as values.

The values of the returned object returnValue are the results of those functions when input is passed. The properties of the returned object are equal to input.

If any of the conditions is a Promise, then the returned value is a Promise that resolves to returnValue.

random

random(min: number, max: number): number

It returns a random number between min inclusive and max inclusive.

const randomResult = R.random(1, 10)
expect(randomResult).toBeLessThanOrEqual(10)
expect(randomResult).toBeGreaterThanOrEqual(1)

rangeBy

rangeBy(start: number, end: number, step: number): number[]

It returns array of all numbers between start and end, when the step of increase is step.

expect(
  R.rangeBy(0, 10, 2)
).toEqual([0, 2, 4, 6, 8, 10])
expect(
  R.rangeBy(0, 2, 0.3)
).toEqual([0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

renameProps

renameProps(rules: object, input: object): object

If property prop of rules is also a property in input, then rename input property to rules[prop].

const rules = {
  f: "foo",
  b: "bar"
}
const input = {
  f:1,
  b:2
}
const result = R.renameProps(rules, input)
const expectedResult = {
  foo:1,
  bar:2
}
// result === expectedResult

resolve

resolve(promises: object): Promise

It acts as Promise.all for object with Promises. It returns a promise that resolve to object.

const fn = ms => new Promise(resolve => {
  setTimeout(() => {
    resolve(ms)
  }, ms)
})
const promises = {
  a : fn(1),
  b : fn(2),
}
const result = await R.resolve(promises)
const expectedResult = { a:1, b:2 }
// result === expectedResult

resolveSecure

resolveSecure(promises: Array): Array<{type: 'RESULT'|'ERROR', payload:any}>

It acts as Promise.all with fault tollerance.

Occurence of error err in any of the promises adds {type: 'ERROR', payload: err} to the final result. Result result in any of the promises adds {type: 'RESULT', payload: result} to the final result.

const fn = async () => {
  try {
    JSON.parse("{:a")
  }
  catch (err) {
    throw new Error(err)
  }
}

const result = await R.resolveSecure([
  R.delay(2000),
  fn(1000)
])

const expectedResult = [
  {
    "payload": 'RAMBDAX_DELAY',
    "type": "RESULT"
  },
  {
    payload:"Unexpected token : in JSON at position 1",
    type: "ERROR"
  }
]
// => result === expectedResult

shuffle

shuffle(arr: any[]): any[]

It returns randomized copy of array.

switcher

Edited fork of Switchem library.

It is best explained with the following example:

const valueToMatch = {foo: 1}

const result = switcher(valueToMatch)
  .is('baz', 'is baz')
  .is( x => typeof x === 'boolean', 'is boolean')
  .is({foo: 1}, 'Property foo is 1')
  .default('is bar')

console.log(result) // => 'Property foo is 1'

As you can see valueToMatch is matched sequentially against various is conditions. If none of them is appliable, then default value is returned as result.

Note that default must be the last condition and it is mandatory.

Rambda's equals is used as part of the comparison process.

tapAsync

tapAsync(fn: Function|Async|Promise, inputArgument: T): T

It is R.tap that accept promise-like fn argument.

const log = async a => {
  await R.delay(1000)
  console.log(a)
}
const result = R.tapAsync(log, "foo")
// the console logs `foo`
// `result` is equal to "foo"

throttle

throttle(fn: Function, period: number): Function

It creates a throttled function that invokes fn maximum once for a period of milliseconds.

let counter = 0
const inc = () => {
  counter++
}

const fn = throttle(inc, 1000)
fn()
await R.delay(500)
fn()
console.log(counter) // => 1

where

where(conditions: object, input: object): boolean

Each property prop in conditions is a function.

This function is called with input(prop). If all such function calls return true, then the final result is also true.

const condition = R.where({
  a : aProp => typeof aProp === "string",
  b : bProp => bProp === 4
})

condition({
  a : "foo",
  b : 4,
  c : 11,
}) //=> true

condition({
  a : 1,
  b : 4,
  c : 11,
}) //=> false

when

when(rule: Function|boolean, fn: Function): Function

var truncate = R.when(
  x => x.length > 5,
  R.compose(x => `${x}...`, R.take(5))
)

console.log(truncate('1234')) => '1234'
console.log(truncate('12345678')) => '12345...'

Methods inherited from Rambda

add

add(a: Number, b: Number): Number

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

rambdax

Package Exports

Readme

Rambdax

Simple example

How to use it?

Differences between Rambda and Ramdax

API

API part I - Rambdax own methods

assocPath

compact

composeAsync

debounce

delay

evolve

greater

intersection

isPromiseLike

isValid

less

mapAsync

mapFastAsync

memoize

mergeAll

omitBy

once

pickBy

produce

random

rangeBy

renameProps

resolve

resolveSecure

shuffle

switcher

tapAsync

throttle

where

when

Methods inherited from Rambda

add

addIndex

adjust

all

allPass

always

any

append

both

compose

complement

concat

contains

curry

dec

defaultTo

divide

drop

dropLast

endsWith

either

equals

F

filter

find

findIndex

flatten

flip

forEach

has

head

identity

ifElse

inc

includes

indexOf

init

join

is

isNil