pepka 1.2.1 → 1.3.1

package/src/common.ts

@@ -1,18 +1,54 @@
 import { curry2 } from "./curry"
-import { to, isNull } from "./utils"
+import { BasicType } from "./types"
+import { to, isNull, isStr, isUndef } from "./utils"
 
 // It's faster that toUpperCase() !
-const caseMap = {
-  u: 'U', b: 'B', n: 'N', s: 'S', f: 'F'
-}
+const caseMap = { u: 'U', b: 'B', n: 'N', s: 'S', f: 'F' }
 
 export const symbol = Symbol()
 export const toLower = (s: string) => s.toLowerCase()
 export const toUpper = (s: string) => s.toUpperCase()
-export const type = (s: any) => {
+export const type = (s: any): string => {
   const t = to(s)
   return t==='object'
     ? isNull(s) ? 'Null' : s.constructor.name
     : caseMap[t[0]] + t.slice(1)
 }
-export const typeIs = curry2((t: string, s: any) => type(s)===t)
+export const typeIs = curry2((t: string, s: any) => type(s)===t)
+export const length = (s: any[] | string) => s.length
+export const isNil = (s: any) => isNull(s) || isUndef(s)
+export const eq = curry2((a: any, b: any) => a===b)
+export const equals = curry2((a: any, b: any) => {
+  const typea = type(a)
+  if(eq(typea, type(b)) && (eq(typea, 'Object') || eq(typea, 'Array'))) {
+    if(isNull(a) || isNull(b)) return eq(a, b)
+    if(eq(a, b)) return true
+    for(const v of [a, b])
+      for(const k in v)
+        if(
+          !((eq(v, b)) && (k in a)) &&
+          !((eq(v, a)) && (k in b) && equals(a[k], b[k]))
+        ) return false
+    return true
+  }
+  return eq(a, b)
+})
+export const includes = curry2(
+  <T>(s: T, ss: T[]) => {
+    if(isStr(ss)) return ss.includes(s)
+    else {
+      for(const a of ss) if(equals(a, s)) return true
+      return false
+    }
+  }
+)
+/** @param start string | any[] @param s string | any[] */
+export const qstartsWithWith = (comparator: (x: any, y: any)=>boolean) => curry2(
+  (start: any[] | string, s: any[] | string) => {
+    const len_start = length(start)
+    const len_s = length(s)
+    if(len_start>len_s) return false
+    for(let i=0; i<len_start; i++) if(!comparator(s[i], start[i])) return false
+    return true
+  }
+)

package/src/index.ts

@@ -5,4 +5,5 @@ export * from './common'
 export * from './safe'
 export * from './quick'
 export * from './strings'
+export * from './async'
 export * from './types'

package/src/quick.ts

@@ -1,9 +1,8 @@
 import { curry2, curry3 } from "./curry"
-import { type } from "./common"
+import { includes, isNil, type, length, eq, qstartsWithWith } from "./common"
 import { AnyObject, Reducer, AnyFunc } from "./types"
 import { isFunc, isArray, isObj } from "./utils"
-import { includes, isNil } from "./safe"
-// TODO: qoverProp, qover array ?
+// TODO: qflat, qoverProp, qover array ?
 
 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 })
@@ -91,7 +90,7 @@ export const qfilter = curry2(
   }
 )
 export const qempty = (o: AnyObject|any[]) => {
-  if(isArray(o)) o.splice(0) 
+  if(isArray(o)) o.splice(0)
   else for(const i in o) delete o[i]
   return o
 }
@@ -119,4 +118,6 @@ export const qomit = curry2(
     (_: any, k: string) => !includes(k, props),
     o
   )
-)
+)
+/** @param start string | any[] @param s string | any[] */
+export const qstartsWith = qstartsWithWith(eq)

package/src/safe.ts

@@ -1,28 +1,12 @@
 import { __, curry, curry2, curry3 } from './curry'
-import { isNum, isUndef, undef, isNull, isArray, isFunc, isStr, isObj, inf } from './utils'
+import { isNum, undef, isNull, isArray, isFunc, isObj, inf } from './utils'
 import { qmergeDeep, qreduce, qappend, qmapKeys, qmergeDeepX, qmergeDeepAdd, qfilter, qfreeze, qfreezeShallow, qmapObj } from './quick'
 import { AnyFunc, Cond, AnyObject, Reducer } from './types'
-import { symbol, type } from './common'
+import { symbol, type, length, equals, includes, isNil, qstartsWithWith } from './common'
 // over, lensProp
 
 export const take = (argN: number) => (...args: any[]) => args[argN]
-export const eq = curry2((a: any, b: any) => a===b)
 export const weakEq = curry2((a: any, b: any) => a==b)
-export const equals = curry2((a: any, b: any) => {
-  const typea = type(a)
-  if(eq(typea, type(b)) && (eq(typea, 'Object') || eq(typea, 'Array'))) {
-    if(isNull(a) || isNull(b)) return eq(a, b)
-    if(eq(a, b)) return true
-    for(const v of [a, b])
-      for(const k in v)
-        if(
-          !((eq(v, b)) && (k in a)) &&
-          !((eq(v, a)) && (k in b) && equals(a[k], b[k]))
-        ) return false
-    return true
-  }
-  return eq(a, b)
-})
 export const ifElse = curry(
   (
     cond: (s: any) => boolean,
@@ -58,15 +42,6 @@ export const bind = curry2<AnyFunc>(
   (fn: AnyFunc, context: any) => fn.bind(context)
 )
 export const nth = curry2(<T=any>(i: number, data: T[] | string) => data[i])
-export const includes = curry2(
-  <T>(s: T, ss: T[]) => {
-    if(isStr(ss)) return ss.includes(s)
-    else {
-      for(const a of ss) if(equals(a, s)) return true
-      return false
-    }
-  }
-)
 export const slice = curry3(
   (from: number, to: number, o: any[] | string) =>
     o.slice(from, (isNum(to)?to:inf) as number)
@@ -74,26 +49,35 @@ export const slice = curry3(
 export const flip = <T extends AnyFunc>(fn: T) => curry2(
   (b: Parameters<T>[1], a: Parameters<T>[0]) => fn(a, b)
 )
+/** @returns first element of an array. */
 export const head = nth(0) as <T = any>(xs: T[] | string) => T
+/** @returns last element of an array. */
 export const tail = slice(1, inf)
-export const add = curry2((n: number, m: number) => n+m)
-export const subtract = curry2((n: number, m: number) => m-n)
-export const multiply = curry2((n: number, m: number) => n*m)
-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 )
+/** @param a @param b @returns a+b  */
+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  */
+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  */
+export const gte = curry2( (a: number, b: number) => 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))
 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 divide = curry2((n: number, m: number) => n/m)
-export const isNil = (s: any) => isNull(s) || isUndef(s)
-export const length = (s: any[] | string) => s.length
 export const always = <T=any>(s: T) => () => s
 export const identity = (s: any) => s
 export const trim = (s: string) => s.trim()
 export const last = (s: any[] | string) => s[length(s)-1]
+/** @param start string | any[] @param s string | any[] */
+export const startsWith = qstartsWithWith((x: any, y: any) => equals(x, y))
 type NotOverload = {
   (x: true): false
   (x: false): true
@@ -139,13 +123,11 @@ export const sizeof = (s: any[] | string | AnyObject) => {
     return len
   } else return length(s as any[])
 }
-export const range = curry2((from: number, to: number) =>
-  genBy(add(from), to-from)
-)
-// TODO: make it using equals for deep stuff !
+export const range = curry2((from: number, to: number) => genBy(add(from), to-from))
+/** @param xs any[] @returns xs without duplicates.  */
 export const uniq = (xs: any[]) => qreduce(
   <T>(accum: any, x: T) =>
-    includes(x, accum) ? accum : qappend(x, accum),
+    find(equals(x), accum) ? accum : qappend(x, accum),
 [], xs)
 export const intersection = curry2(
   (xs1: any[], xs2: any[]) => xs1.filter(flip(includes)(xs2))
@@ -177,11 +159,7 @@ export const explore = (caption: string, level = 'log') => tap(
 )
 export const cond = curry2(
   (pairs: [Cond, Function][], s: any) => {
-    for(const [cond, fn] of pairs) {
-      if(cond(s)) {
-        return fn(s)
-      }
-    }
+    for(const [cond, fn] of pairs) if(cond(s)) return fn(s)
   }
 )
 /** Assigns a prop to an object.
@@ -190,10 +168,7 @@ export const cond = curry2(
  * @param object AnyObject
  */
 export const assoc = curry3(
-  (prop: string, v: any, obj: AnyObject) => ({
-    ...obj,
-    [prop]: v
-  })
+  (prop: string, v: any, obj: AnyObject) => ({...obj, [prop]: v})
 )
 export const assocPath = curry3(
   (_path: string[], v: any, o: AnyObject) => compose(
@@ -209,16 +184,15 @@ export const assocPath = curry3(
 )
 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 = curry2(
-  (preds: Cond[], x: any) => preds.some((pred) => pred(x))
-)
-export const prop = curry2( (key: string, o: AnyObject) => o[key] )
+export const allPass = curry2((preds: Cond[], x: any) => preds.every((pred) => pred(x)))
+export const anyPass = curry2((preds: Cond[], x: any) => preds.some((pred) => pred(x)))
+/** @param key string @param o AnyObject @returns o[key] */
+export const prop = curry2((key: string, o: AnyObject) => o[key])
+/** @param key string @param value any @param o AnyObject @returns o[key] equals value */
 export const propEq = curry3(
   (key: string, value: any, o: AnyObject) => equals(o[key], value)
 )
+/** @param key string @param o1 AnyObject @param o2 AnyObject @returns o₁[key] equals o₂[key] */
 export const propsEq = curry3(
   (key: string, o1: any, o2: AnyObject) => equals(o1[key], o2[key])
 )
@@ -295,21 +269,15 @@ type Concat = ((a: string, b: string) => string)
 export const concat = curry2(
   ((a: any, b: string | any[]) => b.concat(a)) as Concat
 )
-export const join = curry2(
-  (delimeter: string, arr: string[]) => arr.join(delimeter)
-)
 export const map = curry2(
   (pipe: (s: any, i?: number, list?: any[]) => any, arr: any[]) => arr.map(pipe)
 )
 export const mapObj = curry2(
   (pipe: (s: any, i?: string, list?: any[]) => any, o: AnyObject) => qmapObj(pipe, cloneShallow(o))
 )
-export const forEach = curry2(
-  (pipe: (s: any) => any, arr: any[]) => arr.forEach(pipe)
-)
-export const both = curry3(
-  (cond1: Cond, cond2: Cond, s: any) => cond2(s) && cond1(s)
-)
+export const join = curry2((delimeter: string, arr: string[]) => arr.join(delimeter))
+export const forEach = curry2((pipe: (s: any) => any, arr: any[]) => arr.forEach(pipe))
+export const both = curry3((cond1: Cond, cond2: Cond, s: any) => cond2(s) && cond1(s))
 export const isEmpty = (s: any) => {
   switch(type(s)) {
     case 'String': case 'Array': return length(s)==0
@@ -392,40 +360,8 @@ export const zipWith = curry3(
     map((s: T1, i: number) => pipe(s, b[i]), a)
 )
 
-// ASYNCS
-
-/** One promise waits for another. */
-export const forEachSerial = (() => {
-  const pipe = async (fn: AnyFunc, items: any[], i: number) => {
-    if(i<items.length) {
-      await fn(items[i])
-      await pipe(fn, items, ++i)
-    }
-  }
-  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)
-/** 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 })
-/** Waits for all promises mapped by the fn. */
-export const forEachAsync = curry2(
-  (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 = (() => {
-  const pipe = async (fns: AnyFunc[], input: any[], i: number): Promise<any> =>
-    ~i ? await pipe(fns, [await fns[i](...input)], --i) : head(input)
-  return <T = any>(...fns: AnyFunc[]) =>
-    (...input: any[]) => pipe(fns, input, fns.length-1) as Promise<T>
-})()
+// Reexport safe stuff that is ready to use externally. 
+export { toLower, toUpper, type, typeIs, length, isNil, eq, equals, includes } from './common'
 
 // ALIASES
 export const mirror = identity

package/src/strings.ts

@@ -5,8 +5,8 @@ type StrTmpl = ((data: AnyObject) => string)
 const ecran = '\\'
 
 // TODO: make it splicy, not accumulatie by symbols.
-// Supports ecrans: '\{"json": {yes} \}'
-// get_tmpl(one{meme}two)({meme: 42}) -> one42two
+/** Supports ecrans: '\\{"json": {yes} \\}'
+  @returns get_tmpl(one{meme}two)({meme: 42}) -> one42two */
 export const getTmpl = (tmpl: string): StrTmpl => {
   const parts: string[] = []
   const keymap: string[] = []

package/src/types.ts

@@ -7,4 +7,5 @@ export type TupleFn<ARG1=any, ARG2=any, Out=any> = (a: ARG1, b: ARG2) => Out
 export type Curried<
   Args extends AnyArgs = AnyArgs,
   ReturnT = any
-> = (arg: Args[number]) => Curried<Args> | ReturnT
+> = (arg: Args[number]) => Curried<Args> | ReturnT
+export type BasicType = 'String'|'Object'|'Number'|'Symbol'|'Array'|'Null'|'Undefined'