rubico 1.9.7 → 2.0.0

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

@@ -0,0 +1,28 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('rubico')
+const _ = require('lodash')
+
+/**
+ * @name omitRace
+ *
+ * @benchmark
+ * rubico.omit(['a', 'b', 'c'])(object): 1e+6: 599.19ms
+ * _.omit(['a', 'b', 'c'])(object): 1e+6: 2.651s
+ *
+ * 2020-11-30
+ * rubico.omit(['a', 'b', 'c'])(object): 1e+6: 628.47ms
+ * _.omit(['a', 'b', 'c'])(object): 1e+6: 2.595s
+ */
+
+{
+  const objectABCDE = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+
+  const keys = ['a', 'b', 'c']
+
+  // console.log(rubico.omit(keys)(objectABCDE))
+  // console.log(_.omit(objectABCDE, keys))
+
+  // timeInLoop("rubico.omit(['a', 'b', 'c'])(object)", 1e6, () => rubico.omit(keys)(objectABCDE))
+
+  // timeInLoop("_.omit(['a', 'b', 'c'])(object)", 1e6, () => _.omit(objectABCDE, keys))
+}

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

@@ -0,0 +1,51 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('..')
+
+const { or } = rubico
+
+const isPromise = value => value != null && typeof value.then == 'function'
+
+const isOdd = x => x % 2 == 1
+
+const threeOddChecks = number => isOdd(number) || isOdd(number) || isOdd(number)
+
+const threeIsOdd = or([isOdd, isOdd, isOdd])
+
+const arrayOr = (fns, x) => {
+  const promises = []
+  for (let i = 0; i < fns.length; i++) {
+    const point = fns[i](x)
+    if (isPromise(point)) promises.push(point)
+    else if (point) return (promises.length > 0
+      ? Promise.all(promises).then(() => true)
+      : true)
+  }
+  return (promises.length > 0
+    ? Promise.all(promises).then(res => res.some(x => x))
+    : false)
+}
+
+const isOddArray = [isOdd, isOdd, isOdd]
+
+/**
+ * @name or
+ *
+ * @benchmark
+ * isOdd(value) || isOdd(value) || isOdd(value): 1e+6: 5.96ms
+ * arrayOr([isOdd, isOdd, isOdd]): 1e+6: 27.249ms
+ * or([isOdd, isOdd, isOdd]): 1e+6: 15.245ms
+ *
+ * @remarks
+ * ...args slows down from ~48ms
+ */
+
+{
+  // console.log(arrayOr(isOddArray, 2))
+  // console.log(or([isOdd, isOdd, isOdd])(2))
+
+  // timeInLoop('isOdd(value) || isOdd(value) || isOdd(value)', 1e6, () => threeOddChecks(2))
+
+  // timeInLoop('arrayOr([isOdd, isOdd, isOdd])', 1e6, () => arrayOr(isOddArray, 2))
+
+  // timeInLoop('or([isOdd, isOdd, isOdd])', 1e6, () => threeIsOdd(2))
+}

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

@@ -0,0 +1,24 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('rubico')
+const _ = require('lodash')
+
+/**
+ * @name pickRace
+ *
+ * @benchmark
+ * rubico.pick(['a', 'b', 'c'])(object): 1e+6: 165.468ms
+ * _.pick(['a', 'b', 'c'])(object): 1e+6: 1.324s
+ */
+
+{
+  const objectABCDE = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+
+  const keys = ['a', 'b', 'c']
+
+  // console.log(rubico.pick(keys)(objectABCDE))
+  // console.log(_.pick(objectABCDE, keys))
+
+  // timeInLoop("rubico.pick(['a', 'b', 'c'])(object)", 1e6, () => rubico.pick(keys)(objectABCDE))
+
+  // timeInLoop("_.pick(['a', 'b', 'c'])(object)", 1e6, () => _.pick(objectABCDE, keys))
+}

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

@@ -0,0 +1,152 @@
+const timeInLoop = require('../x/timeInLoop')
+const _ = require('lodash/fp')
+const { pipe } = require('..')
+const R = require('ramda')
+
+const isPromise = value => value != null && typeof value.then == 'function'
+
+/**
+ * @name funcConcat
+ *
+ * @benchmark
+ * funcConcat1: 1e+6: 25.164ms
+ * funcConcat2: 1e+6: 26.097ms
+ * funcConcat20: 1e+6: 25.276ms
+ * funcConcat30: 1e+6: 24.74ms
+ * funcConcat31: 1e+6: 15.768ms
+ *
+ * funcConcat1 - async: 1e+6: 302.914ms
+ * funcConcat2 - async: 1e+6: 302.83ms
+ * funcConcat20 - async: 1e+6: 297.492ms
+ * funcConcat30 - async: 1e+6: 250.784ms
+ * funcConcat31 - async: 1e+6: 244.547ms
+ */
+
+const funcConcat1 = (funcA, funcB) => function pipedFunction(...args) {
+  const intermediate = funcA.apply(null, args)
+  const resolver = _funcCallResolver(funcB)
+  return isPromise(intermediate)
+    ? intermediate.then(res => funcB.call(null, res))
+    : funcB.call(null, intermediate)
+}
+
+const _funcCallResolver = func => function resolver(value) {
+  return func.call(null, value)
+}
+
+const funcConcat2 = (funcA, funcB) => function pipedFunction(...args) {
+  const intermediate = funcA.apply(null, args)
+  const resolver = _funcCallResolver(funcB)
+  return isPromise(intermediate)
+    ? intermediate.then(resolver)
+    : resolver(intermediate)
+}
+
+const funcConcat20 = (funcA, funcB) => function pipedFunction(...args) {
+  const intermediate = funcA.apply(null, args)
+  const resolver = _funcCallResolver(funcB)
+  return isPromise(intermediate)
+    ? intermediate.then(resolver)
+    : funcB.call(null, intermediate)
+}
+
+const funcConcat30 = (funcA, funcB) => function pipedFunction(...args) {
+  const intermediate = funcA.apply(null, args)
+  return isPromise(intermediate)
+    ? intermediate.then(funcB)
+    : funcB.call(null, intermediate)
+}
+
+const funcConcat31 = (funcA, funcB) => function pipedFunction(...args) {
+  const intermediate = funcA(...args)
+  return isPromise(intermediate)
+    ? intermediate.then(funcB)
+    : funcB(intermediate)
+}
+
+{
+  const funcA = number => number + 1
+
+  const funcB = number => number + 2
+
+  const asyncFuncA = async number => number + 1
+
+  const asyncFuncB = async number => number + 2
+
+  // console.log(funcConcat1(funcA, funcB)(2))
+  // console.log(funcConcat2(funcA, funcB)(2))
+  // console.log(funcConcat20(funcA, funcB)(2))
+  // console.log(funcConcat30(funcA, funcB)(2))
+  // console.log(funcConcat31(funcA, funcB)(2))
+  // funcConcat1(asyncFuncA, asyncFuncB)(2).then(console.log)
+  // funcConcat2(asyncFuncA, asyncFuncB)(2).then(console.log)
+  // funcConcat20(asyncFuncA, asyncFuncB)(2).then(console.log)
+  // funcConcat30(asyncFuncA, asyncFuncB)(2).then(console.log)
+  // funcConcat31(asyncFuncA, asyncFuncB)(2).then(console.log)
+
+  // timeInLoop('funcConcat1', 1e6, () => funcConcat1(funcA, funcB)(2))
+
+  // timeInLoop('funcConcat2', 1e6, () => funcConcat2(funcA, funcB)(2))
+
+  // timeInLoop('funcConcat20', 1e6, () => funcConcat20(funcA, funcB)(2))
+
+  // timeInLoop('funcConcat30', 1e6, () => funcConcat30(funcA, funcB)(2))
+
+  // timeInLoop('funcConcat31', 1e6, () => funcConcat31(funcA, funcB)(2))
+
+  // timeInLoop.async('funcConcat1 - async', 1e6, () => funcConcat1(asyncFuncA, asyncFuncB)(2))
+
+  // timeInLoop.async('funcConcat2 - async', 1e6, () => funcConcat2(asyncFuncA, asyncFuncB)(2))
+
+  // timeInLoop.async('funcConcat20 - async', 1e6, () => funcConcat20(asyncFuncA, asyncFuncB)(2))
+
+  // timeInLoop.async('funcConcat30 - async', 1e6, () => funcConcat30(asyncFuncA, asyncFuncB)(2))
+
+  // timeInLoop.async('funcConcat31 - async', 1e6, () => funcConcat31(asyncFuncA, asyncFuncB)(2))
+}
+
+const funcConcatSync = (
+  funcA, funcB,
+) => function pipedFunction(...args) {
+  return funcB(funcA(...args))
+}
+
+const pipeSync = funcs => funcs.reduce(funcConcatSync)
+
+/**
+ * @name pipe
+ *
+ * @benchmark
+ * rubico.pipe: 1e+6: 249.955ms
+ * rubico.pipe.sync: 1e+6: 94.613ms
+ * _.pipe: 1e+6: 463.235ms
+ * R.pipe: 1e+6: 1.034s
+ */
+
+
+const funcs = [
+  number => number + 1,
+  number => number + 2,
+  number => number + 3,
+]
+
+const rubicoPipeline = pipe(funcs)
+
+const pipeSyncPipeline = pipeSync(funcs)
+
+const lodashPipeline = _.pipe(funcs)
+
+const ramdaPipeline = R.pipe(...funcs)
+
+// console.log('rubicoPipeline(2)', pipe(funcs)(2))
+// console.log('pipeSyncPipeline(2)', pipe.sync(funcs)(2))
+// console.log('lodashPipeline(2)', _.pipe(funcs)(2))
+// console.log('ramdaPipeline(2)', R.pipe(...funcs)(2))
+
+// timeInLoop('rubico.pipe', 1e6, () => pipe(funcs)(2))
+
+// timeInLoop('rubico.pipe.sync', 1e6, () => pipe.sync(funcs)(2))
+
+// timeInLoop('_.pipe', 1e6, () => _.pipe(funcs)(2))
+
+// timeInLoop('R.pipe', 1e6, () => R.pipe(funcs[0], funcs[1], funcs[2])(2))