pepka 0.12.3 → 0.13.0-b1

package/README.md

@@ -1,23 +1,26 @@
 ![image](https://user-images.githubusercontent.com/7501201/122691868-ae59f800-d23a-11eb-97fa-c0fab3cb0808.png)
 
-HI! Meet pepka - JavaScript/TypeScript functional programming utilities library named after my paraqeet.
+HI! Meet pepka - JavaScript/TypeScript functional programming utility library named after my parakeet.
 
 This lib is intended to be a functional toolkit more flexible than ramda is.
 Its' basic API is similimar to ramda's one.
 Other goals are:
-- Async pipes. They are not super-pure, but super handy.
-- Most flexible types as possible (Let'em be any better than crashing because of their failures. I'm currently working on full JSDocs and better basic types).
-- Tree-shakeble ans smallest possible. What could be native, is native.
-- Has "quick" alternatives of most computation-heavy functions with `q` prefix which are not completely safe by fp means.
+- Async pipes. They are very handy, but are not 100% pure in terms of Haskell c:
+- Most flexible types possible (Let'em be any better than crashing because of their failures. I'm currently working on full JSDocs and better basic types).
+- Tree-shakeble and smallest possible. What could be native, is native.
+- Has "quick" alternatives of most computation-heavy functions with `q` prefix which are not completely safe by fp means: most of them do mutations and it may be needed to `clone` or `cloneShallow` data in a first pipe of `compose(...)`.
+- Has basic toolbelt-types like AnyObject and AnyFunc<ReturnType?, [...args]?> etc.
 - Has some basic additinal must-have stuff that ramda does not.
 
 Full docs are coming,
 please reference ramda's ones for most operations and examples: https://ramdajs.com/docs/
 
 Basic API differences:
+- clone() clones deeply as possible any type possible.
+- cloneShallow() clones only by 1st level of folding also any type possible.
 - mergeDeep - replaces arrays.
-  - mergeDeepX - replaces elements with same indexes.
-  - mergeDeepAdd - adds new element to arrays.
+  - mergeDeepX - replaces its' elements with same indexes.
+  - mergeDeepAdd - adds new elements to arrays.
 - type - returns type UpperCased of anything passed to it, including classes and typed arrays.
 - mapKeys - changes existing keys and data by map or function like usual mapper.
 - explore(label)(data) - `compose(explore('the number'))(42)` results in `'the number', 42` in console passing by the data.

package/dist/bundle.dev.js

@@ -1,4 +1,4 @@
-const __ = (function Placeholder() { });
+const __ = Symbol('Placeholder');
 const countArgs = (s) => {
     let i = 0;
     for (const v of s)
@@ -37,7 +37,38 @@ const _curry = (fn, args, new_args) => {
 };
 const curry = ((fn) => ((...args) => fn.length > countArgs(args)
     ? _curry(fn, [], args)
-    : fn(...args)));
+    : fn(...args)));
+// type EndlessPh<Func extends FT.Function, ArgT> =
+//   (a: ArgT) => ReturnType<Func>
+//   | ((a: A.x) => EndlessPh<Func, ArgT>)
+const endlessph = (fn) => {
+    function _endlessph(a) {
+        return a === __ ? fn : fn(a);
+    }
+    return _endlessph;
+};
+function curry2(fn) {
+    function curried2(a, b) {
+        const withPlaceholder1 = a === __;
+        const aln = arguments.length;
+        if (aln === 1 && withPlaceholder1)
+            throw new Error('Senseless placeholder usage.');
+        return arguments.length > 1
+            ? withPlaceholder1
+                ? endlessph((a) => fn(a, b))
+                : fn(a, b)
+            : (b) => fn(a, b);
+    }
+    return curried2;
+}
+function curry3(fn) {
+    // type p0 = Parameters<Func>[0]
+    // type p1 = Parameters<Func>[1]
+    // type p2 = Parameters<Func>[2]
+    // type ReturnT = ReturnType<Func>
+    // TODO: optimize.
+    return curry(fn);
+}
 
 const undef = undefined;
 const nul = null;
@@ -63,14 +94,14 @@ const type = (s) => {
         : caseMap[t[0]] + t.slice(1);
 };
 
-const qappend = curry((s, xs) => { xs.push(s); return xs; });
-const qassoc = curry((prop, v, obj) => {
+const qappend = curry2((s, xs) => { xs.push(s); return xs; });
+const qassoc = curry3((prop, v, obj) => {
     obj[prop] = v;
     return obj;
 });
-const qreduce = curry((fn, accum, arr) => arr.reduce(fn, accum));
+const qreduce = curry3((fn, accum, arr) => arr.reduce(fn, accum));
 // strategy is for arrays: 1->clean, 2->merge, 3->push.
-const mergeDeep$1 = curry((strategy, o1, o2) => {
+const mergeDeep$1 = curry3((strategy, o1, o2) => {
     for (let k in o2) {
         switch (type(o2[k])) {
             case 'Array':
@@ -110,7 +141,7 @@ const qmergeDeep = mergeDeep$1(1);
 const qmergeDeepX = mergeDeep$1(2);
 const qmergeDeepAdd = mergeDeep$1(3);
 /** qmapKeys({ a: 'b' }, { a: 44 }) -> { b: 44 } */
-const qmapKeys = curry((keyMap, o) => {
+const qmapKeys = curry2((keyMap, o) => {
     let k, mapped, newKey, newValue;
     for (k in keyMap) {
         mapped = keyMap[k];
@@ -124,7 +155,7 @@ const qmapKeys = curry((keyMap, o) => {
     }
     return o;
 });
-const qfilter = curry((cond, data) => {
+const qfilter = curry2((cond, data) => {
     const isArr = isArray(data);
     for (let k in data) {
         if (!cond(data[k], k)) {
@@ -140,10 +171,13 @@ const qfilter = curry((cond, data) => {
     return data;
 });
 /** @deprecated */
-const qindexOf = curry((x, xs) => xs.indexOf(x));
+const qindexOf = curry2((x, xs) => xs.indexOf(x));
+
+// TODO: possibly introduce a second argument limiting unfolding.
+const uncurry = (fn) => (...args) => qreduce(((fn, arg) => fn ? fn(arg) : fn), fn, args);
 
 // over, lensProp
-const equals = curry((a, b) => {
+const equals = curry2((a, b) => {
     const typea = type(a);
     if (typea === type(b) && (typea === 'Object' || typea == 'Array')) {
         if (isNull(a) || isNull(b)) {
@@ -165,16 +199,17 @@ const equals = curry((a, b) => {
     return a === b;
 });
 const ifElse = curry((cond, pipeYes, pipeNo, s) => cond(s) ? pipeYes(s) : pipeNo(s));
-const when = curry((cond, pipe, s) => ifElse(cond, pipe, identity, s));
+const when = curry3((cond, pipe, s) => ifElse(cond, pipe, identity, s));
 const compose = ((...fns) => (s = __) => {
     for (let i = length(fns) - 1; i > -1; i--) {
         s = s === __ ? fns[i]() : fns[i](s);
     }
     return s;
-}); // as F.Compose
-const bind = curry((fn, context) => fn.bind(context));
-const nth = curry((i, data) => data[i]);
-const includes = curry((s, ss) => {
+});
+const bind = curry2((fn, context) => fn.bind(context));
+const _nth = (i, data) => data[i];
+const nth = curry2(_nth);
+const includes = curry2((s, ss) => {
     if (isStr(ss)) {
         return ss.includes(s);
     }
@@ -187,11 +222,11 @@ const includes = curry((s, ss) => {
         return false;
     }
 });
-const slice = curry((from, to, o) => o.slice(from, (isNum(to) ? to : Infinity)));
+const slice = curry3((from, to, o) => o.slice(from, (isNum(to) ? to : Infinity)));
 const head = nth(0);
 const tail = slice(1, nul);
-const add = curry((n, m) => n + m);
-const subtract = curry((n, m) => m - n);
+const add = curry2((n, m) => n + m);
+const subtract = curry2((n, m) => m - n);
 const flip = (fn) => curry((b, a) => fn(a, b));
 const isNil = (s) => isNull(s) || isUndef(s);
 const length = (s) => s.length;
@@ -207,10 +242,10 @@ const complement = (fn) => (...args) => {
 const keys = (o) => Object.keys(o);
 const values = (o) => Object.values(o);
 const toPairs = (o) => Object.entries(o);
-const test = curry((re, s) => re.test(s));
-const tap = curry((fn, s) => { fn(s); return s; });
-const append = curry((s, xs) => [...xs, s]);
-const split = curry((s, xs) => xs.split(s));
+const test = curry2((re, s) => re.test(s));
+const tap = curry2((fn, s) => { fn(s); return s; });
+const append = curry2((s, xs) => [...xs, s]);
+const split = curry2((s, xs) => xs.split(s));
 const T = always(true);
 const F = always(false);
 const sizeof = (s) => {
@@ -223,10 +258,10 @@ const sizeof = (s) => {
     else
         return length(s);
 };
-const range = curry((from, to) => genBy(add(from), to - from));
+const range = curry2((from, to) => genBy(add(from), to - from));
 const uniq = (xs) => qreduce((accum, x) => includes(x, accum) ? accum : qappend(x, accum), [], xs);
-const intersection = curry((xs1, xs2) => xs1.filter(flip(includes)(xs2)));
-const genBy = curry((generator, length) => [...Array(length)].map((_, i) => generator(i)));
+const intersection = curry2((xs1, xs2) => xs1.filter(flip(includes)(xs2)));
+const genBy = curry2((generator, length) => [...Array(length)].map((_, i) => generator(i)));
 const once = (fn) => {
     let done = false, cache;
     return (...args) => {
@@ -240,50 +275,51 @@ const once = (fn) => {
     };
 };
 const reverse = (xs) => compose((ln) => reduce((nxs, _, i) => qappend(xs[ln - i], nxs), [], xs), add(-1), length)(xs);
-const gt = curry((a, b) => a > b);
-const lt = curry((a, b) => a < b);
-const gte = curry((a, b) => b >= a);
-const lte = curry((a, b) => b <= a);
-// : <U=any>(sortFn: (v: U)=>-1|1, xs: U[]) => U[] 
-const sort = curry((sortFn, xs) => xs.sort(sortFn));
-const find = curry((fn, s) => s.find(fn));
-const findIndex = curry((fn, s) => s.findIndex(fn));
-const indexOf = curry((x, xs) => findIndex(equals(x), xs));
+const gt = curry2((a, b) => a > b);
+const lt = curry2((a, b) => a < b);
+const gte = curry2((a, b) => b >= a);
+const lte = curry2((a, b) => b <= a);
+const sort = curry2((sortFn, xs) => xs.sort(sortFn));
+const find = curry2((fn, s) => s.find(fn));
+const findIndex = curry2((fn, s) => s.findIndex(fn));
+const indexOf = curry2((x, xs) => findIndex(equals(x), xs));
 const explore = (caption, level = 'log') => tap((v) => console[level](caption, v));
-const cond = curry((pairs, s) => {
+const cond = curry2((pairs, s) => {
     for (const [cond, fn] of pairs) {
         if (cond(s)) {
             return fn(s);
         }
     }
 });
-const assoc = curry((prop, v, obj) => ({
+const assoc = curry3((prop, v, obj) => ({
     ...obj,
     [prop]: v
 }));
-const assocPath = curry((_path, v, o) => compose((first) => assoc(first, length(_path) < 2
+const assocPath = curry3((_path, v, o) => compose((first) => assoc(first, length(_path) < 2
     ? v
     : assocPath(slice(1, null, _path), v, isObj(o[first]) ? o[first] : {}), o), head)(_path));
-const all = curry((pred, xs) => xs.every(pred));
-const any = curry((pred, xs) => xs.some(pred));
-const allPass = curry((preds, x) => preds.every((pred) => pred(x)));
-const anyPass = curry((preds, x) => preds.some((pred) => pred(x)));
-const prop = curry((key, o) => o[key]);
-const propEq = curry((key, value, o) => equals(o[key], value));
-const propsEq = curry((key, o1, o2) => equals(o1[key], o2[key]));
-const pathOr = curry((_default, path, o) => ifElse(length, () => isNil(o)
+const all = curry2((pred, xs) => xs.every(pred));
+const any = curry2((pred, xs) => xs.some(pred));
+const allPass = curry2((preds, x) => preds.every((pred) => pred(x)));
+const anyPass = curry2((preds, x) => preds.some((pred) => pred(x)));
+const prop = curry2((key, o) => o[key]);
+const propEq = curry3((key, value, o) => equals(o[key], value));
+const propsEq = curry3((key, o1, o2) => equals(o1[key], o2[key]));
+const pathOr = curry3((_default, path, o) => ifElse(length, () => isNil(o)
     ? _default
     : compose(ifElse(isNil, always(_default), (o) => pathOr(_default, slice(1, nul, path), o)), flip(prop)(o), head)(path), always(o), path));
 const path = pathOr(undef);
-const pathEq = curry((_path, value, o) => equals(path(_path, o), value));
-const pathsEq = curry((_path, o1, o2) => equals(path(_path, o1), path(_path, o2)));
+const pathEq = curry3((_path, value, o) => equals(path(_path, o), value));
+const pathsEq = curry3((_path, o1, o2) => equals(path(_path, o1), path(_path, o2)));
 const typed_arr_re = /^(.*?)(8|16|32|64)(Clamped)?Array$/;
-const clone = (s) => {
+const clone = (s, shallow = false) => {
     const t = type(s);
     switch (t) {
         case 'Null': return s;
-        case 'Array': return map(clone, s);
+        case 'Array': return shallow ? [...s] : map(clone, s);
         case 'Object':
+            if (shallow)
+                return { ...s };
             const out = {};
             for (let k in s) {
                 out[k] = clone(s[k]);
@@ -295,12 +331,13 @@ const clone = (s) => {
         case 'Symbol':
             return s;
         default:
-            return typed_arr_re.test(t) ? map(clone, s) : s;
+            return typed_arr_re.test(t) ? s.constructor.from(s) : s;
     }
 };
-const reduce = curry((fn, accum, arr) => qreduce(fn, clone(accum), arr));
-const pickBy = curry((cond, o) => filter(cond, o));
-const pick = curry((props, o) => {
+const cloneShallow = (s) => clone(s, true);
+const reduce = curry3((fn, accum, arr) => qreduce(fn, clone(accum), arr));
+const pickBy = curry2((cond, o) => filter(cond, o));
+const pick = curry2((props, o) => {
     const out = {};
     for (const p of props) {
         if (p in o) {
@@ -309,13 +346,13 @@ const pick = curry((props, o) => {
     }
     return out;
 });
-const omit = curry((props, o) => filter((_, k) => !includes(k, props), o));
+const omit = curry2((props, o) => filter((_, k) => !includes(k, props), o));
 const fromPairs = (pairs) => reduce((o, pair) => assoc(...pair, o), {}, pairs);
-const concat = curry(((a, b) => a.concat(b)));
-const join = curry((delimeter, arr) => arr.join(delimeter));
-const map = curry((pipe, arr) => arr.map(pipe));
-const forEach = curry((pipe, arr) => arr.forEach(pipe));
-const both = curry((cond1, cond2, s) => cond2(s) && cond1(s));
+const concat = curry2(((a, b) => a.concat(b)));
+const join = curry2((delimeter, arr) => arr.join(delimeter));
+const map = curry2((pipe, arr) => arr.map(pipe));
+const forEach = curry2((pipe, arr) => arr.forEach(pipe));
+const both = curry3((cond1, cond2, s) => cond2(s) && cond1(s));
 const isEmpty = (s) => {
     switch (type(s)) {
         case 'String':
@@ -335,8 +372,8 @@ const empty = (s) => {
         default: return undef;
     }
 };
-const replace = curry((a, b, where) => where.replace(a, b));
-const filter = curry((cond, data) => isArray(data)
+const replace = curry3((a, b, where) => where.replace(a, b));
+const filter = curry2((cond, data) => isArray(data)
     ? data.filter(cond)
     : compose(fromPairs, filter(([k, v]) => cond(v, k)), toPairs)(data));
 const memoize = (fn) => {
@@ -344,13 +381,13 @@ const memoize = (fn) => {
     let cached = false;
     return () => cached ? cache : (cached = true, cache = fn());
 };
-const mergeShallow = curry((o1, o2) => Object.assign({}, o1, o2));
-const mergeDeep = curry((a, b) => qmergeDeep(clone(a), clone(b)));
-const mergeDeepX = curry((a, b) => qmergeDeepX(clone(a), clone(b)));
-const mergeDeepAdd = curry((a, b) => qmergeDeepAdd(clone(a), clone(b)));
-const overProp = curry((prop, pipe, data) => assoc(prop, pipe(data[prop]), data));
+const mergeShallow = curry2((o1, o2) => Object.assign({}, o1, o2));
+const mergeDeep = curry2((a, b) => qmergeDeep(clone(a), clone(b)));
+const mergeDeepX = curry2((a, b) => qmergeDeepX(clone(a), clone(b)));
+const mergeDeepAdd = curry2((a, b) => qmergeDeepAdd(clone(a), clone(b)));
+const overProp = curry3((prop, pipe, data) => assoc(prop, pipe(data[prop]), data));
 /** mapKeys({ a: 'b' }, { a: 44 }) -> { b: 44 } */
-const mapKeys = curry((keyMap, o) => qmapKeys(keyMap, Object.assign({}, o)));
+const mapKeys = curry2((keyMap, o) => qmapKeys(keyMap, Object.assign({}, o)));
 // ASYNCS
 /** One promise waits for another. */
 const forEachSerial = (() => {
@@ -360,12 +397,13 @@ const forEachSerial = (() => {
             await pipe(fn, items, ++i);
         }
     };
-    return curry((fn, items) => pipe(fn, items, 0));
+    return curry2((fn, items) => pipe(fn, items, 0));
 })();
 /** Promise.all wrapper for functional pipelining. */
 const waitAll = (promises) => Promise.all(promises);
+const waitTap = curry2(async (fn, s) => { await fn(s); return s; });
 /** Waits for all promises mapped by the fn. */
-const forEachAsync = curry((fn, items) => Promise.all(items.map(fn)));
+const forEachAsync = curry2((fn, items) => Promise.all(items.map(fn)));
 /** The same as compose, but waits for promises in chains and returns a Promise.  */
 const composeAsync = (() => {
     const pipe = async (fns, data, i) => ~i ? await pipe(fns, await fns[i](data), --i) : data;
@@ -422,6 +460,9 @@ var pepka = /*#__PURE__*/Object.freeze({
   __proto__: null,
   __: __,
   curry: curry,
+  curry2: curry2,
+  curry3: curry3,
+  uncurry: uncurry,
   toLower: toLower,
   toUpper: toUpper,
   type: type,
@@ -486,6 +527,7 @@ var pepka = /*#__PURE__*/Object.freeze({
   pathEq: pathEq,
   pathsEq: pathsEq,
   clone: clone,
+  cloneShallow: cloneShallow,
   reduce: reduce,
   pickBy: pickBy,
   pick: pick,
@@ -509,6 +551,7 @@ var pepka = /*#__PURE__*/Object.freeze({
   mapKeys: mapKeys,
   forEachSerial: forEachSerial,
   waitAll: waitAll,
+  waitTap: waitTap,
   forEachAsync: forEachAsync,
   composeAsync: composeAsync,
   mirror: mirror,

package/package.json

@@ -19,6 +19,7 @@
     "d.ts"
   ],
   "license": "MIT",
+  "type": "module",
   "main": "dist/bundle.js",
   "module": "dist/es/index.js",
   "name": "pepka",
@@ -38,15 +39,13 @@
     "prod": "npm run gentypes && npm run prod:es && npm run prod:cjs",
     "all": "npm run dev && npm run prod"
   },
-  "version": "0.12.3",
+  "version": "0.13.0b1",
   "ava": {
     "files": [
       "./test/specs/*.ts"
     ],
-    "serial": false,
     "failFast": true,
     "timeout": "2m",
-    "compileEnhancements": false,
     "extensions": [
       "ts"
     ],
@@ -55,23 +54,23 @@
     ]
   },
   "devDependencies": {
-    "@types/node": "^15.12.4",
-    "ava": "^3.15.0",
+    "@types/node": "^18.11.10",
+    "ava": "^5.1.0",
     "codecov": "^3.8.2",
     "cross-env": "^7.0.3",
-    "dts-bundle-generator": "^5.9.0",
+    "dts-bundle-generator": "^7.1.0",
     "nyc": "^15.1.0",
-    "rollup": "^2.52.1",
+    "rollup": "^3.5.1",
     "rollup-plugin-commonjs": "^10.1.0",
     "rollup-plugin-node-resolve": "^5.2.0",
     "rollup-plugin-replace": "^2.2.0",
     "rollup-plugin-resolve-aliases": "^0.3.0",
     "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.30.0",
-    "ts-node": "^10.0.0",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "ts-node": "^10.9.1",
     "ts-toolbelt": "^9.6.0",
     "tslint": "^6.1.0",
-    "typescript": "^4.3.4"
+    "typescript": "^4.9.3"
   },
   "types": "./dist/bundle.d.ts",
   "sideEffects": false

package/rollup.config.js

@@ -3,6 +3,7 @@ import resolve from 'rollup-plugin-node-resolve'
 import typescript from 'rollup-plugin-typescript2'
 import { terser } from 'rollup-plugin-terser'
 import replace from 'rollup-plugin-replace'
+import tsc from 'typescript'
 
 export default {
   input: process.env.NODE_ENV=='development' ? 'test/in-browser.ts' : 'src/index.ts',
@@ -16,7 +17,7 @@ export default {
     resolve(),
     commonjs(),
     typescript({
-      typescript: require("typescript"),
+      typescript: tsc,
       tsconfig: "./tsconfig.json",
       tsconfigOverride: {
         compilerOptions: {

package/src/curry.ts

@@ -1,9 +1,9 @@
+import { F as FT, A } from 'ts-toolbelt'
+import { AnyFunc, AnyArgs } from "./types"
 
-type Args = any[]
+export const __ = Symbol('Placeholder') as A.x
 
-export const __ = (function Placeholder() {})
-
-const countArgs = (s: Args) => {
+const countArgs = (s: AnyArgs) => {
   let i = 0
   for (const v of s) v!==__ && i++
   return i
@@ -11,7 +11,7 @@ const countArgs = (s: Args) => {
 
 // TODO: try to make it mutable.
 // { 0: __, 1: 10 }, [ 11 ]
-const addArgs = (args: Args, _args: Args) => {
+const addArgs = (args: AnyArgs, _args: AnyArgs) => {
   const len = args.length
   const new_args = args.slice()
   const _args_len = _args.length
@@ -29,12 +29,12 @@ const addArgs = (args: Args, _args: Args) => {
   return new_args
 }
 
-const _curry = (fn: Function, args: Args, new_args: Args) => {
+const _curry = (fn: Function, args: AnyArgs, new_args: AnyArgs) => {
   const args2add = fn.length - args.length - countArgs(new_args)
   if(args2add < 1) {
     return fn(...addArgs(args, new_args))
   } else {
-    const curried = (...__args: Args) => _curry(
+    const curried = (...__args: AnyArgs) => _curry(
       fn,
       addArgs(args, new_args),
       __args
@@ -45,9 +45,55 @@ const _curry = (fn: Function, args: Args, new_args: Args) => {
 }
 
 export const curry = (
-  (fn: Function) => (
-    (...args: Args) => fn.length>countArgs(args)
+  <Func extends AnyFunc>(fn: AnyFunc) => (
+    (...args: AnyArgs) => fn.length>countArgs(args)
       ? _curry(fn, [], args)
       : fn(...args)
-  )
-)
+  ) as FT.Curry<Func>
+)
+// type EndlessPh<Func extends FT.Function, ArgT> =
+//   (a: ArgT) => ReturnType<Func>
+//   | ((a: A.x) => EndlessPh<Func, ArgT>)
+const endlessph = <Func extends FT.Function>(fn: Func) => {
+  type ReturnT = ReturnType<Func>
+  type p0 = Parameters<Func>[0]
+  function _endlessph(a: p0): ReturnT
+  function _endlessph(a: A.x): Func
+  function _endlessph(a: p0 | A.x) {
+    return a===__ ? fn : fn(a)
+  }
+  return _endlessph
+}
+
+type Func2 = (a: any, b: any) => any
+export function curry2<Func extends Func2>(fn: Func) {
+  type p0 = Parameters<Func>[0]
+  type p1 = Parameters<Func>[1]
+  type ReturnT = ReturnType<Func>
+  function curried2( a: p0 ): (b: p1) => ReturnT
+  function curried2( a: p0, b: p1 ): ReturnT
+  function curried2( a: A.x, b: p1 ): (a: p0) => ReturnT
+  function curried2( a: p0, b: A.x ): (b: p1) => ReturnT
+  function curried2( a: p0 | A.x, b?: p1 ) {
+    const withPlaceholder1 = a===__
+    const aln = arguments.length
+    if(aln === 1 && withPlaceholder1)
+      throw new Error('Senseless placeholder usage.')
+    return arguments.length>1
+    ? withPlaceholder1
+      ? endlessph((a: p0) => fn(a, b))
+      : fn(a, b) as ReturnType<Func>
+    : (b: p1) => fn(a, b)
+  }
+  return curried2
+}
+
+type Func3 = (a: any, b: any, c: any) => any
+export function curry3<Func extends Func3>(fn: Func) {
+  // type p0 = Parameters<Func>[0]
+  // type p1 = Parameters<Func>[1]
+  // type p2 = Parameters<Func>[2]
+  // type ReturnT = ReturnType<Func>
+  // TODO: optimize.
+  return curry(fn)
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 
 export * from './curry'
+export * from './uncurry'
 export * from './common'
 export * from './safe'
 export * from './quick'

package/src/quick.ts

@@ -1,21 +1,21 @@
-import { curry } from "./curry"
+import { curry, curry2, curry3 } from "./curry"
 import { type } from "./common"
 import { AnyObject, Reducer, AnyFunc } from "./types"
 import { isFunc, isArray } from "./utils"
 
-export const qappend = curry((s: any, xs: any[]) => {xs.push(s); return xs})
-export const qassoc = curry(
+export const qappend = curry2((s: any, xs: any[]) => {xs.push(s); return xs})
+export const qassoc = curry3(
   (prop: string, v: any, obj: AnyObject) => {
     obj[prop] = v
     return obj
   }
 )
-export const qreduce = curry(
+export const qreduce = curry3(
   (fn: Reducer, accum: any, arr: any[]) =>
     arr.reduce(fn, accum)
 )
 // strategy is for arrays: 1->clean, 2->merge, 3->push.
-const mergeDeep = curry((strategy: 1|2|3, o1: AnyObject, o2: AnyObject): AnyObject => {
+const mergeDeep = curry3((strategy: 1|2|3, o1: AnyObject, o2: AnyObject): AnyObject => {
   for(let k in o2) {
     switch(type(o2[k])) {
       case 'Array':
@@ -54,7 +54,7 @@ export const qmergeDeep = mergeDeep(1)
 export const qmergeDeepX = mergeDeep(2)
 export const qmergeDeepAdd = mergeDeep(3)
 /** qmapKeys({ a: 'b' }, { a: 44 }) -> { b: 44 } */
-export const qmapKeys = curry(
+export const qmapKeys = curry2(
   (
     keyMap: {[oldKey: string]: string},
     o: AnyObject
@@ -74,7 +74,7 @@ export const qmapKeys = curry(
   }
 )
 
-export const qfilter = curry(
+export const qfilter = curry2(
   (
     cond: (v: any, k: string | number) => boolean,
     data: any[] | AnyObject
@@ -94,6 +94,6 @@ export const qfilter = curry(
   }
 )
 /** @deprecated */
-export const qindexOf = curry(
+export const qindexOf = curry2(
   (x: any, xs: any[]) => xs.indexOf(x)
 )

package/src/safe.ts

@@ -1,11 +1,12 @@
-import { __, curry } from './curry'
+import { __, curry, curry2, curry3 } from './curry'
 import { isNum, nul, isUndef, undef, isNull, isArray, isFunc, isStr, isObj } from './utils'
 import { qmergeDeep, qreduce, qappend, qmapKeys, qmergeDeepX, qmergeDeepAdd } from './quick'
 import { AnyFunc, Cond, AnyObject, Reducer } from './types'
 import { type } from './common'
+import { F as FT } from 'ts-toolbelt'
 // over, lensProp
 
-export const equals = curry((a: any, b: any) => {
+export const equals = curry2((a: any, b: any) => {
   const typea = type(a)
   if(typea===type(b) && (typea==='Object' || typea=='Array')) {
     if(isNull(a) || isNull(b)) {
@@ -36,30 +37,31 @@ export const ifElse = curry(
     s: any
   ) => cond(s) ? pipeYes(s) : pipeNo(s)
 )
-export const when = curry(
+export const when = curry3(
   (
     cond: (s: any) => boolean,
     pipe: (s: any) => any,
     s: any
   ) => ifElse(cond, pipe, identity, s)
 )
-export const compose = (
-  (...fns: Function[]) =>
+export const compose: FT.Compose = (
+  (...fns: AnyFunc[]) =>
     (s: any = __) => {
       for(let i = length(fns)-1; i>-1; i--) {
         s = s===__ ? fns[i]() : fns[i](s)
       }
       return s
     }
-)// as F.Compose
+)
 
-export const bind = curry(
+export const bind = curry2<AnyFunc>(
   (fn: AnyFunc, context: any) => fn.bind(context)
 )
-export const nth = curry(
-  (i: number, data: any[]) => data[i]
-)
-export const includes = curry(
+
+const _nth = <T=any>(i: number, data: T[]) => data[i]
+export const nth = curry2(_nth)
+
+export const includes = curry2(
   (s: any, ss: any[]) => {
     if(isStr(ss)) {
       return ss.includes(s)
@@ -73,14 +75,14 @@ export const includes = curry(
     }
   }
 )
-export const slice = curry(
+export const slice = curry3(
   (from: number, to: number|null, o: any[] | string) =>
     o.slice(from, (isNum(to)?to:Infinity) as number)
 )
 export const head = nth(0)
 export const tail = slice(1, nul)
-export const add = curry((n: number, m: number) => n+m)
-export const subtract = curry((n: number, m: number) => m-n)
+export const add = curry2((n: number, m: number) => n+m)
+export const subtract = curry2((n: number, m: number) => m-n)
 export const flip = (fn: Function) => curry((b: any, a: any) => fn(a, b))
 export const isNil = (s: any) => isNull(s) || isUndef(s)
 export const length = (s: any[] | string) => s.length
@@ -96,10 +98,10 @@ export const complement = (fn: AnyFunc) => (...args: any) => {
 export const keys = (o: AnyObject | any[]) => Object.keys(o)
 export const values = (o: AnyObject | any[]) => Object.values(o)
 export const toPairs = (o: AnyObject | any[]) => Object.entries(o)
-export const test = curry((re: RegExp, s: string) => re.test(s))
-export const tap = curry((fn: Function, s: any) => { fn(s); return s })
-export const append = curry((s: any, xs: any[]) => [...xs, s])
-export const split = curry((s: string, xs: string) => xs.split(s))
+export const test = curry2((re: RegExp, s: string) => re.test(s))
+export const tap = curry2((fn: Function, s: any) => { fn(s); return s })
+export const append = curry2((s: any, xs: any[]) => [...xs, s])
+export const split = curry2((s: string, xs: string) => xs.split(s))
 export const T = always<true>(true) as (...args: any[]) => true
 export const F = always<false>(false) as (...args: any[]) => false
 export const sizeof = (s: any[] | string | AnyObject) => {
@@ -109,17 +111,17 @@ export const sizeof = (s: any[] | string | AnyObject) => {
     return len
   } else return length(s as any[])
 }
-export const range = curry((from: number, to: number) =>
+export const range = curry2((from: number, to: number) =>
   genBy(add(from), to-from)
 )
 export const uniq = (xs: any[]) => qreduce(
   (accum: any[], x: any) =>
     includes(x, accum) ? accum : qappend(x, accum),
 [], xs)
-export const intersection = curry(
+export const intersection = curry2(
   (xs1: any[], xs2: any[]) => xs1.filter(flip(includes)(xs2))
 )
-export const genBy = curry(
+export const genBy = curry2(
   (
     generator: (i: number) => any,
     length: number
@@ -144,33 +146,18 @@ export const reverse = (xs: any[]) => compose(
   add(-1),
   length
 )(xs)
-export const gt = curry(
-  (a: number, b: number) => a>b
-)
-export const lt = curry(
-  (a: number, b: number) => a<b
-)
-export const gte = curry(
-  (a: number, b: number) => b>=a
-)
-export const lte = curry(
-  (a: number, b: number) => b<=a
-)
-// : <U=any>(sortFn: (v: U)=>-1|1, xs: U[]) => U[] 
-export const sort = curry((sortFn: any, xs: any[]) => xs.sort(sortFn))
-export const find = curry(
-  (fn: Cond, s: any[]) => s.find(fn)
-)
-export const findIndex = curry(
-  (fn: Cond, s: any[]) => s.findIndex(fn)
-)
-export const indexOf = curry(
-  (x: any, xs: any[]) => findIndex(equals(x), xs)
-)
+export const gt = curry2( (a: number, b: number) => a>b )
+export const lt = curry2( (a: number, b: number) => a<b )
+export const gte = curry2( (a: number, b: number) => b>=a )
+export const lte = curry2( (a: number, b: number) => b<=a )
+export const sort = curry2((sortFn: any, xs: any[]) => xs.sort(sortFn))
+export const find = curry2((fn: Cond, s: any[]) => s.find(fn))
+export const findIndex = curry2((fn: Cond, s: any[]) => s.findIndex(fn))
+export const indexOf = curry2((x: any, xs: any[]) => findIndex(equals(x), xs))
 export const explore = (caption: string, level = 'log') => tap(
   (v: any) => console[level](caption, v)
 )
-export const cond = curry(
+export const cond = curry2(
   (pairs: [Cond, Function][], s: any) => {
     for(const [cond, fn] of pairs) {
       if(cond(s)) {
@@ -179,13 +166,13 @@ export const cond = curry(
     }
   }
 )
-export const assoc = curry(
+export const assoc = curry3(
   (prop: string, v: any, obj: AnyObject) => ({
     ...obj,
     [prop]: v
   })
 )
-export const assocPath = curry(
+export const assocPath = curry3(
   (_path: string[], v: any, o: AnyObject) => compose(
     (first: string) => assoc(
       first,
@@ -197,24 +184,22 @@ export const assocPath = curry(
     head
   )(_path)
 )
-export const all = curry((pred: Cond, xs: any[]) => xs.every(pred))
-export const any = curry((pred: Cond, xs: any[]) => xs.some(pred))
-export const allPass = curry(
+export const all = curry2((pred: Cond, xs: any[]) => xs.every(pred))
+export const any = curry2((pred: Cond, xs: any[]) => xs.some(pred))
+export const allPass = curry2(
   (preds: Cond[], x: any) => preds.every((pred) => pred(x))
 )
-export const anyPass = curry(
+export const anyPass = curry2(
   (preds: Cond[], x: any) => preds.some((pred) => pred(x))
 )
-export const prop = curry(
-  (key: string, o: AnyObject) => o[key]
-)
-export const propEq = curry(
+export const prop = curry2( (key: string, o: AnyObject) => o[key] )
+export const propEq = curry3(
   (key: string, value: any, o: AnyObject) => equals(o[key], value)
 )
-export const propsEq = curry(
+export const propsEq = curry3(
   (key: string, o1: any, o2: AnyObject) => equals(o1[key], o2[key])
 )
-export const pathOr = curry(
+export const pathOr = curry3(
   (_default: any, path: string[], o: any) =>
     ifElse(length,
       () => isNil(o)
@@ -231,20 +216,21 @@ export const pathOr = curry(
     path)
 )
 export const path = pathOr(undef)
-export const pathEq = curry(
+export const pathEq = curry3(
   (_path: string[], value: any, o: AnyObject) => equals(path(_path, o), value)
 )
-export const pathsEq = curry(
+export const pathsEq = curry3(
   (_path: string[], o1: AnyObject, o2: AnyObject) =>
     equals(path(_path, o1), path(_path, o2))
 )
 const typed_arr_re = /^(.*?)(8|16|32|64)(Clamped)?Array$/
-export const clone = (s: any) => {
+export const clone = (s: any, shallow = false) => {
   const t = type(s)
   switch(t) {
     case 'Null': return s
-    case 'Array': return map(clone, s)
+    case 'Array': return shallow ? [...s] : map(clone, s)
     case 'Object':
+      if(shallow) return {...s}
       const out = {}
       for(let k in s) {
         out[k] = clone(s[k])
@@ -254,17 +240,19 @@ export const clone = (s: any) => {
     case 'Boolean': case 'Symbol':
       return s
     default:
-      return typed_arr_re.test(t) ? map(clone, s) : s
+      return typed_arr_re.test(t) ? s.constructor.from(s) : s
   }
 }
-export const reduce = curry(
+export const cloneShallow = (s: any) => clone(s, true)
+
+export const reduce = curry3(
   (fn: Reducer, accum: any, arr: any[]) =>
     qreduce(fn, clone(accum), arr)
 )
-export const pickBy = curry(
+export const pickBy = curry2(
   (cond: Cond, o: AnyObject) => filter(cond, o)
 )
-export const pick = curry(
+export const pick = curry2(
   (props: string[], o: AnyObject) => {
     const out = {}
     for(const p of props) {
@@ -275,7 +263,7 @@ export const pick = curry(
     return out
   }
 )
-export const omit = curry(
+export const omit = curry2(
   (props: string[], o: AnyObject) => filter(
     (_: any, k: string) => !includes(k, props),
     o
@@ -287,19 +275,19 @@ export const fromPairs = (pairs: [string, any][]) => reduce(
 )
 type Concat = ((a: string, b: string) => string)
             | ((a: any[], b: any[]) => any[])
-export const concat = curry(
+export const concat = curry2(
   ((a, b) => a.concat(b)) as Concat
 )
-export const join = curry(
+export const join = curry2(
   (delimeter: string, arr: string[]) => arr.join(delimeter)
 )
-export const map = curry(
+export const map = curry2(
   (pipe: (s: any) => any, arr: any[]) => arr.map(pipe)
 )
-export const forEach = curry(
+export const forEach = curry2(
   (pipe: (s: any) => any, arr: any[]) => arr.forEach(pipe)
 )
-export const both = curry(
+export const both = curry3(
   (cond1: Cond, cond2: Cond, s: any) => cond2(s) && cond1(s)
 )
 export const isEmpty = (s: any) => {
@@ -319,14 +307,14 @@ export const empty = (s: any) => {
     default: return undef
   }
 }
-export const replace = curry(
+export const replace = curry3(
   (
     a: string | RegExp,
     b: string,
     where: string
   ) => where.replace(a, b)
 )
-export const filter = curry(
+export const filter = curry2(
   (
     cond: (v: any, k: string | number) => boolean,
     data: any[] | AnyObject
@@ -343,25 +331,25 @@ export const memoize = (fn: Function) => {
   let cached = false
   return () => cached ? cache : (cached = true, cache = fn())
 }
-export const mergeShallow = curry(
+export const mergeShallow = curry2(
   (o1: AnyObject, o2: AnyObject): AnyObject =>
     Object.assign({}, o1, o2)
 )
-export const mergeDeep = curry(
+export const mergeDeep = curry2(
   (a: AnyObject, b: AnyObject) => qmergeDeep(clone(a), clone(b))
 )
-export const mergeDeepX = curry(
+export const mergeDeepX = curry2(
   (a: AnyObject, b: AnyObject) => qmergeDeepX(clone(a), clone(b))
 )
-export const mergeDeepAdd = curry(
+export const mergeDeepAdd = curry2(
   (a: AnyObject, b: AnyObject) => qmergeDeepAdd(clone(a), clone(b))
 )
-export const overProp = curry(
+export const overProp = curry3(
   (prop: string, pipe: AnyFunc, data: any) =>
     assoc(prop, pipe(data[prop]), data)
 )
 /** mapKeys({ a: 'b' }, { a: 44 }) -> { b: 44 } */
-export const mapKeys = curry(
+export const mapKeys = curry2(
   (
     keyMap: {[oldKey: string]: string},
     o: AnyObject
@@ -378,14 +366,15 @@ export const forEachSerial = (() => {
       await pipe(fn, items, ++i)
     }
   }
-  return curry(
+  return curry2(
     (fn: AnyFunc, items: any[]) => pipe(fn, items, 0)
   )
 })()
 /** Promise.all wrapper for functional pipelining. */
 export const waitAll = (promises: Promise<any>[]) => Promise.all(promises)
+export const waitTap = curry2(async (fn: Function, s: any) => { await fn(s); return s })
 /** Waits for all promises mapped by the fn. */
-export const forEachAsync = curry(
+export const forEachAsync = curry2(
   (fn: (item: any) => Promise<any>, items: any[]) =>
     Promise.all(items.map(fn))
 )
@@ -395,10 +384,9 @@ export const composeAsync = (() => {
     ~i ? await pipe(fns, await fns[i](data), --i) : data
   return <T = any>(...fns: AnyFunc[]) =>
     (data?: any) => pipe(fns, data, fns.length-1) as Promise<T>
-})()
+})() as FT.Compose<'async'>
 
 // ALIASES
-
 export const mirror = identity
 export const reflect = identity
-export const echo = identity
+export const echo = identity

package/src/types.ts

@@ -1,7 +1,14 @@
-
 export type Cond = (...xs: any[]) => boolean
 export interface AnyObject {
   [k: string]: any
 }
+export type AnyArgs = any[]
+export type Curried<
+  Args extends AnyArgs = AnyArgs,
+  ReturnT = any
+> = (arg: Args[number]) => Curried<Args> | ReturnT
 export type Reducer = <T>(accum: T, cur: any, index: number) => T
-export type AnyFunc = (...args: any[]) => any
+export type AnyFunc<
+  ReturnT = any,
+  Args extends AnyArgs = AnyArgs
+> = (...args: Args) => ReturnT

package/src/uncurry.ts

@@ -0,0 +1,11 @@
+import { qreduce } from "./quick"
+import { AnyFunc, Curried } from "./types"
+
+// TODO: possibly introduce a second argument limiting unfolding.
+export const uncurry = <
+  Args extends any[] = any[],
+  ReturnT = any
+>(fn: Curried<Args>): AnyFunc =>
+  (...args: Args) => qreduce(
+    ((fn: Curried<Args>, arg: any) => fn ? fn(arg) : fn), fn, args
+  ) as ReturnT

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "moduleResolution": "Node",
     "lib": [ "esnext", "DOM" ],
     "strictNullChecks": true,
     "target": "esnext",
@@ -14,8 +15,5 @@
     "rootDir": "src",
     "baseUrl": "."
   },
-  "include": [
-    "src/**/*",
-    "src/node_modules/ts-toolbelt/out/index.d.ts"
-  ]
+  "include": [ "src/**/*" ]
 }