pepka 0.12.2 → 0.13.0-b1

package/src/curry.ts

@@ -1,53 +1,99 @@
-
-type Args = any[]
-
-export const __ = (function Placeholder() {})
-
-const countArgs = (s: Args) => {
-  let i = 0
-  for (const v of s) v!==__ && i++
-  return i
-}
-
-// TODO: try to make it mutable.
-// { 0: __, 1: 10 }, [ 11 ]
-const addArgs = (args: Args, _args: Args) => {
-  const len = args.length
-  const new_args = args.slice()
-  const _args_len = _args.length
-  let _args_left = _args_len
-  let i=0
-  for (; _args_left && i<len; i++) {
-    if(new_args[i] === __) {
-      new_args[i] = _args[_args_len-_args_left]
-      _args_left--
-    }
-  }
-  for(i=len; _args_left; i++, _args_left--) {
-    new_args[i] = _args[_args_len-_args_left]
-  }
-  return new_args
-}
-
-const _curry = (fn: Function, args: Args, new_args: Args) => {
-  const args2add = fn.length - args.length - countArgs(new_args)
-  if(args2add < 1) {
-    return fn(...addArgs(args, new_args))
-  } else {
-    const curried = (...__args: Args) => _curry(
-      fn,
-      addArgs(args, new_args),
-      __args
-    )
-    ;(curried as any).$args_left = args2add
-    return curried
-  }
-}
-
-export const curry = (
-  (fn: Function) => (
-    (...args: Args) => fn.length>countArgs(args)
-      ? _curry(fn, [], args)
-      : fn(...args)
-  )
-)
+import { F as FT, A } from 'ts-toolbelt'
+import { AnyFunc, AnyArgs } from "./types"
+
+export const __ = Symbol('Placeholder') as A.x
+
+const countArgs = (s: AnyArgs) => {
+  let i = 0
+  for (const v of s) v!==__ && i++
+  return i
+}
+
+// TODO: try to make it mutable.
+// { 0: __, 1: 10 }, [ 11 ]
+const addArgs = (args: AnyArgs, _args: AnyArgs) => {
+  const len = args.length
+  const new_args = args.slice()
+  const _args_len = _args.length
+  let _args_left = _args_len
+  let i=0
+  for (; _args_left && i<len; i++) {
+    if(new_args[i] === __) {
+      new_args[i] = _args[_args_len-_args_left]
+      _args_left--
+    }
+  }
+  for(i=len; _args_left; i++, _args_left--) {
+    new_args[i] = _args[_args_len-_args_left]
+  }
+  return new_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: AnyArgs) => _curry(
+      fn,
+      addArgs(args, new_args),
+      __args
+    )
+    ;(curried as any).$args_left = args2add
+    return curried
+  }
+}
+
+export const curry = (
+  <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,6 +1,7 @@
-
-export * from './curry'
-export * from './common'
-export * from './safe'
-export * from './quick'
+
+export * from './curry'
+export * from './uncurry'
+export * from './common'
+export * from './safe'
+export * from './quick'
 export * from './strings'

package/src/quick.ts

@@ -1,98 +1,99 @@
-import { curry } 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(
-  (prop: string, v: any, obj: AnyObject) => {
-    obj[prop] = v
-    return obj
-  }
-)
-export const qreduce = curry(
-  (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 => {
-  for(let k in o2) {
-    switch(type(o2[k])) {
-      case 'Array':
-        if(strategy>1 && type(o1[k])==='Array') {
-          switch(strategy) {
-            case 2:
-              const o1k = o1[k], o2k = o2[k]
-              for(const i in o2k) {
-                if(o1k[i]) {
-                  mergeDeep(strategy, o1k[i], o2k[i])
-                } else {
-                  o1k[i] = o2k[i]
-                }
-              }
-              break
-            case 3: o1[k].push(...o2[k])
-            default: break
-          }
-        } else {
-          o1[k] = o2[k]
-        }
-        break
-      case 'Object':
-        if(type(o1[k])==='Object') {
-          mergeDeep(strategy, o1[k], o2[k])
-          break
-        }
-      default:
-        o1[k] = o2[k]
-        break
-    }
-  }
-  return o1
-})
-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(
-  (
-    keyMap: {[oldKey: string]: string},
-    o: AnyObject
-  ) => {
-    let k: string, mapped: string | AnyFunc, newKey: string, newValue: any
-    for(k in keyMap) {
-      mapped = keyMap[k]
-      ;[newKey, newValue] = isFunc(mapped)
-        ? (mapped as unknown as AnyFunc)(o)
-        : [mapped, o[k]]
-      o[newKey] = newValue
-      if(k !== newKey) {
-        delete o[k]
-      }
-    }
-    return o
-  }
-)
-
-export const qfilter = curry(
-  (
-    cond: (v: any, k: string | number) => boolean,
-    data: any[] | AnyObject
-  ) => {
-    const isArr = isArray(data)
-    for(let k in data) {
-      if(!cond(data[k], k)) {
-        if(isArr) {
-          data.splice(k, 1)
-        } else {
-          // TODO: handle Maps and Sets ?
-          delete data[k]
-        }
-      }
-    }
-    return data
-  }
-)
-export const qindexOf = curry(
-  (x: any, xs: any[]) => xs.indexOf(x)
+import { curry, curry2, curry3 } from "./curry"
+import { type } from "./common"
+import { AnyObject, Reducer, AnyFunc } from "./types"
+import { isFunc, isArray } from "./utils"
+
+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 = curry3(
+  (fn: Reducer, accum: any, arr: any[]) =>
+    arr.reduce(fn, accum)
+)
+// strategy is for arrays: 1->clean, 2->merge, 3->push.
+const mergeDeep = curry3((strategy: 1|2|3, o1: AnyObject, o2: AnyObject): AnyObject => {
+  for(let k in o2) {
+    switch(type(o2[k])) {
+      case 'Array':
+        if(strategy>1 && type(o1[k])==='Array') {
+          switch(strategy) {
+            case 2:
+              const o1k = o1[k], o2k = o2[k]
+              for(const i in o2k) {
+                if(o1k[i]) {
+                  mergeDeep(strategy, o1k[i], o2k[i])
+                } else {
+                  o1k[i] = o2k[i]
+                }
+              }
+              break
+            case 3: o1[k].push(...o2[k])
+            default: break
+          }
+        } else {
+          o1[k] = o2[k]
+        }
+        break
+      case 'Object':
+        if(type(o1[k])==='Object') {
+          mergeDeep(strategy, o1[k], o2[k])
+          break
+        }
+      default:
+        o1[k] = o2[k]
+        break
+    }
+  }
+  return o1
+})
+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 = curry2(
+  (
+    keyMap: {[oldKey: string]: string},
+    o: AnyObject
+  ) => {
+    let k: string, mapped: string | AnyFunc, newKey: string, newValue: any
+    for(k in keyMap) {
+      mapped = keyMap[k]
+      ;[newKey, newValue] = isFunc(mapped)
+        ? (mapped as unknown as AnyFunc)(o)
+        : [mapped, o[k]]
+      o[newKey] = newValue
+      if(k !== newKey) {
+        delete o[k]
+      }
+    }
+    return o
+  }
+)
+
+export const qfilter = curry2(
+  (
+    cond: (v: any, k: string | number) => boolean,
+    data: any[] | AnyObject
+  ) => {
+    const isArr = isArray(data)
+    for(let k in data) {
+      if(!cond(data[k], k)) {
+        if(isArr) {
+          data.splice(k, 1)
+        } else {
+          // TODO: handle Maps and Sets ?
+          delete data[k]
+        }
+      }
+    }
+    return data
+  }
+)
+/** @deprecated */
+export const qindexOf = curry2(
+  (x: any, xs: any[]) => xs.indexOf(x)
 )