Avaq/ramda-sanctuary.md

## ramda-sanctuary.md

      
    Raw
  

              ramda-sanctuary.md
            
          
Ramda
Sanctuary


add(a, b)
add(b, a)


addIndex(f)
``


adjust(f, i, xs)
``


all(f, xs)
``


allPass(fs, x)
allPass(fs, x)


always(x)
K(x)


and(a, b)
and(a, b)


any(f, x)
``


anyPass(f, xs)
anyPass(f, xs)


ap(a, b)
ap(a, b)


aperture()
``


append(x, xs)
append(x, xs)


apply()
``


applySpec()
``


ascend()
``


assoc()
``


assocPath()
``


binary(f)
curry2(f)


bind()
``


both(f, g)
allPass([f, g])


call(f, x)
A(f, x)


chain(a, b)
chain(a, b)


clamp(a, b)
``


clone()
``


comparator()
``


complement(f)
compose(not, f)


compose(f, g)
compose(f, g)


composeK(f, g)
compose(chain(f), g)


composeP()
``


concat(xs, ys)
concat(xs, ys)


cond()
``


construct()
``


constructN()
``


contains(x, xs)
compose(isJust, indexOf(x), xs)


converge()
``


countBy()
``


curry(f)
curry<n>(f)


curryN(f)
curry<n>(f)


dec(x)
dec(x)


defaultTo(x, y)
compose(fromMaybe(x), toMaybe, y)


descend()
``


difference()
``


differenceWith()
``


dissoc()
``


dissocPath()
``


divide(x, y)
div(x, y)


drop(i, xs)
fromMaybe([], drop(i, xs))


dropLast()
fromMaybe([], dropLast(i, xs))


dropLastWhile()
``


dropRepeats()
``


dropRepeatsWith()
``


dropWhile()
``


either(f, g)
anyPass([f, g])


empty(x)
empty(x.constructor)


eqBy(f, a, b)
on(equals, f, a, b)


eqProps(x, a, b)
on(equals, prop(x), a, b)


equals(a, b)
equals(a, b)


evolve(a, b)
ap(b, a)


F(x)
K(false, x)


filter(f, xs)
filter(f, xs)


find(f, xs)
find(f, xs)


findIndex()
findIndex(f, xs)


findLast()
``


findLastIndex()
``


flatten(xs)
``


flip(f)
flip(f)


forEach()
``


forEachObjIndexed()
``


fromPairs(xs)
fromPairs(xs)


groupBy()
``


groupWith()
``


gt()
``


gte()
``


has()
``


hasIn()
``


head()
``


identical()
``


identity()
``


ifElse()
``


inc()
``


indexBy()
``


indexOf()
``


init()
``


insert()
``


insertAll()
``


intersection()
``


intersectionWith()
``


intersperse()
``


into()
``


invert()
``


invertObj()
``


invoker()
``


is()
``


isArrayLike()
``


isEmpty()
``


isNil()
``


join()
``


juxt()
``


keys()
``


keysIn()
``


last()
``


lastIndexOf()
``


length()
``


lens()
``


lensIndex()
``


lensPath()
``


lensProp()
``


lift()
``


liftN()
``


lt()
``


lte()
``


map()
``


mapAccum()
``


mapAccumRight()
``


mapObjIndexed()
``


match()
``


mathMod()
``


max()
``


maxBy()
``


mean()
``


median()
``


memoize()
``


merge()
``


mergeAll()
``


mergeWith()
``


mergeWithKey()
``


min()
``


minBy()
``


modulo()
``


multiply()
``


nAry()
``


negate()
``


none()
``


not()
``


nth()
``


nthArg()
``


objOf()
``


of()
``


omit()
``


once()
``


or()
``


over()
``


pair()
``


partial()
``


partialRight()
``


partition()
``


path()
``


pathEq()
``


pathOr()
``


pathSatisfies()
``


pick()
``


pickAll()
``


pickBy()
``


pipe()
``


pipeK()
``


pipeP()
``


pluck()
``


prepend()
``


product()
``


project()
``


prop()
``


propEq()
``


propIs()
``


propOr()
``


props()
``


propSatisfies()
``


range()
``


reduce()
``


reduceBy()
``


reduced()
``


reduceRight()
``


reduceWhile()
``


reject()
``


remove()
``


repeat()
``


replace()
``


reverse()
``


scan()
``


sequence()
``


set()
``


slice()
``


sort()
``


sortBy()
``


sortWith()
``


split()
``


splitAt()
``


splitEvery()
``


splitWhen()
``


subtract()
``


sum()
``


symmetricDifference()
``


symmetricDifferenceWith()
``


T()
``


tail()
``


take()
``


takeLast()
``


takeLastWhile()
``


takeWhile()
``


tap()
``


test()
``


times()
``


toLower()
``


toPairs()
``


toPairsIn()
``


toString()
``


toUpper()
``


transduce()
``


transpose()
``


traverse()
``


trim()
``


tryCatch()
``


type()
``


unapply()
``


unary()
``


uncurryN()
``


unfold()
``


union()
``


unionWith()
``


uniq()
``


uniqBy()
``


uniqWith()
``


unless()
``


unnest()
``


until()
``


update()
``


useWith()
``


values()
``


valuesIn()
``


view()
``


when()
``


where()
``


whereEq()
``


without()
``


xprod()
``


zip()
``


zipObj()
``


zipWith()
``
Ramda	Sanctuary
`add(a, b)`	`add(b, a)`
`addIndex(f)`	``
`adjust(f, i, xs)`	``
`all(f, xs)`	``
`allPass(fs, x)`	`allPass(fs, x)`
`always(x)`	`K(x)`
`and(a, b)`	`and(a, b)`
`any(f, x)`	``
`anyPass(f, xs)`	`anyPass(f, xs)`
`ap(a, b)`	`ap(a, b)`
`aperture()`	``
`append(x, xs)`	`append(x, xs)`
`apply()`	``
`applySpec()`	``
`ascend()`	``
`assoc()`	``
`assocPath()`	``
`binary(f)`	`curry2(f)`
`bind()`	``
`both(f, g)`	`allPass([f, g])`
`call(f, x)`	`A(f, x)`
`chain(a, b)`	`chain(a, b)`
`clamp(a, b)`	``
`clone()`	``
`comparator()`	``
`complement(f)`	`compose(not, f)`
`compose(f, g)`	`compose(f, g)`
`composeK(f, g)`	`compose(chain(f), g)`
`composeP()`	``
`concat(xs, ys)`	`concat(xs, ys)`
`cond()`	``
`construct()`	``
`constructN()`	``
`contains(x, xs)`	`compose(isJust, indexOf(x), xs)`
`converge()`	``
`countBy()`	``
`curry(f)`	`curry<n>(f)`
`curryN(f)`	`curry<n>(f)`
`dec(x)`	`dec(x)`
`defaultTo(x, y)`	`compose(fromMaybe(x), toMaybe, y)`
`descend()`	``
`difference()`	``
`differenceWith()`	``
`dissoc()`	``
`dissocPath()`	``
`divide(x, y)`	`div(x, y)`
`drop(i, xs)`	`fromMaybe([], drop(i, xs))`
`dropLast()`	`fromMaybe([], dropLast(i, xs))`
`dropLastWhile()`	``
`dropRepeats()`	``
`dropRepeatsWith()`	``
`dropWhile()`	``
`either(f, g)`	`anyPass([f, g])`
`empty(x)`	`empty(x.constructor)`
`eqBy(f, a, b)`	`on(equals, f, a, b)`
`eqProps(x, a, b)`	`on(equals, prop(x), a, b)`
`equals(a, b)`	`equals(a, b)`
`evolve(a, b)`	`ap(b, a)`
`F(x)`	`K(false, x)`
`filter(f, xs)`	`filter(f, xs)`
`find(f, xs)`	`find(f, xs)`
`findIndex()`	`findIndex(f, xs)`
`findLast()`	``
`findLastIndex()`	``
`flatten(xs)`	``
`flip(f)`	`flip(f)`
`forEach()`	``
`forEachObjIndexed()`	``
`fromPairs(xs)`	`fromPairs(xs)`
`groupBy()`	``
`groupWith()`	``
`gt()`	``
`gte()`	``
`has()`	``
`hasIn()`	``
`head()`	``
`identical()`	``
`identity()`	``
`ifElse()`	``
`inc()`	``
`indexBy()`	``
`indexOf()`	``
`init()`	``
`insert()`	``
`insertAll()`	``
`intersection()`	``
`intersectionWith()`	``
`intersperse()`	``
`into()`	``
`invert()`	``
`invertObj()`	``
`invoker()`	``
`is()`	``
`isArrayLike()`	``
`isEmpty()`	``
`isNil()`	``
`join()`	``
`juxt()`	``
`keys()`	``
`keysIn()`	``
`last()`	``
`lastIndexOf()`	``
`length()`	``
`lens()`	``
`lensIndex()`	``
`lensPath()`	``
`lensProp()`	``
`lift()`	``
`liftN()`	``
`lt()`	``
`lte()`	``
`map()`	``
`mapAccum()`	``
`mapAccumRight()`	``
`mapObjIndexed()`	``
`match()`	``
`mathMod()`	``
`max()`	``
`maxBy()`	``
`mean()`	``
`median()`	``
`memoize()`	``
`merge()`	``
`mergeAll()`	``
`mergeWith()`	``
`mergeWithKey()`	``
`min()`	``
`minBy()`	``
`modulo()`	``
`multiply()`	``
`nAry()`	``
`negate()`	``
`none()`	``
`not()`	``
`nth()`	``
`nthArg()`	``
`objOf()`	``
`of()`	``
`omit()`	``
`once()`	``
`or()`	``
`over()`	``
`pair()`	``
`partial()`	``
`partialRight()`	``
`partition()`	``
`path()`	``
`pathEq()`	``
`pathOr()`	``
`pathSatisfies()`	``
`pick()`	``
`pickAll()`	``
`pickBy()`	``
`pipe()`	``
`pipeK()`	``
`pipeP()`	``
`pluck()`	``
`prepend()`	``
`product()`	``
`project()`	``
`prop()`	``
`propEq()`	``
`propIs()`	``
`propOr()`	``
`props()`	``
`propSatisfies()`	``
`range()`	``
`reduce()`	``
`reduceBy()`	``
`reduced()`	``
`reduceRight()`	``
`reduceWhile()`	``
`reject()`	``
`remove()`	``
`repeat()`	``
`replace()`	``
`reverse()`	``
`scan()`	``
`sequence()`	``
`set()`	``
`slice()`	``
`sort()`	``
`sortBy()`	``
`sortWith()`	``
`split()`	``
`splitAt()`	``
`splitEvery()`	``
`splitWhen()`	``
`subtract()`	``
`sum()`	``
`symmetricDifference()`	``
`symmetricDifferenceWith()`	``
`T()`	``
`tail()`	``
`take()`	``
`takeLast()`	``
`takeLastWhile()`	``
`takeWhile()`	``
`tap()`	``
`test()`	``
`times()`	``
`toLower()`	``
`toPairs()`	``
`toPairsIn()`	``
`toString()`	``
`toUpper()`	``
`transduce()`	``
`transpose()`	``
`traverse()`	``
`trim()`	``
`tryCatch()`	``
`type()`	``
`unapply()`	``
`unary()`	``
`uncurryN()`	``
`unfold()`	``
`union()`	``
`unionWith()`	``
`uniq()`	``
`uniqBy()`	``
`uniqWith()`	``
`unless()`	``
`unnest()`	``
`until()`	``
`update()`	``
`useWith()`	``
`values()`	``
`valuesIn()`	``
`view()`	``
`when()`	``
`where()`	``
`whereEq()`	``
`without()`	``
`xprod()`	``
`zip()`	``
`zipObj()`	``
`zipWith()`	``