rubico 1.9.7 → 2.0.1

package/archive/arrayMap2-2023-05-29.js

@@ -0,0 +1,73 @@
+const funcCall = require('./funcCall')
+const thunkify4 = require('./thunkify4')
+const __ = require('./placeholder')
+const curry2 = require('./curry2')
+const curry3 = require('./curry3')
+const curry4 = require('./curry4')
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+const _Promise = require('./_Promise')
+
+/**
+ * @name arrayMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayMap(
+ *   array Array,
+ *   mapper (item any, index number, array Array)=>Promise|any,
+ * ) -> Promise|Array
+ * ```
+ *
+ * @description
+ * Apply a mapper to each item of an array, returning an array. Mapper may be asynchronous.
+ */
+
+const arrayMapHandlePromise = function (
+  result, promise, index, promiseCounts, _promise
+) {
+  promiseCounts.pending += 1
+  promise.then(value => {
+    result[index] = value
+    promiseCounts.resolved += 1
+    if (promiseCounts.resolved == promiseCounts.pending) {
+      _promise._fulfill(result)
+    }
+  }, error => {
+    _promise.reject(error)
+  })
+}
+
+const arrayMap2 = function (array, mapper) {
+  const length = array.length
+  const result = Array(length)
+  const promiseCounts = { pending: 0, resolved: 0 }
+
+  let index = -1
+  let _promise = new _Promise()
+
+  while (++index < length) {
+    const ret = mapper(array[index], index, array)
+    if (isPromise(ret)) {
+      arrayMapHandlePromise(result, ret, index, promiseCounts, _promise)
+    } else {
+      result[index] = ret
+    }
+  }
+
+  if (promiseCounts.pending == 0) {
+    return result
+  }
+
+  return _promise
+}
+
+if (process.argv[1] == __filename) {
+  const timeInLoopAsync = require('./timeInLoopAsync')
+
+  timeInLoopAsync('arrayMap2', 1e6, async () => {
+    await arrayMap2([1, 2, 3, 4, 5], async value => value + 1)
+  })
+}
+
+module.exports = arrayMap2

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

@@ -0,0 +1,34 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('..')
+const _ = require('lodash')
+const R = require('ramda')
+
+const isOdd = number => number % 2 == 1
+
+const isEven = number => number % 2 == 0
+
+/**
+ * @name allRace
+ *
+ * @benchmark
+ * _.every: 1e+6: 20.984ms
+ * R.all: 1e+6: 368.142ms
+ * rubico.all: 1e+6: 24.772ms
+ *
+ * @remarks
+ * promise check
+ */
+
+{
+  const evenNumbers = [2, 4, 6, 8, 10]
+
+  // console.log(_.every(evenNumbers, isEven))
+  // console.log(R.all(isEven)(evenNumbers))
+  // console.log(rubico.all(isEven)(evenNumbers))
+
+  // timeInLoop('_.every', 1e6, () => _.every(evenNumbers, isEven))
+
+  // timeInLoop('R.all', 1e6, () => R.all(isEven)(evenNumbers))
+
+  // timeInLoop('rubico.all', 1e6, () => rubico.all(isEven)(evenNumbers))
+}

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

@@ -0,0 +1,24 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('..')
+
+const { and } = rubico
+
+const isOdd = x => x % 2 == 1
+
+const threeOddChecks = number => isOdd(number) && isOdd(number) && isOdd(number)
+
+const threeIsOdd = and([isOdd, isOdd, isOdd])
+
+/**
+ * @name or
+ *
+ * @benchmark
+ * isOdd(value) && isOdd(value) && isOdd(value): 1e+6: 6.664ms
+ * and([isOdd, isOdd, isOdd]): 1e+6: 16.842ms
+ */
+
+{
+  // timeInLoop('isOdd(value) && isOdd(value) && isOdd(value)', 1e6, () => threeOddChecks(1))
+
+  // timeInLoop('and([isOdd, isOdd, isOdd])', 1e6, () => threeIsOdd(1))
+}

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

@@ -0,0 +1,174 @@
+const timeInLoop = require('../x/timeInLoop')
+const { assign } = require('..')
+
+const isPromise = value => value != null && typeof value.then == 'function'
+
+const promiseAll = Promise.all.bind(Promise)
+
+const funcObjectAll1 = funcs => function objectAllFuncs(...args) {
+  const output = {}, promises = []
+  for (const key in funcs) {
+    const outputItem = funcs[key].apply(null, args)
+    if (isPromise(outputItem)) {
+      promises.push(outputItem.then(res => {
+        output[key] = res
+      }))
+    } else {
+      output[key] = outputItem
+    }
+  }
+  return promises.length == 0 ? output : promiseAll(promises).then(() => output)
+}
+
+const funcObjectAll2 = funcs => function objectAllFuncs(...args) {
+  const output = {}, promises = []
+  for (const key in funcs) {
+    const outputItem = funcs[key](...args)
+    if (isPromise(outputItem)) {
+      promises.push(outputItem.then(res => {
+        output[key] = res
+      }))
+    } else {
+      output[key] = outputItem
+    }
+  }
+  return promises.length == 0 ? output : promiseAll(promises).then(() => output)
+}
+
+const funcObjectAll3 = funcs => function objectAllFuncs(...args) {
+  const result = {}
+  let isAsync = false
+  for (const key in funcs) {
+    const resultItem = funcs[key](...args)
+    if (isPromise(resultItem)) isAsync = true
+    result[key] = resultItem
+  }
+  return isAsync ? promiseObjectAll(result) : result
+}
+
+
+const vanilla1 = ({ number }) => ({
+  number,
+  a: number + 1,
+  b: number + 2,
+  c: number + 3,
+})
+
+const funcs = {
+  a: ({ number }) => number + 1,
+  b: ({ number }) => number + 2,
+  c: ({ number }) => number + 3,
+}
+
+const vanilla2 = function (obj) {
+  const output = { ...obj }
+  for (const key in funcs) {
+    output[key] = funcs[key](obj)
+  }
+  return output
+}
+
+const assign1 = function (funcs) {
+  const allFuncs = funcObjectAll1.call(null, funcs)
+  return function assignment(input) {
+    const output = allFuncs.call(null, input)
+    return isPromise(output)
+      ? output.then(res => ({ ...input, ...res }))
+      : ({ ...input, ...output })
+  }
+}
+
+const assign2 = function (funcs) {
+  const allFuncs = funcObjectAll2(funcs)
+  return function assignment(input) {
+    const output = allFuncs(input)
+    return isPromise(output)
+      ? output.then(res => ({ ...input, ...res }))
+      : ({ ...input, ...output })
+  }
+}
+
+const assign3 = function (funcs) {
+  const allFuncs = funcObjectAll3(funcs)
+  return function assignment(input) {
+    const output = allFuncs(input)
+    return isPromise(output)
+      ? output.then(res => ({ ...input, ...res }))
+      : ({ ...input, ...output })
+  }
+}
+
+// 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 objectAssign = Object.assign
+
+const objectAssign = (objA, objB) => ({ ...objA, ...objB })
+
+const assign5 = function (funcs) {
+  const allFuncs = funcObjectAll3(funcs)
+  return function assignment(object) {
+    const result = allFuncs(object)
+    return isPromise(result)
+      ? result.then(curry2(objectAssign, object, __))
+      : ({ ...object, ...result })
+  }
+}
+
+/**
+ * @name assign
+ *
+ * @benchmark
+ * assign1: 1e+5: 67.168ms
+ * assign2: 1e+5: 60.779ms
+ * assign3: 1e+5: 58.094ms
+ * assign5: 1e+5: 59.132ms
+ *
+ * @remarks
+ * currying is slower here
+ */
+
+{
+
+  // console.log('assign1', assign1(funcs)({ number: 2 }))
+  // console.log('assign2', assign2(funcs)({ number: 2 }))
+  // console.log('assign3', assign3(funcs)({ number: 2 }))
+  // console.log('assign5', assign5(funcs)({ number: 2 }))
+
+  // timeInLoop('assign1', 1e5, () => assign1(funcs)({ number: 2 }))
+
+  // timeInLoop('assign2', 1e5, () => assign2(funcs)({ number: 2 }))
+
+  // timeInLoop('assign3', 1e5, () => assign3(funcs)({ number: 2 }))
+
+  // timeInLoop('assign5', 1e5, () => assign5(funcs)({ number: 2 }))
+}

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

@@ -0,0 +1,55 @@
+const rubico = require('..')
+const timeInLoop = require('../x/timeInLoop')
+const R = require('ramda')
+const curry1 = require('../_internal/curry1')
+const curry2 = require('../_internal/curry2')
+const curry3 = require('../_internal/curry3')
+const curry4 = require('../_internal/curry4')
+
+const { __ } = rubico
+
+/**
+ * @name curryRace
+ *
+ * @benchmark
+ * rubico.curry: 1e+5: 60.554ms
+ * R.curry: 1e+5: 106.163ms
+ */
+const add6 = (a, b, c, d, e, f) => a + b + c + d + e + f
+
+// console.log(rubico.curry(add6)(1, 2)(3)(4, 5, 6)) // 21
+// console.log(R.curry(add6)(1, 2)(3)(4, 5, 6)) // 21
+
+// timeInLoop('rubico.curry', 1e5, () => rubico.curry(add6)(1, 2)(3)(4, 5, 6))
+// timeInLoop('R.curry', 1e5, () => R.curry(add6)(1, 2)(3)(4, 5, 6))
+
+/**
+ * @name curryPlaceholderRace
+ *
+ * @benchmark
+ * rubico.curry: 1e+5: 98.834ms
+ * R.curry: 1e+5: 147.693ms
+ */
+// console.log(rubico.curry(add6)(1, 2, rubico.__)(3)(4, rubico.__, 6)(5)) // 21
+// console.log(R.curry(add6)(1, 2, R.__)(3)(4, R.__, 6)(5)) // 21
+
+// timeInLoop('rubico.curry', 1e5, () => rubico.curry(add6)(1, 2, rubico.__)(3)(4, rubico.__, 6)(5))
+// timeInLoop('R.curry', 1e5, () => R.curry(add6)(1, 2, R.__)(3)(4, R.__, 6)(5))
+
+/**
+ * @name curryRaceUnary
+ *
+ * @benchmark
+ * rubico.curry: 1e+5: 60.554ms
+ * R.curry: 1e+5: 106.163ms
+ *
+ * rubico.curry: 1e+5: 45.475ms
+ * R.curry: 1e+5: 66.493ms
+ */
+const identity = value => value
+
+// console.log(rubico.curry(identity)(__)(1)) // 1
+// console.log(R.curry(identity)(R.__)(1)) // 1
+
+// timeInLoop('rubico.curry', 1e5, () => rubico.curry(identity)(__)(1))
+// timeInLoop('R.curry', 1e5, () => R.curry(identity)(R.__)(1))

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

@@ -0,0 +1,25 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('..')
+const _ = require('lodash')
+const R = require('ramda')
+
+/**
+ * @name eq
+ *
+ * @benchmark
+ * rubico.eq(0, 0): 1e+7: 12.499ms
+ * _.eq(0, 0): 1e+7: 12.585ms
+ * R.equals(0, 0): 1e+7: 196.767ms
+ */
+
+const rubicoEq = rubico.eq(0, 0)
+
+// console.log(rubicoEq())
+// console.log(_.eq(0, 0))
+// console.log(R.equals(0, 0))
+
+// timeInLoop('rubico.eq(0, 0)', 1e7, () => rubicoEq())
+
+// timeInLoop('_.eq(0, 0)', 1e7, () => _.eq(0, 0))
+
+// timeInLoop('R.equals(0, 0)', 1e7, () => R.equals(0, 0))