rubico 1.9.7 → 2.0.0

package/archive/benchmarks-v1.9.7/switchCase.js

@@ -0,0 +1,256 @@
+const { switchCase } = require('..')
+const { timeInLoop } = require('../x')
+
+const isPromise = value => value != null && typeof value.then == 'function'
+
+const possiblePromiseThen = (value, func) => (
+  isPromise(value) ? value.then(func) : func(value))
+
+/**
+ * @name funcConditional
+ *
+ * @synopsis
+ * funcConditional(
+ *   funcs Array<args=>Promise|any>,
+ * )(args ...any) -> Promise|any
+ */
+const funcConditional = funcs => function funcSwitching(...args) {
+  const lastIndex = funcs.length - 1
+  let funcsIndex = -2
+  while ((funcsIndex += 2) < lastIndex) {
+    const shouldReturnNext = funcs[funcsIndex].apply(null, args)
+    if (isPromise(shouldReturnNext)) {
+      return shouldReturnNext.then(res => res
+        ? funcs[funcsIndex + 1].apply(null, args)
+        : asyncFuncSwitch(funcs, args, funcsIndex))
+    }
+    if (shouldReturnNext) {
+      return funcs[funcsIndex + 1].apply(null, args)
+    }
+  }
+  return funcs[funcsIndex].apply(null, args)
+}
+
+const funcConditionalRegularCalls = funcs => function funcSwitching(...args) {
+  const lastIndex = funcs.length - 1
+  let funcsIndex = -2
+  while ((funcsIndex += 2) < lastIndex) {
+    const shouldReturnNext = funcs[funcsIndex](...args)
+    if (isPromise(shouldReturnNext)) {
+      return shouldReturnNext.then(res => res
+        ? funcs[funcsIndex + 1](...args)
+        : asyncFuncSwitch(funcs, args, funcsIndex))
+    }
+    if (shouldReturnNext) {
+      return funcs[funcsIndex + 1](...args)
+    }
+  }
+  return funcs[funcsIndex](...args)
+}
+
+const arraySwitchCase = (funcs, args, index) => {
+  if (index === funcs.length - 1) return funcs[index](...args)
+  return possiblePromiseThen(
+    funcs[index](...args),
+    ok => ok
+      ? funcs[index + 1](...args)
+      : arraySwitchCase(funcs, args, index + 2),
+  )
+}
+
+const switchCase1 = funcConditional
+
+const switchCase10 = funcConditionalRegularCalls
+
+const switchCase2 = funcs => (...args) => arraySwitchCase(funcs, args, 0)
+
+// argument resolver for curry2
+const curry2ResolveArg0 = (
+  baseFunc, arg1,
+) => function arg0Resolver(arg0) {
+  return baseFunc(arg0, arg1)
+}
+
+// argument resolver for curry2
+const curry2ResolveArg1 = (
+  baseFunc, arg0,
+) => function arg1Resolver(arg1) {
+  return baseFunc(arg0, arg1)
+}
+
+/**
+ * @name curry2
+ *
+ * @synopsis
+ * __ = Symbol('placeholder')
+ *
+ * curry2(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ * ) -> function
+ */
+const curry2 = function (baseFunc, arg0, arg1) {
+  return arg0 == __
+    ? curry2ResolveArg0(baseFunc, arg1)
+    : curry2ResolveArg1(baseFunc, arg0)
+}
+
+const thunkify1 = (func, arg0) => () => func(arg0)
+
+const thunkify3 = (func, arg0, arg1, arg2) => () => func(arg0, arg1, arg2)
+
+const asyncFuncSwitch = async function (funcs, args, funcsIndex) {
+  const lastIndex = funcs.length - 1
+  while ((funcsIndex += 2) < lastIndex) {
+    if (await funcs[funcsIndex](...args)) {
+      return funcs[funcsIndex + 1](...args)
+    }
+  }
+  return funcs[funcsIndex](...args)
+}
+
+const __ = Symbol('placeholder')
+
+const thunkConditional = (
+  boolean, thunkA, thunkB,
+) => boolean ? thunkA() : thunkB()
+
+const switchCase3 = funcs => function funcSwitching(...args) {
+  const lastIndex = funcs.length - 1
+  let funcsIndex = -2
+
+  while ((funcsIndex += 2) < lastIndex) {
+    const shouldReturnNext = funcs[funcsIndex](...args)
+    if (isPromise(shouldReturnNext)) {
+      return shouldReturnNext.then(
+        curry3(
+          thunkConditional,
+          __,
+          thunkify1(
+            curry2(funcApply, funcs[funcsIndex + 1], __),
+            args),
+          thunkify3(asyncFuncSwitch, funcs, args, funcsIndex)))
+    }
+    if (shouldReturnNext) {
+      return funcs[funcsIndex + 1](...args)
+    }
+  }
+  return funcs[funcsIndex](...args)
+}
+
+
+/**
+ * @name switchCase
+ *
+ * @benchmark
+ *
+ * @NOTE Bo5 runs
+ * fiveCases_switchCaseRubico1: 1e+6: 369.264ms
+ * fiveCases_switchCaseRubico10: 1e+6: 314.024ms
+ * fiveCases_switchCaseRubico2: 1e+6: 301.841ms
+ * fiveCases_switchCaseRubico3: 1e+6: 271.723ms
+ *
+ * fiveMilCases_switchCaseRubico1: 5e+0: 326.556ms
+ * fiveMilCases_switchCaseRubico10: 5e+0: 263.211ms
+ * fiveMilCases_switchCaseRubico2: Error: Maximum call stack size exceeded
+ * fiveMilCases_switchCaseRubico3: 5e+0: 262.337ms
+ *
+ * fiveThousandCases_switchCaseRubico1: 5e+2: 63.736ms
+ * fiveThousandCases_switchCaseRubico10: 5e+2: 48.004ms
+ * fiveThousandCases_switchCaseRubico2: 5e+2: 270.643ms
+ * fiveThousandCases_switchCaseRubico3: 5e+2: 25.742ms
+ */
+
+{
+  const isOdd = x => x % 2 === 1
+
+  const odd = () => 'odd'
+
+  const even = () => 'even'
+
+  /**
+   * @name createCases
+   *
+   * @synopsis
+   * createCases(length number) -> cases Array<function, length>
+   */
+  const createCases = function (length) {
+    if (!isOdd(length)) throw new RangeError('length must be odd')
+    const output = [], lastIndex = length - 1
+    let index = -1
+    while (++index < lastIndex) {
+      output[index] = isOdd(index) ? odd : isOdd
+    }
+    output[index] = even
+    return output
+  }
+
+  const fiveCases = createCases(5)
+
+  const fiveCases_vanilla = num => isOdd(num) ? odd() : isOdd(num) ? odd() : even()
+
+  const fiveCases_vanillaArgs = (...args) => isOdd(...args) ? odd(...args) : isOdd(...args) ? odd(...args) : even(...args)
+
+  const fiveCases_switchCaseRubico1 = switchCase1(fiveCases)
+
+  const fiveCases_switchCaseRubico10 = switchCase10(fiveCases)
+
+  const fiveCases_switchCaseRubico2 = switchCase2(fiveCases)
+
+  const fiveCases_switchCaseRubico3 = switchCase3(fiveCases)
+
+  const fiveMilCases = createCases(4_999_999)
+
+  const fiveMilCases_switchCaseRubico = switchCase(fiveMilCases)
+
+  const fiveMilCases_switchCaseRubico1 = switchCase1(fiveMilCases)
+
+  const fiveMilCases_switchCaseRubico10 = switchCase10(fiveMilCases)
+
+  const fiveMilCases_switchCaseRubico2 = switchCase2(fiveMilCases)
+
+  const fiveMilCases_switchCaseRubico3 = switchCase3(fiveMilCases)
+
+  const fiveThousandCases = createCases(4_999)
+
+  const fiveThousandCases_switchCaseRubico = switchCase(fiveThousandCases)
+
+  const fiveThousandCases_switchCaseRubico1 = switchCase1(fiveThousandCases)
+
+  const fiveThousandCases_switchCaseRubico10 = switchCase10(fiveThousandCases)
+
+  const fiveThousandCases_switchCaseRubico2 = switchCase2(fiveThousandCases)
+
+  const fiveThousandCases_switchCaseRubico3 = switchCase3(fiveThousandCases)
+
+  // timeInLoop('fiveCases_vanilla', 1e6, () => fiveCases_vanilla(2))
+
+  // timeInLoop('fiveCases_vanillaArgs', 1e6, () => fiveCases_vanillaArgs(2))
+
+  // timeInLoop('fiveCases_switchCaseRubico1', 1e6, () => fiveCases_switchCaseRubico1(2))
+
+  // timeInLoop('fiveCases_switchCaseRubico10', 1e6, () => fiveCases_switchCaseRubico10(2))
+
+  // timeInLoop('fiveCases_switchCaseRubico2', 1e6, () => fiveCases_switchCaseRubico2(2))
+
+  // console.log(fiveCases_switchCaseRubico3(2))
+
+  // timeInLoop('fiveCases_switchCaseRubico3', 1e6, () => fiveCases_switchCaseRubico3(2))
+
+  // timeInLoop('fiveMilCases_switchCaseRubico1', 5, () => fiveMilCases_switchCaseRubico1(2))
+
+  // timeInLoop('fiveMilCases_switchCaseRubico10', 5, () => fiveMilCases_switchCaseRubico10(2))
+
+  // timeInLoop('fiveMilCases_switchCaseRubico2', 5, () => fiveMilCases_switchCaseRubico2(2))
+
+  // timeInLoop('fiveMilCases_switchCaseRubico3', 5, () => fiveMilCases_switchCaseRubico3(2))
+
+  // timeInLoop('fiveThousandCases_switchCaseRubico1', 500, () => fiveThousandCases_switchCaseRubico1(2))
+
+  // timeInLoop('fiveThousandCases_switchCaseRubico10', 500, () => fiveThousandCases_switchCaseRubico10(2))
+
+  // timeInLoop('fiveThousandCases_switchCaseRubico2', 500, () => fiveThousandCases_switchCaseRubico2(2))
+
+  // timeInLoop('fiveThousandCases_switchCaseRubico3', 500, () => fiveThousandCases_switchCaseRubico3(2))
+}

package/archive/benchmarks-v1.9.7/tap.js

@@ -0,0 +1,90 @@
+const timeInLoop = require('../x/timeInLoop')
+const _ = require('lodash/fp')
+const { tap } = require('..')
+const R = require('ramda')
+
+const isPromise = value => value != null && typeof value.then == 'function'
+
+/**
+ * @name tap
+ *
+ * @benchmark
+ * tapNoopThunk: 1e+6: 4.242ms
+ * tapRegularCallNoopThunk: 1e+6: 4.969ms
+ * _tapNoopThunk: 1e+6: 155.716ms
+ * RTapNoopThunk: 1e+6: 291.025ms
+ */
+
+{
+  const noop = () => {}
+
+  const tapNoop = tap(noop)
+
+  const tapNoopThunk = () => tapNoop('yo')
+
+  tap.regularCall = func => function tapping(input) {
+    const call = func(input)
+    return isPromise(call) ? call.then(() => input) : input
+  }
+
+  const tapRegularCallNoop = tap.regularCall(noop)
+
+  const tapRegularCallNoopThunk = () => tapRegularCallNoop('yo')
+
+  const _tapNoop = _.tap(noop)
+
+  const _tapNoopThunk = () => _tapNoop('yo')
+
+  const RTapNoop = R.tap(noop)
+
+  const RTapNoopThunk = () => RTapNoop('yo')
+
+  // const func = tapNoopThunk
+  // const func = tapRegularCallNoopThunk
+  // const func = tapNoopThunk
+  // const func = _tapNoopThunk
+  // const func = RTapNoopThunk
+
+  // console.log(func())
+
+  // timeInLoop(func.name, 1e6, func)
+}
+
+const tap0 = func => function tapping(...args) {
+  const point = args[0],
+    call = func(...args)
+  return isPromise(call) ? call.then(() => point) : point
+}
+
+const always = value => function getter() { return value }
+
+const tap1 = func => function tapping(...args) {
+  const point = args[0],
+    call = func(...args)
+  return isPromise(call) ? call.then(always(point)) : point
+}
+
+/**
+ * @name tap
+ *
+ * @benchmark
+ * tap0: 1e+7: 141.116ms
+ * tap1: 1e+7: 141.007ms
+ */
+
+{
+  const array = []
+
+  const noop = function () {}
+
+  // timeInLoop('tap0', 1e7, () => tap0(noop)(0))
+
+  // timeInLoop('tap1', 1e7, () => tap1(noop)(0))
+}
+
+/**
+ * @name tap.if
+ *
+ * @benchmark
+ * TODO
+ */

package/archive/benchmarks-v1.9.7/transform.js

@@ -0,0 +1,218 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('rubico')
+const R = require('ramda')
+const _ = require('lodash')
+const _fp = require('lodash/fp')
+const { Readable, Writable } = require('stream')
+
+const isPromise = value => value != null && typeof value.then == 'function'
+
+const {
+  pipe, fork, assign,
+  tap, tryCatch, switchCase,
+  map, filter, reduce, transform, flatMap,
+  any, all, and, or, not,
+  eq, gt, lt, gte, lte,
+  get, pick, omit,
+} = rubico
+
+const square = number => number ** 2
+
+const isOdd = number => number % 2 == 1
+
+const squaredOdds = pipe([
+  filter(isOdd),
+  map(square),
+])
+
+const squaredOddsArrayConcat = transform(
+  squaredOdds, [],
+)
+
+/**
+ * @name squaredOddsArrayConcat
+ *
+ * @benchmark
+ * squaredOddsArrayConcat: 1e+5: 85.147ms
+ *
+ * @note Bo5
+ */
+
+{
+  const numbers = [1, 2, 3, 4, 5]
+
+  const arrayEmpty = () => []
+
+  const squaredOddsArrayConcat = transform(squaredOdds, arrayEmpty)
+
+  // timeInLoop('squaredOddsArrayConcat', 1e5, () => squaredOddsArrayConcat(numbers))
+}
+
+/**
+ * @name squaredOddsStringAdd
+ *
+ * @benchmark
+ * squaredOddsStringAdd: 1e+5: 176.517ms
+ *
+ * @note Bo5
+ */
+
+{
+  const numbers = [1, 2, 3, 4, 5]
+
+  const squaredOddsStringAdd = transform(squaredOdds, '')
+
+  // console.log(squaredOddsStringAdd(numbers))
+
+  // timeInLoop('squaredOddsStringAdd', 1e5, () => squaredOddsStringAdd(numbers))
+}
+
+/**
+ * @name squaredOddsSetAdd
+ *
+ * @benchmark
+ * squaredOddsSetAdd: 1e+5: 93.28ms
+ *
+ * @note Bo5
+ */
+
+{
+  const numbers = [1, 2, 3, 4, 5]
+
+  const setEmpty = () => new Set()
+
+  const squaredOddsSetAdd = transform(squaredOdds, setEmpty)
+
+  // console.log(squaredOddsSetAdd(numbers))
+
+  // timeInLoop('squaredOddsSetAdd', 1e5, () => squaredOddsSetAdd(numbers))
+}
+
+/**
+ * @name squaredOddsUint8ArrayConcat
+ *
+ * @benchmark
+ * squaredOddsUint8ArrayConcat: 1e+5: 237.538ms
+ *
+ * @note Bo5
+ */
+
+{
+  const numbers = [1, 2, 3, 4, 5]
+
+  const setEmpty = () => new Set()
+
+  const uint8ArrayEmpty = () => new Uint8Array(0)
+
+  const squaredOddsUint8ArrayConcat = transform(squaredOdds, uint8ArrayEmpty)
+
+  // console.log(squaredOddsUint8ArrayConcat(numbers))
+
+  // timeInLoop('squaredOddsUint8ArrayConcat', 1e5, () => squaredOddsUint8ArrayConcat(numbers))
+}
+
+const MockWritable = function (values) {
+  Writable.call(this)
+  this.array = [...values]
+  this.handlers = new Map()
+}
+
+MockWritable.prototype.write = function (chunk, encoding, callback) {
+  this.array.push(chunk)
+}
+
+MockWritable.prototype.on = function (eventName, handler) {
+  if (this.handlers.has(eventName)) {
+    this.handlers.get(eventName).push(handler)
+  } else {
+    this.handlers.set(eventName, [handler])
+  }
+}
+
+MockWritable.prototype.once = function (eventName, handler) {
+  this.handlers.set(eventName, [handler])
+}
+
+MockWritable.prototype.emit = function (eventName, ...args) {
+  if (!this.handlers.has(eventName)) {
+    return undefined
+  }
+  return this.handlers.get(eventName).map(handler => handler(...args))
+}
+
+/**
+ * @name squaredOddsStreamConcat
+ *
+ * @benchmark
+ *
+ * @note Bo5
+ * squaredOddsStreamConcat: 1e+5: 90.274ms
+ */
+
+{
+  const numbers = [1, 2, 3, 4, 5]
+
+  const setEmpty = () => new Set()
+
+  const uint8ArrayEmpty = () => new Uint8Array(0)
+
+  const square = number => number ** 2
+
+  const squaredOddsStreamConcat = transform(squaredOdds, new MockWritable([]))
+
+  // console.log(squaredOddsStreamConcat(numbers))
+
+  // timeInLoop('squaredOddsStreamConcat', 1e5, () => squaredOddsStreamConcat(numbers))
+}
+
+/**
+ * @name squaredOddsObjectAssign
+ *
+ * @benchmark
+ * squaredOddsObjectAssign: 1e+5: 96.854ms
+ *
+ * @note Bo5
+ */
+
+{
+  const numbers = [1, 2, 3, 4, 5]
+
+  const setEmpty = () => new Set()
+
+  const uint8ArrayEmpty = () => new Uint8Array(0)
+
+  const square = number => number ** 2
+
+  const objectEmpty = () => ({})
+
+  const squaredOddsObjectAssign = transform(squaredOdds, objectEmpty)
+
+  // console.log(squaredOddsObjectAssign(numbers))
+
+  // timeInLoop('squaredOddsObjectAssign', 1e5, () => squaredOddsObjectAssign(numbers))
+}
+
+/**
+ * @name squaredOddsNullTransform
+ *
+ * @benchmark
+ * squaredOddsNullTransform: 1e+5: 78.409ms
+ *
+ * @note Bo5
+ */
+
+{
+  const numbers = [1, 2, 3, 4, 5]
+
+  const setEmpty = () => new Set()
+
+  const uint8ArrayEmpty = () => new Uint8Array(0)
+
+  const square = number => number ** 2
+
+  const squaredOddsNullTransform = transform(squaredOdds, null)
+
+  // console.log(squaredOddsNullTransform(numbers))
+
+  // timeInLoop('squaredOddsNullTransform', 1e5, () => squaredOddsNullTransform(numbers))
+}

package/archive/benchmarks-v1.9.7/tryCatch.js

@@ -0,0 +1,108 @@
+const tryCatch = require('../tryCatch')
+const timeInLoop = require('../x/timeInLoop')
+
+const isPromise = value => value != null && typeof value.then == 'function'
+
+const tryCatch2 = (tryer, catcher) => function tryCatcher(...args) {
+  try {
+    const output = tryer.apply(null, args)
+    return isPromise(output)
+      ? output.catch(err => catcher.call(null, err, ...args))
+      : output
+  } catch (err) {
+    return catcher.call(null, err, ...args)
+  }
+}
+
+// argument resolver for curry3
+const curry3ResolveArg0 = (
+  baseFunc, arg1, arg2,
+) => function arg0Resolver(arg0) {
+  return baseFunc(arg0, arg1, arg2)
+}
+
+// argument resolver for curry3
+const curry3ResolveArg1 = (
+  baseFunc, arg0, arg2,
+) => function arg1Resolver(arg1) {
+  return baseFunc(arg0, arg1, arg2)
+}
+
+// argument resolver for curry3
+const curry3ResolveArg2 = (
+  baseFunc, arg0, arg1,
+) => function arg2Resolver(arg2) {
+  return baseFunc(arg0, arg1, arg2)
+}
+
+/**
+ * @name curry3
+ *
+ * @synopsis
+ * __ = Symbol('placeholder')
+ *
+ * curry3(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ *   arg2 __|any
+ * ) -> function
+ */
+const curry3 = function (baseFunc, arg0, arg1, arg2) {
+  if (arg0 == __) {
+    return curry3ResolveArg0(baseFunc, arg1, arg2)
+  }
+  if (arg1 == __) {
+    return curry3ResolveArg1(baseFunc, arg0, arg2)
+  }
+  return curry3ResolveArg2(baseFunc, arg0, arg1)
+}
+
+const tryCatch3 = (tryer, catcher) => function tryCatcher(...args) {
+  try {
+    const result = tryer(...args)
+    return isPromise(result)
+      ? result.catch(curry3(catcherApply, catcher, __, args))
+      : result
+  } catch (err) {
+    return catcher(err, ...args)
+  }
+}
+
+/**
+ * @name tryCatch
+ *
+ * @benchmark
+ * tryCatch2: 1e+6: 36.369ms
+ * tryCatch3: 1e+6: 17.027ms
+ *
+ * TODO find the date
+ */
+
+{
+  const identity = value => value
+
+  const noop = () => {}
+
+  const isPromise = value => value != null && typeof value.then == 'function'
+
+  // console.log(tryCatch2(identity, noop)('yo'))
+  // console.log(tryCatch3(identity, noop)('yo'))
+
+  // timeInLoop('tryCatch2', 1e6, () => tryCatch2(identity, noop)('yo'))
+
+  // timeInLoop('tryCatch3', 1e6, () => tryCatch3(identity, noop)('yo'))
+}
+
+/**
+ * @name tryCatch 2022-06-13
+ *
+ * @benchmark
+ * tryCatch: 1e+6: tryCatch: 1e+6: 39.787ms
+ */
+
+{
+  const identity = value => value
+  const noop = () => {}
+  timeInLoop('tryCatch', 1e6, () => tryCatch2(identity, noop)('yo'))
+}

package/assign.js

@@ -1,14 +1,25 @@
 const isPromise = require('./_internal/isPromise')
 const objectAssign = require('./_internal/objectAssign')
 const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
 const curry3 = require('./_internal/curry3')
-const funcObjectAll = require('./_internal/funcObjectAll')
+const functionObjectAll = require('./_internal/functionObjectAll')
+
+// _assign(object Object, funcs Object<function>) -> Promise|Object
+const _assign = function (object, funcs) {
+  const result = functionObjectAll(funcs, [object])
+  return isPromise(result)
+    ? result.then(curry3(objectAssign, {}, object, __))
+    : ({ ...object, ...result })
+}
 
 /**
  * @name assign
  *
  * @synopsis
  * ```coffeescript [specscript]
+ * assign(object Object, resolvers Object<function>) -> result Promise|Object
+ *
  * assign(resolvers Object<function>)(object Object) -> result Promise|Object
  * ```
  *
@@ -46,14 +57,13 @@ const funcObjectAll = require('./_internal/funcObjectAll')
  *
  * @execution concurrent
  */
-const assign = function (funcs) {
-  const allFuncs = funcObjectAll(funcs)
-  return function assignment(value) {
-    const result = allFuncs(value)
-    return isPromise(result)
-      ? result.then(curry3(objectAssign, {}, value, __))
-      : ({ ...value, ...result })
+const assign = function (arg0, arg1) {
+  if (arg1 == null) {
+    return curry2(_assign, __, arg0)
   }
+  return isPromise(arg0)
+    ? arg0.then(curry2(_assign, __, arg1))
+    : _assign(arg0, arg1)
 }
 
 module.exports = assign