Comprehensive Ramda to Sanctuary list

Ramda	Sanctuary
`add(a, b)`	`add(a, b)`
`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(s, x, o)`	`insert(s, x, o)`
`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)`	`complement(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()`	``
`converge()`	``
`countBy()`	``
`curry(f)`	`curry<n>(f)`
`curryN(f)`	`curry<n>(f)`
`dec(x)`	`sub(1)(x)`
`defaultTo(x, y)`	`compose(fromMaybe(x), toMaybe, y)`
`descend()`	``
`difference()`	``
`differenceWith()`	``
`dissoc(s, o)`	`remove(s, o)`
`dissocPath()`	``
`divide(x, y)`	`div(x, y)`
`drop(i, xs)`	`fromMaybe([], drop(i, xs))`
`dropLast()`	`fromMaybe([], dropLast(i, xs))`
`dropLastWhile()`	``
`dropRepeats()`	``
`dropRepeatsWith()`	``
`dropWhile(f, xs)`	`dropWhile(f, xs)`
`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(x, y)`	`gt_(x, y)`
`gte(x, y)`	`gte_(x, y)`
`has()`	``
`hasIn()`	``
`head(xs)`	`head(xs)` returns Maybe
`identical()`	``
`identity(x)`	`I(x)`
`ifElse()`	``
`inc(x)`	`add(1)(x)`
`indexBy()`	``
`indexOf()`	``
`init(xs)`	`init(xs)` returns Maybe
`insert()`	``
`insertAll()`	``
`intersection()`	``
`intersectionWith()`	``
`intersperse()`	``
`into()`	``
`invert()`	``
`invertObj()`	``
`invoker()`	``
`is(X, x)`	`is(X, x)`
`isArrayLike()`	``
`isEmpty()`	``
`isNil()`	``
`join()`	``
`juxt()`	``
`keys(o)`	`keys(o)`
`keysIn()`	``
`last(xs)`	`last(xs)` returns Maybe
`lastIndexOf()`	``
`length(xs)`	`size(xs)` generalized over Foldable
`lens()`	``
`lensIndex()`	``
`lensPath()`	``
`lensProp()`	``
`lift()`	``
`liftN()`	``
`lt(x, y)`	`lt(x, y)`
`lte(x, y)`	`lte(x, y)`
`map(f, xs)`	`map(f, xs)`
`mapAccum()`	``
`mapAccumRight()`	``
`mapObjIndexed()`	``
`match()`	``
`mathMod()`	``
`max(x, y)`	`max(x, y)`
`maxBy()`	``
`mean()`	``
`median()`	``
`memoize()`	``
`merge(o1, o2)`	`concat(o1, o2)`
`mergeAll()`	``
`mergeWith()`	``
`mergeWithKey()`	``
`min(x, y)`	`min(x, y)`
`minBy()`	``
`modulo()`	``
`multiply(x, y)`	`mult(x, y)`
`nAry()`	``
`negate(x)`	`mult(-1)(x)`
`none()`	``
`not(b)`	`not(b)`
`nth(n, xs)`	`at(n, xs)` returns Maybe
`nthArg()`	``
`objOf(s, x)`	`singleton(s, x)`
`of(x)`	`of(typeRep, x)`
`omit()`	``
`once()`	``
`or(x, y)`	`or(x, y)`
`over()`	``
`pair()`	``
`partial()`	``
`partialRight()`	``
`partition()`	``
`path(p, o)`	`props(p, o)`
`pathEq()`	``
`pathOr()`	``
`pathSatisfies()`	``
`pick()`	``
`pickAll()`	``
`pickBy()`	``
`pipe(f1, f2, ...)`	`pipe([f1, f2, ...])`
`pipeK()`	``
`pipeP()`	``
`pluck(p, xs)`	`map(prop(p), xs)`
`prepend(x, xs)`	`prepend(x, xs)`
`product(xs)`	`product(xs)`
`project()`	``
`prop(s, o)`	`prop(s, o)`
`propEq()`	``
`propIs()`	``
`propOr(x, y z)`	`compose(fromMaybe(x), get(K(true), y))(z)`
`props`	``
`propSatisfies()`	``
`range(n, m)`	`range(n, m)`
`reduce(f, d, xs)`	`reduce(f, d, xs)`
`reduceBy()`	``
`reduced()`	``
`reduceRight()`	``
`reduceWhile()`	``
`reject()`	``
`remove()`	``
`repeat()`	``
`replace()`	``
`reverse(xs)`	`reverse(xs)`
`scan()`	``
`sequence(f, xs)`	`sequence(F, xs)` takes a type representative
`set()`	``
`slice(n, m, xs)`	`slice(n, m, xs)` returns Maybe
`sort(xs)`	`sort(xs)`
`sortBy(f, xs)`	`sortBy(f, xs)`
`sortWith()`	``
`split(str, s)`	`splitOn(str, s)`
`split(regex, s)`	`splitOnRegex(regex, s)`
`splitAt()`	``
`splitEvery()`	``
`splitWhen()`	``
`subtract(x, y)`	`sub(x, y)`
`sum(xs)`	`sum(xs)`
`symmetricDifference()`	``
`symmetricDifferenceWith()`	``
`T(x)`	`K(true)(x)`
`tail(xs)`	`tail(xs)` returns Maybe
`take(n, xs)`	`take(n, xs)` returns Maybe
`takeLast(n, xs)`	`takeLast(n, xs)` returns Maybe
`takeLastWhile()`	``
`takeWhile(f, xs)`	`takeWhile(f, xs)` returns Maybe, doesn't work with String
`tap()`	``
`test(r, s)`	`test(r, s)`
`times()`	``
`toLower(s)`	`toLower(s)`
`toPairs(o)`	`pairs(o)`
`toPairsIn()`	``
`toString(x)`	`toString(x)`
`toUpper(s)`	`toUpper(s)`
`transduce()`	``
`transpose()`	``
`traverse(f, g, xs)`	`traverse(F, g, xs)`
`trim(s)`	`trim(s)`
`tryCatch()`	``
`type(s)`	`type(x).name`
`unapply()`	``
`unary()`	``
`uncurryN()`	``
`unfold(f :: b -> [a], d)`	`unfoldr(f :: b -> Maybe (Pair a b), d)`
`union()`	``
`unionWith()`	``
`uniq()`	``
`uniqBy()`	``
`uniqWith()`	``
`unless(f, g, x)`	`unless(f, g, x)`
`unnest()`	``
`until()`	``
`update()`	``
`useWith()`	``
`values(o)`	`values(o)` all values must be of the same type
`valuesIn()`	``
`view()`	``
`when(f, g, x)`	`when(f, g, x)`
`where()`	``
`whereEq()`	``
`without()`	``
`xprod(xs, ys)`	`lift2(x => y => [x, y], xs, ys)`
`zip()`	``
`zipObj()`	``
`zipWith()`	``

gabejohnson/ramda-sanctuary.md