pepka 0.12.3 → 0.13.0-b10

package/dist/es/safe.js

@@ -1,9 +1,9 @@
-import { __, curry } from './curry';
-import { isNum, nul, isUndef, undef, isNull, isArray, isFunc, isStr, isObj } from './utils';
+import { __, curry, curry2, curry3 } from './curry';
+import { isNum, isUndef, undef, isNull, isArray, isFunc, isStr, isObj, inf } from './utils';
 import { qmergeDeep, qreduce, qappend, qmapKeys, qmergeDeepX, qmergeDeepAdd } from './quick';
 import { type } from './common';
 // over, lensProp
-export const equals = curry((a, b) => {
+export const equals = curry2((a, b) => {
     const typea = type(a);
     if (typea === type(b) && (typea === 'Object' || typea == 'Array')) {
         if (isNull(a) || isNull(b)) {
@@ -25,16 +25,17 @@ export const equals = curry((a, b) => {
     return a === b;
 });
 export const ifElse = curry((cond, pipeYes, pipeNo, s) => cond(s) ? pipeYes(s) : pipeNo(s));
-export const when = curry((cond, pipe, s) => ifElse(cond, pipe, identity, s));
-export const compose = ((...fns) => (s = __) => {
+export const when = curry3((cond, pipe, s) => ifElse(cond, pipe, identity, s));
+export const compose = ((...fns) => (s = Symbol()) => {
     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((fn, context) => fn.bind(context));
-export const nth = curry((i, data) => data[i]);
-export const includes = curry((s, ss) => {
+});
+export const bind = curry2((fn, context) => fn.bind(context));
+const _nth = (i, data) => data[i];
+export const nth = curry2(_nth);
+export const includes = curry2((s, ss) => {
     if (isStr(ss)) {
         return ss.includes(s);
     }
@@ -47,11 +48,11 @@ export const includes = curry((s, ss) => {
         return false;
     }
 });
-export const slice = curry((from, to, o) => o.slice(from, (isNum(to) ? to : Infinity)));
+export const slice = curry3((from, to, o) => o.slice(from, (isNum(to) ? to : inf)));
 export const head = nth(0);
-export const tail = slice(1, nul);
-export const add = curry((n, m) => n + m);
-export const subtract = curry((n, m) => m - n);
+export const tail = slice(1, inf); // typeshit.
+export const add = curry2((n, m) => n + m);
+export const subtract = curry2((n, m) => m - n);
 export const flip = (fn) => curry((b, a) => fn(a, b));
 export const isNil = (s) => isNull(s) || isUndef(s);
 export const length = (s) => s.length;
@@ -67,10 +68,10 @@ export const complement = (fn) => (...args) => {
 export const keys = (o) => Object.keys(o);
 export const values = (o) => Object.values(o);
 export const toPairs = (o) => Object.entries(o);
-export const test = curry((re, s) => re.test(s));
-export const tap = curry((fn, s) => { fn(s); return s; });
-export const append = curry((s, xs) => [...xs, s]);
-export const split = curry((s, xs) => xs.split(s));
+export const test = curry2((re, s) => re.test(s));
+export const tap = curry2((fn, s) => { fn(s); return s; });
+export const append = curry2((s, xs) => [...xs, s]);
+export const split = curry2((s, xs) => xs.split(s));
 export const T = always(true);
 export const F = always(false);
 export const sizeof = (s) => {
@@ -83,10 +84,10 @@ export const sizeof = (s) => {
     else
         return length(s);
 };
-export const range = curry((from, to) => genBy(add(from), to - from));
+export const range = curry2((from, to) => genBy(add(from), to - from));
 export const uniq = (xs) => qreduce((accum, x) => includes(x, accum) ? accum : qappend(x, accum), [], xs);
-export const intersection = curry((xs1, xs2) => xs1.filter(flip(includes)(xs2)));
-export const genBy = curry((generator, length) => [...Array(length)].map((_, i) => generator(i)));
+export const intersection = curry2((xs1, xs2) => xs1.filter(flip(includes)(xs2)));
+export const genBy = curry2((generator, length) => [...Array(length)].map((_, i) => generator(i)));
 export const once = (fn) => {
     let done = false, cache;
     return (...args) => {
@@ -100,50 +101,51 @@ export const once = (fn) => {
     };
 };
 export const reverse = (xs) => compose((ln) => reduce((nxs, _, i) => qappend(xs[ln - i], nxs), [], xs), add(-1), length)(xs);
-export const gt = curry((a, b) => a > b);
-export const lt = curry((a, b) => a < b);
-export const gte = curry((a, b) => b >= a);
-export const lte = curry((a, b) => b <= a);
-// : <U=any>(sortFn: (v: U)=>-1|1, xs: U[]) => U[] 
-export const sort = curry((sortFn, xs) => xs.sort(sortFn));
-export const find = curry((fn, s) => s.find(fn));
-export const findIndex = curry((fn, s) => s.findIndex(fn));
-export const indexOf = curry((x, xs) => findIndex(equals(x), xs));
+export const gt = curry2((a, b) => a > b);
+export const lt = curry2((a, b) => a < b);
+export const gte = curry2((a, b) => b >= a);
+export const lte = curry2((a, b) => b <= a);
+export const sort = curry2((sortFn, xs) => xs.sort(sortFn));
+export const find = curry2((fn, s) => s.find(fn));
+export const findIndex = curry2((fn, s) => s.findIndex(fn));
+export const indexOf = curry2((x, xs) => findIndex(equals(x), xs));
 export const explore = (caption, level = 'log') => tap((v) => console[level](caption, v));
-export const cond = curry((pairs, s) => {
+export const cond = curry2((pairs, s) => {
     for (const [cond, fn] of pairs) {
         if (cond(s)) {
             return fn(s);
         }
     }
 });
-export const assoc = curry((prop, v, obj) => ({
+export const assoc = curry3((prop, v, obj) => ({
     ...obj,
     [prop]: v
 }));
-export const assocPath = curry((_path, v, o) => compose((first) => assoc(first, length(_path) < 2
+export 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));
-export const all = curry((pred, xs) => xs.every(pred));
-export const any = curry((pred, xs) => xs.some(pred));
-export const allPass = curry((preds, x) => preds.every((pred) => pred(x)));
-export const anyPass = curry((preds, x) => preds.some((pred) => pred(x)));
-export const prop = curry((key, o) => o[key]);
-export const propEq = curry((key, value, o) => equals(o[key], value));
-export const propsEq = curry((key, o1, o2) => equals(o1[key], o2[key]));
-export const pathOr = curry((_default, path, o) => ifElse(length, () => isNil(o)
+    : assocPath(slice(1, inf, _path), v, isObj(o[first]) ? o[first] : {}), o), head)(_path));
+export const all = curry2((pred, xs) => xs.every(pred));
+export const any = curry2((pred, xs) => xs.some(pred));
+export const allPass = curry2((preds, x) => preds.every((pred) => pred(x)));
+export const anyPass = curry2((preds, x) => preds.some((pred) => pred(x)));
+export const prop = curry2((key, o) => o[key]);
+export const propEq = curry3((key, value, o) => equals(o[key], value));
+export const propsEq = curry3((key, o1, o2) => equals(o1[key], o2[key]));
+export 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));
+    : compose(ifElse(isNil, always(_default), (o) => pathOr(_default, slice(1, inf, path), o)), flip(prop)(o), head)(path), always(o), path));
 export const path = pathOr(undef);
-export const pathEq = curry((_path, value, o) => equals(path(_path, o), value));
-export const pathsEq = curry((_path, o1, o2) => equals(path(_path, o1), path(_path, o2)));
+export const pathEq = curry3((_path, value, o) => equals(path(_path, o), value));
+export const pathsEq = curry3((_path, o1, o2) => equals(path(_path, o1), path(_path, o2)));
 const typed_arr_re = /^(.*?)(8|16|32|64)(Clamped)?Array$/;
-export const clone = (s) => {
+export 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]);
@@ -155,12 +157,13 @@ export 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;
     }
 };
-export const reduce = curry((fn, accum, arr) => qreduce(fn, clone(accum), arr));
-export const pickBy = curry((cond, o) => filter(cond, o));
-export const pick = curry((props, o) => {
+export const cloneShallow = (s) => clone(s, true);
+export const reduce = curry3((fn, accum, arr) => qreduce(fn, clone(accum), arr));
+export const pickBy = curry2((cond, o) => filter(cond, o));
+export const pick = curry2((props, o) => {
     const out = {};
     for (const p of props) {
         if (p in o) {
@@ -169,13 +172,13 @@ export const pick = curry((props, o) => {
     }
     return out;
 });
-export const omit = curry((props, o) => filter((_, k) => !includes(k, props), o));
+export const omit = curry2((props, o) => filter((_, k) => !includes(k, props), o));
 export const fromPairs = (pairs) => reduce((o, pair) => assoc(...pair, o), {}, pairs);
-export const concat = curry(((a, b) => a.concat(b)));
-export const join = curry((delimeter, arr) => arr.join(delimeter));
-export const map = curry((pipe, arr) => arr.map(pipe));
-export const forEach = curry((pipe, arr) => arr.forEach(pipe));
-export const both = curry((cond1, cond2, s) => cond2(s) && cond1(s));
+export const concat = curry2(((a, b) => a.concat(b)));
+export const join = curry2((delimeter, arr) => arr.join(delimeter));
+export const map = curry2((pipe, arr) => arr.map(pipe));
+export const forEach = curry2((pipe, arr) => arr.forEach(pipe));
+export const both = curry3((cond1, cond2, s) => cond2(s) && cond1(s));
 export const isEmpty = (s) => {
     switch (type(s)) {
         case 'String':
@@ -195,8 +198,8 @@ export const empty = (s) => {
         default: return undef;
     }
 };
-export const replace = curry((a, b, where) => where.replace(a, b));
-export const filter = curry((cond, data) => isArray(data)
+export const replace = curry3((a, b, where) => where.replace(a, b));
+export const filter = curry2((cond, data) => isArray(data)
     ? data.filter(cond)
     : compose(fromPairs, filter(([k, v]) => cond(v, k)), toPairs)(data));
 export const memoize = (fn) => {
@@ -204,13 +207,13 @@ export const memoize = (fn) => {
     let cached = false;
     return () => cached ? cache : (cached = true, cache = fn());
 };
-export const mergeShallow = curry((o1, o2) => Object.assign({}, o1, o2));
-export const mergeDeep = curry((a, b) => qmergeDeep(clone(a), clone(b)));
-export const mergeDeepX = curry((a, b) => qmergeDeepX(clone(a), clone(b)));
-export const mergeDeepAdd = curry((a, b) => qmergeDeepAdd(clone(a), clone(b)));
-export const overProp = curry((prop, pipe, data) => assoc(prop, pipe(data[prop]), data));
+export const mergeShallow = curry2((o1, o2) => Object.assign({}, o1, o2));
+export const mergeDeep = curry2((a, b) => qmergeDeep(clone(a), clone(b)));
+export const mergeDeepX = curry2((a, b) => qmergeDeepX(clone(a), clone(b)));
+export const mergeDeepAdd = curry2((a, b) => qmergeDeepAdd(clone(a), clone(b)));
+export const overProp = curry3((prop, pipe, data) => assoc(prop, pipe(data[prop]), data));
 /** mapKeys({ a: 'b' }, { a: 44 }) -> { b: 44 } */
-export const mapKeys = curry((keyMap, o) => qmapKeys(keyMap, Object.assign({}, o)));
+export const mapKeys = curry2((keyMap, o) => qmapKeys(keyMap, Object.assign({}, o)));
 // ASYNCS
 /** One promise waits for another. */
 export const forEachSerial = (() => {
@@ -220,12 +223,13 @@ export 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. */
 export const waitAll = (promises) => Promise.all(promises);
+export const waitTap = curry2(async (fn, s) => { await fn(s); return s; });
 /** Waits for all promises mapped by the fn. */
-export const forEachAsync = curry((fn, items) => Promise.all(items.map(fn)));
+export const forEachAsync = curry2((fn, items) => Promise.all(items.map(fn)));
 /** The same as compose, but waits for promises in chains and returns a Promise.  */
 export const composeAsync = (() => {
     const pipe = async (fns, data, i) => ~i ? await pipe(fns, await fns[i](data), --i) : data;

package/dist/es/uncurry.js

@@ -0,0 +1,3 @@
+import { qreduce } from "./quick";
+// TODO: possibly introduce a second argument limiting unfolding.
+export const uncurry = (fn) => (...args) => qreduce(((fn, arg) => fn ? fn(arg) : fn), fn, args);

package/dist/es/utils.js

@@ -1,5 +1,6 @@
 export const undef = undefined;
 export const nul = null;
+export const inf = Infinity;
 export const to = (s) => typeof s;
 export const isNull = (s) => s === nul;
 export const isUndef = (s) => s === undef;

package/dts-fix.js

@@ -0,0 +1,11 @@
+import prepend from 'prepend'
+ 
+const s =
+`import {F as FT} from 'ts-toolbelt'
+export { __ }
+`
+
+prepend('./dist/bundle.d.ts', s, function(error) {
+    if (error)
+        console.error(error.message)
+})

package/package.json

@@ -19,6 +19,7 @@
     "d.ts"
   ],
   "license": "MIT",
+  "type": "module",
   "main": "dist/bundle.js",
   "module": "dist/es/index.js",
   "name": "pepka",
@@ -31,22 +32,21 @@
     "test": "npm run gentypes && npm run prod:cjs && ava",
     "test:report": "nyc npm test && nyc report --reporter=text-lcov > coverage.lcov && codecov",
     "test:lazy": "ava",
-    "gentypes": "dts-bundle-generator -o dist/bundle.d.ts src/index.ts",
+    "dts-fix": "node dts-fix.js",
+    "gentypes": "dts-bundle-generator --no-check -o dist/bundle.d.ts src/index.ts && npm run dts-fix",
     "dev": "cross-env NODE_ENV=development BUILD=es rollup -c",
     "prod:cjs": "cross-env NODE_ENV=production BUILD=cjs rollup -c",
     "prod:es": "cross-env NODE_ENV=production tsc",
     "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.0b10",
   "ava": {
     "files": [
       "./test/specs/*.ts"
     ],
-    "serial": false,
     "failFast": true,
     "timeout": "2m",
-    "compileEnhancements": false,
     "extensions": [
       "ts"
     ],
@@ -54,24 +54,27 @@
       "ts-node/register"
     ]
   },
+  "dependencies": {
+    "ts-toolbelt": "^9.6.0"
+  },
   "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",
+    "prepend": "^1.0.2",
+    "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",
-    "ts-toolbelt": "^9.6.0",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "ts-node": "^10.9.1",
     "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,10 @@
+import { F as FT } from 'ts-toolbelt'
+import { AnyFunc, AnyArgs } from "./types"
 
-type Args = any[]
+type Placeholder = symbol
+export const __: Placeholder = Symbol('Placeholder')
 
-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 +12,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 +30,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 +46,52 @@ 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>
+)
+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: Placeholder): Func
+  function _endlessph(a: p0 | Placeholder) {
+    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: Placeholder, b: p1 ): (a: p0) => ReturnT
+  function curried2( a: p0, b: Placeholder ): (b: p1) => ReturnT
+  function curried2( a: p0 ): (b: p1) => ReturnT
+  function curried2( a: p0, b: p1 ): ReturnT
+  function curried2( a: p0 | Placeholder, 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) as FT.Curry<Func>
+}

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 { 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(
-  (fn: Reducer, accum: any, arr: any[]) =>
+export const qreduce = curry3(
+  <T>(fn: Reducer, accum: any, arr: T[]) =>
     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)
 )