pepka 1.4.1 → 1.4.2

package/dist/bundle.cjs

@@ -136,7 +136,10 @@ const qstartsWithWith = (comparator) => curry2((start, s) => {
     return true;
 });
 
-// TODO: qflat, qpick, qoverProp, qover array ?
+// TODO: qoverProp, qover array ?
+/** Then next fns seem to be excess due to their safe ver performance should be the same or better:
+ * qflat, qpick
+ */
 const qappend = curry2((s, xs) => { xs.push(s); return xs; });
 const qassoc = curry3((prop, v, obj) => { obj[prop] = v; return obj; });
 const qreduce = curry3((fn, accum, arr) => arr.reduce(fn, accum));
@@ -278,15 +281,15 @@ const tail = slice(1, inf);
 const add = curry2((a, b) => a + b);
 /** @param a @param b @returns b-a  */
 const subtract = curry2((a, b) => b - a);
-/**@param a @param b @returns a*b  */
+/**@param a @param b @returns a×b  */
 const multiply = curry2((a, b) => a * b);
 /** @param a @param b @returns a<b  */
 const gt = curry2((a, b) => a < b);
 /** @param a @param b @returns a>b  */
 const lt = curry2((a, b) => a > b);
-/** @param a @param b @returns a<=b  */
+/** @param a @param b @returns a≤b  */
 const gte = curry2((a, b) => a <= b);
-/** @param a @param b @returns a>=b  */
+/** @param a @param b @returns a≥b  */
 const lte = curry2((a, b) => a >= b);
 const sort = curry2((sortFn, xs) => xs.sort(sortFn));
 const find = curry2((fn, s) => s.find(fn));
@@ -316,9 +319,9 @@ const F = always(false);
 const callWith = curry2((args, fn) => fn(...args));
 const noop = (() => { });
 /** Calls a func from object.
- * @param {any[]} [args] - arguments for the function.
- * @param {string} [fnName] - property name of the function.
- * @param {AnyObject} [o] - the object with the function. */
+ * @param {any[]} args - arguments for the function.
+ * @param {string} fnName - property name of the function.
+ * @param {AnyObject} o - the object with the function. */
 const callFrom = curry((args, fn, o) => o[fn](...args));
 const complement = (fn) => (...args) => {
     const out = fn(...args);
@@ -339,7 +342,29 @@ const range = curry2((from, to) => genBy(add(from), to - from));
 /** @param xs any[] @returns xs without duplicates.  */
 const uniq = (xs) => qreduce((accum, x) => find(equals(x), accum) ? accum : qappend(x, accum), [], xs);
 const intersection = curry2((xs1, xs2) => xs1.filter(flip(includes)(xs2)));
-const diff = curry2((xs1, xs2) => xs1.filter(complement(flip(includes)(xs2))));
+const diff = curry2((_xs1, _xs2) => {
+    const len1 = length(_xs1);
+    const len2 = length(_xs2); // xs2 should be shorter 4 Set mem consumption.
+    const xs1 = len1 > len2 ? _xs1 : _xs2;
+    const xs2 = len1 > len2 ? _xs2 : _xs1;
+    const xset2 = new Set(xs2);
+    const common = new Set();
+    const out = [];
+    let i;
+    for (i = 0; i < len1; i++) {
+        const el = xs1[i];
+        if (xset2.has(el))
+            common.add(el);
+        else
+            out.push(el);
+    }
+    for (i = 0; i < len2; i++) {
+        const el = xs2[i];
+        if (!common.has(el))
+            out.push(el);
+    }
+    return out;
+});
 const genBy = curry2((generator, length) => [...Array(length)].map((_, i) => generator(i)));
 const once = (fn) => {
     let done = false, cache;

package/dist/bundle.d.ts

@@ -108,7 +108,7 @@ export declare const subtract: {
 	(a: number): (b: number) => number;
 	(a: number, b: number): number;
 };
-/**@param a @param b @returns a*b  */
+/**@param a @param b @returns a×b  */
 export declare const multiply: {
 	(a: symbol, b: number): (a: number) => number;
 	(a: number, b: symbol): (b: number) => number;
@@ -129,14 +129,14 @@ export declare const lt: {
 	(a: number): (b: number) => boolean;
 	(a: number, b: number): boolean;
 };
-/** @param a @param b @returns a<=b  */
+/** @param a @param b @returns a≤b  */
 export declare const gte: {
 	(a: symbol, b: number): (a: number) => boolean;
 	(a: number, b: symbol): (b: number) => boolean;
 	(a: number): (b: number) => boolean;
 	(a: number, b: number): boolean;
 };
-/** @param a @param b @returns a>=b  */
+/** @param a @param b @returns a≥b  */
 export declare const lte: {
 	(a: symbol, b: number): (a: number) => boolean;
 	(a: number, b: symbol): (b: number) => boolean;
@@ -251,9 +251,9 @@ export declare const callWith: {
 };
 export declare const noop: (...args: any[]) => any;
 /** Calls a func from object.
- * @param {any[]} [args] - arguments for the function.
- * @param {string} [fnName] - property name of the function.
- * @param {AnyObject} [o] - the object with the function. */
+ * @param {any[]} args - arguments for the function.
+ * @param {string} fnName - property name of the function.
+ * @param {AnyObject} o - the object with the function. */
 export declare const callFrom: (...args: AnyArgs) => any;
 export declare const complement: (fn: AnyFunc) => (...args: any) => boolean | any;
 export declare const sizeof: (s: any[] | string | AnyObject) => number;
@@ -501,6 +501,9 @@ export declare const some: {
 	(a: Cond): (b: any[]) => boolean;
 	(a: Cond, b: any[]): boolean;
 };
+/** Then next fns seem to be excess due to their safe ver performance should be the same or better:
+ * qflat, qpick
+ */
 export declare const qappend: {
 	(a: symbol, b: any[]): (a: any) => any[];
 	(a: any, b: symbol): (b: any[]) => any[];
@@ -587,17 +590,17 @@ export declare const forEachSerial: {
 	(a: AnyFunc, b: any[]): Promise<void>;
 };
 /** Promise.all wrapper for functional pipelining. */
-export declare const waitAll: (promises: Promise<any>[]) => Promise<any[]>;
+export declare const waitAll: <T>(promises: Promise<T>[]) => Promise<Awaited<T>[]>;
 /** Waits for a Promise that been generated by the first arg, then returns an untoched value. Types T.
  * @param {AnyFunc<Promise>} fn - function to wait.
  * @param {T} s - any value to tap and return back
  * @returns {T}
  */
 export declare const waitTap: {
-	(a: symbol, b: any): (a: AnyFunc) => Promise<any>;
-	(a: AnyFunc, b: symbol): (b: any) => Promise<any>;
-	(a: AnyFunc): (b: any) => Promise<any>;
-	(a: AnyFunc, b: any): Promise<any>;
+	(a: symbol, b: any): (a: AnyFunc<Promise<any>>) => Promise<any>;
+	(a: AnyFunc<Promise<any>>, b: symbol): (b: any) => Promise<any>;
+	(a: AnyFunc<Promise<any>>): (b: any) => Promise<any>;
+	(a: AnyFunc<Promise<any>>, b: any): Promise<any>;
 };
 /** Waits for all promises mapped by the fn. */
 export declare const forEachAsync: {

package/dist/bundle.mjs

@@ -134,7 +134,10 @@ const qstartsWithWith = (comparator) => curry2((start, s) => {
     return true;
 });
 
-// TODO: qflat, qpick, qoverProp, qover array ?
+// TODO: qoverProp, qover array ?
+/** Then next fns seem to be excess due to their safe ver performance should be the same or better:
+ * qflat, qpick
+ */
 const qappend = curry2((s, xs) => { xs.push(s); return xs; });
 const qassoc = curry3((prop, v, obj) => { obj[prop] = v; return obj; });
 const qreduce = curry3((fn, accum, arr) => arr.reduce(fn, accum));
@@ -276,15 +279,15 @@ const tail = slice(1, inf);
 const add = curry2((a, b) => a + b);
 /** @param a @param b @returns b-a  */
 const subtract = curry2((a, b) => b - a);
-/**@param a @param b @returns a*b  */
+/**@param a @param b @returns a×b  */
 const multiply = curry2((a, b) => a * b);
 /** @param a @param b @returns a<b  */
 const gt = curry2((a, b) => a < b);
 /** @param a @param b @returns a>b  */
 const lt = curry2((a, b) => a > b);
-/** @param a @param b @returns a<=b  */
+/** @param a @param b @returns a≤b  */
 const gte = curry2((a, b) => a <= b);
-/** @param a @param b @returns a>=b  */
+/** @param a @param b @returns a≥b  */
 const lte = curry2((a, b) => a >= b);
 const sort = curry2((sortFn, xs) => xs.sort(sortFn));
 const find = curry2((fn, s) => s.find(fn));
@@ -314,9 +317,9 @@ const F = always(false);
 const callWith = curry2((args, fn) => fn(...args));
 const noop = (() => { });
 /** Calls a func from object.
- * @param {any[]} [args] - arguments for the function.
- * @param {string} [fnName] - property name of the function.
- * @param {AnyObject} [o] - the object with the function. */
+ * @param {any[]} args - arguments for the function.
+ * @param {string} fnName - property name of the function.
+ * @param {AnyObject} o - the object with the function. */
 const callFrom = curry((args, fn, o) => o[fn](...args));
 const complement = (fn) => (...args) => {
     const out = fn(...args);
@@ -337,7 +340,29 @@ const range = curry2((from, to) => genBy(add(from), to - from));
 /** @param xs any[] @returns xs without duplicates.  */
 const uniq = (xs) => qreduce((accum, x) => find(equals(x), accum) ? accum : qappend(x, accum), [], xs);
 const intersection = curry2((xs1, xs2) => xs1.filter(flip(includes)(xs2)));
-const diff = curry2((xs1, xs2) => xs1.filter(complement(flip(includes)(xs2))));
+const diff = curry2((_xs1, _xs2) => {
+    const len1 = length(_xs1);
+    const len2 = length(_xs2); // xs2 should be shorter 4 Set mem consumption.
+    const xs1 = len1 > len2 ? _xs1 : _xs2;
+    const xs2 = len1 > len2 ? _xs2 : _xs1;
+    const xset2 = new Set(xs2);
+    const common = new Set();
+    const out = [];
+    let i;
+    for (i = 0; i < len1; i++) {
+        const el = xs1[i];
+        if (xset2.has(el))
+            common.add(el);
+        else
+            out.push(el);
+    }
+    for (i = 0; i < len2; i++) {
+        const el = xs2[i];
+        if (!common.has(el))
+            out.push(el);
+    }
+    return out;
+});
 const genBy = curry2((generator, length) => [...Array(length)].map((_, i) => generator(i)));
 const once = (fn) => {
     let done = false, cache;

package/package.json

@@ -43,7 +43,7 @@
     "prod": "npm run gentypes && npm run prod:es && npm run prod:cjs",
     "all": "npm run dev && npm run prod"
   },
-  "version": "1.4.1",
+  "version": "1.4.2",
   "ava": {
     "files": [
       "./test/specs/*.ts"

package/src/async.ts

@@ -15,17 +15,16 @@ export const forEachSerial = (() => {
   )
 })()
 /** Promise.all wrapper for functional pipelining. */
-export const waitAll = (promises: Promise<any>[]) => Promise.all(promises)
+export const waitAll = <T>(promises: Promise<T>[]) => Promise.all<T>(promises)
 /** Waits for a Promise that been generated by the first arg, then returns an untoched value. Types T.
  * @param {AnyFunc<Promise>} fn - function to wait.
  * @param {T} s - any value to tap and return back
  * @returns {T}
  */
-export const waitTap = curry2(async (fn: AnyFunc, s: any) => { await fn(s); return s })
+export const waitTap = curry2(async (fn: AnyFunc<Promise<any>>, s: any) => { await fn(s); return s })
 /** Waits for all promises mapped by the fn. */
 export const forEachAsync = curry2(
-  (fn: (item: any) => Promise<any>, items: any[]) =>
-    Promise.all(items.map(fn))
+  (fn: (item: any) => Promise<any>, items: any[]) => Promise.all(items.map(fn))
 )
 /** The same as compose, but waits for promises in chains and returns a Promise.  */
 export const composeAsync = (() => {

package/src/common.ts

@@ -1,5 +1,4 @@
 import { curry2 } from "./curry"
-import { BasicType } from "./types"
 import { to, isNull, isStr, isUndef } from "./utils"
 
 // It's faster that toUpperCase() !

package/src/quick.ts

@@ -2,7 +2,11 @@ import { curry2, curry3 } from "./curry"
 import { includes, isNil, type, eq, qstartsWithWith } from "./common"
 import { AnyObject, Reducer, AnyFunc } from "./types"
 import { isFunc, isArray, isObj } from "./utils"
-// TODO: qflat, qpick, qoverProp, qover array ?
+// TODO: qoverProp, qover array ?
+
+/** Then next fns seem to be excess due to their safe ver performance should be the same or better:
+ * qflat, qpick
+ */
 
 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 })

package/src/safe.ts

@@ -57,15 +57,15 @@ export const tail = slice(1, inf)
 export const add = curry2((a: number, b: number) => a+b)
 /** @param a @param b @returns b-a  */
 export const subtract = curry2((a: number, b: number) => b-a)
-/**@param a @param b @returns a*b  */
+/**@param a @param b @returns a×b  */
 export const multiply = curry2((a: number, b: number) => a*b)
 /** @param a @param b @returns a<b  */
 export const gt = curry2( (a: number, b: number) => a<b )
 /** @param a @param b @returns a>b  */
 export const lt = curry2( (a: number, b: number) => a>b )
-/** @param a @param b @returns a<=b  */
+/** @param a @param b @returns a≤b  */
 export const gte = curry2( (a: number, b: number) => a<=b )
-/** @param a @param b @returns a>=b  */
+/** @param a @param b @returns a≥b  */
 export const lte = curry2( (a: number, b: number) => a>=b )
 export const sort = curry2((sortFn: any, xs: any[]) => xs.sort(sortFn))
 export const find = curry2((fn: Cond, s: any[]) => s.find(fn))
@@ -107,9 +107,9 @@ export const F = always<false>(false) as (...args: any[]) => false
 export const callWith = curry2((args: any[], fn: AnyFunc) => fn(...args))
 export const noop = (()=>{}) as (...args: any[]) => any
 /** Calls a func from object.
- * @param {any[]} [args] - arguments for the function.
- * @param {string} [fnName] - property name of the function.
- * @param {AnyObject} [o] - the object with the function. */
+ * @param {any[]} args - arguments for the function.
+ * @param {string} fnName - property name of the function.
+ * @param {AnyObject} o - the object with the function. */
 export const callFrom = curry((args: any[], fn: string, o: AnyObject) => o[fn](...args))
 export const complement = (fn: AnyFunc) => (...args: any) => {
   const out = fn(...args)
@@ -130,7 +130,26 @@ export const uniq = (xs: any[]) => qreduce(
     find(equals(x), accum) ? accum : qappend(x, accum),
 [], xs)
 export const intersection = curry2((xs1: any[], xs2: any[]) => xs1.filter(flip(includes)(xs2)))
-export const diff = curry2( (xs1: any[], xs2: any[]) => xs1.filter(complement(flip(includes)(xs2))) )
+export const diff = curry2((_xs1: any[], _xs2: any[]) => {
+  const len1 = length(_xs1)
+  const len2 = length(_xs2) // xs2 should be shorter 4 Set mem consumption.
+  const xs1 = len1>len2 ? _xs1 : _xs2
+  const xs2 = len1>len2 ? _xs2 : _xs1
+  const xset2 = new Set(xs2)
+  const common = new Set()
+  const out: any[] = []
+  let i: number
+  for(i=0; i<len1; i++) {
+    const el = xs1[i]
+    if(xset2.has(el)) common.add(el)
+    else out.push(el)
+  }
+  for(i=0; i<len2; i++) {
+    const el = xs2[i]
+    if(!common.has(el)) out.push(el)
+  }
+  return out
+})
 export const genBy = curry2(
   (
     generator: (i: number) => any,