@typed/fx 0.0.9 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/fx",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "High-performance Asynchronous Effects",
   "type": "module",
   "main": "esm/index.js",
@@ -16,20 +16,23 @@
     "mocha": "mocha 'src/**/*.test.ts'",
     "coverage": "c8 --include 'src/**/*' --all npm run mocha",
     "typecheck": "NODE_OPTIONS=--max-old-space-size=4096 tsc --noEmit -p ./tsconfig.build.esm.json",
-    "test": "concurrently npm:eslint npm:mocha npm:typecheck",
+    "test": "npm run mocha && concurrently npm:eslint npm:typecheck",
     "preversion": "npm test",
     "postversion": "npm run build && npm publish --access=public",
     "prepare": "ts-patch install -s",
-    "perf:stream:filter-map-reduce": "node --loader @esbuild-kit/esm-loader perf/filter-map-reduce.ts",
-    "perf:stream:flatMap": "node --loader @esbuild-kit/esm-loader perf/flatMap.ts",
-    "perf:stream:switchMap": "node --loader @esbuild-kit/esm-loader perf/switchMap.ts"
+    "perf": "node --loader @esbuild-kit/esm-loader perf/runFullSuite.ts",
+    "perf:filter-map-reduce": "npm run perfTest filter-map-reduce",
+    "perf:flatMap": "npm run perfTest flatMap",
+    "perf:switchMap": "npm run perfTest switchMap",
+    "perfTest": "node --loader @esbuild-kit/esm-loader perf/runPerfTest.ts"
   },
   "keywords": [
     "Fx",
     "Stream",
     "Async",
     "Dependency Injection",
-    "hkt-ts"
+    "effect-ts",
+    "fp-ts"
   ],
   "author": "Tylor Steinberger (tlsteinberger167@gmail.com)",
   "license": "MIT",
@@ -53,6 +56,7 @@
     "@types/mocha": "^9.1.1",
     "@types/node": "^17.0.45",
     "@types/prettier": "^2.7.0",
+    "@types/yargs": "^17.0.13",
     "@typescript-eslint/eslint-plugin": "^5.34.0",
     "@typescript-eslint/parser": "^5.34.0",
     "@zoltu/typescript-transformer-append-js-extension": "^1.0.1",
@@ -79,7 +83,8 @@
     "tslib": "^2.4.0",
     "tsx": "^3.8.2",
     "typescript": "^4.7.4",
-    "typescript-transform-paths": "^3.3.1"
+    "typescript-transform-paths": "^3.3.1",
+    "yargs": "^17.6.0"
   },
   "exports": {
     ".": {
@@ -102,26 +107,6 @@
         "types": "./esm/Fx.d.ts"
       }
     },
-    "./Sink": {
-      "require": {
-        "default": "./cjs/Sink.js",
-        "types": "./cjs/Sink.d.ts"
-      },
-      "import": {
-        "default": "./esm/Sink.js",
-        "types": "./esm/Sink.d.ts"
-      }
-    },
-    "./TSemaphore": {
-      "require": {
-        "default": "./cjs/TSemaphore.js",
-        "types": "./cjs/TSemaphore.d.ts"
-      },
-      "import": {
-        "default": "./esm/TSemaphore.js",
-        "types": "./esm/TSemaphore.d.ts"
-      }
-    },
     "./_internal": {
       "require": {
         "default": "./cjs/_internal.js",
@@ -172,16 +157,6 @@
         "types": "./esm/delay.d.ts"
       }
     },
-    "./drain": {
-      "require": {
-        "default": "./cjs/drain.js",
-        "types": "./cjs/drain.d.ts"
-      },
-      "import": {
-        "default": "./esm/drain.js",
-        "types": "./esm/drain.d.ts"
-      }
-    },
     "./during": {
       "require": {
         "default": "./cjs/during.js",
@@ -192,14 +167,24 @@
         "types": "./esm/during.d.ts"
       }
     },
-    "./empty": {
+    "./filterLoop": {
       "require": {
-        "default": "./cjs/empty.js",
-        "types": "./cjs/empty.d.ts"
+        "default": "./cjs/filterLoop.js",
+        "types": "./cjs/filterLoop.d.ts"
       },
       "import": {
-        "default": "./esm/empty.js",
-        "types": "./esm/empty.d.ts"
+        "default": "./esm/filterLoop.js",
+        "types": "./esm/filterLoop.d.ts"
+      }
+    },
+    "./filterMap": {
+      "require": {
+        "default": "./cjs/filterMap.js",
+        "types": "./cjs/filterMap.d.ts"
+      },
+      "import": {
+        "default": "./esm/filterMap.js",
+        "types": "./esm/filterMap.d.ts"
       }
     },
     "./flatMap": {
@@ -222,26 +207,6 @@
         "types": "./esm/flatMapConcurrently.d.ts"
       }
     },
-    "./from": {
-      "require": {
-        "default": "./cjs/from.js",
-        "types": "./cjs/from.d.ts"
-      },
-      "import": {
-        "default": "./esm/from.js",
-        "types": "./esm/from.d.ts"
-      }
-    },
-    "./fromCallback": {
-      "require": {
-        "default": "./cjs/fromCallback.js",
-        "types": "./cjs/fromCallback.d.ts"
-      },
-      "import": {
-        "default": "./esm/fromCallback.js",
-        "types": "./esm/fromCallback.d.ts"
-      }
-    },
     "./fromEffect": {
       "require": {
         "default": "./cjs/fromEffect.js",
@@ -252,6 +217,16 @@
         "types": "./esm/fromEffect.d.ts"
       }
     },
+    "./fromIterable": {
+      "require": {
+        "default": "./cjs/fromIterable.js",
+        "types": "./cjs/fromIterable.d.ts"
+      },
+      "import": {
+        "default": "./esm/fromIterable.js",
+        "types": "./esm/fromIterable.d.ts"
+      }
+    },
     "./hold": {
       "require": {
         "default": "./cjs/hold.js",
@@ -262,24 +237,24 @@
         "types": "./esm/hold.d.ts"
       }
     },
-    "./loop": {
+    "./mapCause": {
       "require": {
-        "default": "./cjs/loop.js",
-        "types": "./cjs/loop.d.ts"
+        "default": "./cjs/mapCause.js",
+        "types": "./cjs/mapCause.d.ts"
       },
       "import": {
-        "default": "./esm/loop.js",
-        "types": "./esm/loop.d.ts"
+        "default": "./esm/mapCause.js",
+        "types": "./esm/mapCause.d.ts"
       }
     },
-    "./map": {
+    "./mapEffect": {
       "require": {
-        "default": "./cjs/map.js",
-        "types": "./cjs/map.d.ts"
+        "default": "./cjs/mapEffect.js",
+        "types": "./cjs/mapEffect.d.ts"
       },
       "import": {
-        "default": "./esm/map.js",
-        "types": "./esm/map.d.ts"
+        "default": "./esm/mapEffect.js",
+        "types": "./esm/mapEffect.d.ts"
       }
     },
     "./merge": {
@@ -302,26 +277,6 @@
         "types": "./esm/multicast.d.ts"
       }
     },
-    "./never": {
-      "require": {
-        "default": "./cjs/never.js",
-        "types": "./cjs/never.d.ts"
-      },
-      "import": {
-        "default": "./esm/never.js",
-        "types": "./esm/never.d.ts"
-      }
-    },
-    "./observe": {
-      "require": {
-        "default": "./cjs/observe.js",
-        "types": "./cjs/observe.d.ts"
-      },
-      "import": {
-        "default": "./esm/observe.js",
-        "types": "./esm/observe.d.ts"
-      }
-    },
     "./orElse": {
       "require": {
         "default": "./cjs/orElse.js",
@@ -352,14 +307,44 @@
         "types": "./esm/provide.d.ts"
       }
     },
-    "./reduce": {
+    "./runCollect": {
       "require": {
-        "default": "./cjs/reduce.js",
-        "types": "./cjs/reduce.d.ts"
+        "default": "./cjs/runCollect.js",
+        "types": "./cjs/runCollect.d.ts"
       },
       "import": {
-        "default": "./esm/reduce.js",
-        "types": "./esm/reduce.d.ts"
+        "default": "./esm/runCollect.js",
+        "types": "./esm/runCollect.d.ts"
+      }
+    },
+    "./runDrain": {
+      "require": {
+        "default": "./cjs/runDrain.js",
+        "types": "./cjs/runDrain.d.ts"
+      },
+      "import": {
+        "default": "./esm/runDrain.js",
+        "types": "./esm/runDrain.d.ts"
+      }
+    },
+    "./runObserve": {
+      "require": {
+        "default": "./cjs/runObserve.js",
+        "types": "./cjs/runObserve.d.ts"
+      },
+      "import": {
+        "default": "./esm/runObserve.js",
+        "types": "./esm/runObserve.d.ts"
+      }
+    },
+    "./runReduce": {
+      "require": {
+        "default": "./cjs/runReduce.js",
+        "types": "./cjs/runReduce.d.ts"
+      },
+      "import": {
+        "default": "./esm/runReduce.js",
+        "types": "./esm/runReduce.d.ts"
       }
     },
     "./scheduled": {
@@ -442,16 +427,6 @@
         "types": "./esm/switchMap.d.ts"
       }
     },
-    "./takeUntil": {
-      "require": {
-        "default": "./cjs/takeUntil.js",
-        "types": "./cjs/takeUntil.d.ts"
-      },
-      "import": {
-        "default": "./esm/takeUntil.js",
-        "types": "./esm/takeUntil.d.ts"
-      }
-    },
     "./takeWhile": {
       "require": {
         "default": "./cjs/takeWhile.js",
@@ -462,14 +437,14 @@
         "types": "./esm/takeWhile.d.ts"
       }
     },
-    "./tap": {
+    "./tapEffect": {
       "require": {
-        "default": "./cjs/tap.js",
-        "types": "./cjs/tap.d.ts"
+        "default": "./cjs/tapEffect.js",
+        "types": "./cjs/tapEffect.d.ts"
       },
       "import": {
-        "default": "./esm/tap.js",
-        "types": "./esm/tap.d.ts"
+        "default": "./esm/tapEffect.js",
+        "types": "./esm/tapEffect.d.ts"
       }
     },
     "./throttle": {
@@ -502,6 +477,16 @@
         "types": "./esm/until.d.ts"
       }
     },
+    "./withEmitter": {
+      "require": {
+        "default": "./cjs/withEmitter.js",
+        "types": "./cjs/withEmitter.d.ts"
+      },
+      "import": {
+        "default": "./esm/withEmitter.js",
+        "types": "./esm/withEmitter.d.ts"
+      }
+    },
     "./zip": {
       "require": {
         "default": "./cjs/zip.js",
@@ -512,14 +497,14 @@
         "types": "./esm/zip.d.ts"
       }
     },
-    "./zipItems": {
+    "./zipIterable": {
       "require": {
-        "default": "./cjs/zipItems.js",
-        "types": "./cjs/zipItems.d.ts"
+        "default": "./cjs/zipIterable.js",
+        "types": "./cjs/zipIterable.d.ts"
       },
       "import": {
-        "default": "./esm/zipItems.js",
-        "types": "./esm/zipItems.d.ts"
+        "default": "./esm/zipIterable.js",
+        "types": "./esm/zipIterable.d.ts"
       }
     }
   }

package/perf/_internal.ts

@@ -1,4 +1,4 @@
-import { performance } from 'node:perf_hooks'
+import process from 'node:process'
 
 import * as EffectStream from '@effect/core/Stream/Stream'
 import * as Effect from '@effect/core/io/Effect'
@@ -19,35 +19,45 @@ export function parseIterations() {
 export const iterations = parseIterations()
 export const array = Array.from({ length: iterations }, (_, i) => i)
 
-export function runSuite(suite: Suite) {
-  suite.on('start', logStart).on('cycle', logResults).on('complete', logComplete).run()
+export function runSuite(suite: Suite, cb: () => void) {
+  suite
+    .on('start', logStart)
+    .on('cycle', logResults)
+    .on('complete', () => {
+      logComplete()
+      cb()
+    })
+    .run({ defer: false })
 }
 
+const longestLibrary = 13
+const longestOps = 10
+
 function logResults(e: any) {
   const t = e.target
 
   if (t.failure) {
+    console.log(`| ${t.name} | FAILED | ${e.target.failure} |`)
+
     console.error(padl(10, t.name) + 'FAILED: ' + e.target.failure)
   } else {
-    const result =
-      padl(18, t.name) +
-      padr(13, t.hz.toFixed(2) + ' op/s') +
-      ' \xb1' +
-      padr(7, t.stats.rme.toFixed(2) + '%') +
-      padr(15, ' (' + t.stats.sample.length + ' samples)')
-
-    console.log(result)
+    console.log(
+      `| ${padl(longestLibrary, t.name)} | ${padl(longestOps, t.hz.toFixed(2))} | ${padl(
+        6,
+        t.stats.rme.toFixed(2) + '%',
+      )} | ${padl(3, t.stats.sample.length)}      |`,
+    )
   }
 }
 
 function logStart(this: any) {
-  console.log(this.name)
-  console.log('-------------------------------------------------------')
+  console.log('### ' + this.name)
+  console.log(`| Library       | Ops/sec    | ±      | Samples |
+| --------------|------------|--------|---------|`)
 }
 
 function logComplete() {
-  console.log('-------------------------------------------------------')
-  process.exit(0)
+  console.log('-------------------------------------------------------\n')
 }
 
 function padl(n: number, s: string) {
@@ -57,20 +67,12 @@ function padl(n: number, s: string) {
   return s
 }
 
-function padr(n: number, s: string) {
-  while (s.length < n) {
-    s = ' ' + s
-  }
-  return s
-}
-
-export function timeConstruction(label: string) {
-  const start = performance.now()
-  return () => {
-    const end = performance.now()
-    console.log(label, end - start)
-  }
-}
+// function padr(n: number, s: string) {
+//   while (s.length < n) {
+//     s = ' ' + s
+//   }
+//   return s
+// }
 
 export interface PerformanceTest {
   readonly name: string
@@ -91,27 +93,29 @@ export function PerformanceTestCase<A>(
   return { name, init, run }
 }
 
-export function runPerformanceTest(test: PerformanceTest) {
+export function runPerformanceTest(test: PerformanceTest, cb: () => void) {
   // eslint-disable-next-line import/no-named-as-default-member
   let suite = new benchmark.Suite(test.name)
 
   for (const testCase of test.cases) {
-    const end = timeConstruction(testCase.name)
     const constructed = testCase.init()
-    end()
 
     suite = suite.add(testCase.name, (deferred: benchmark.Deferred) =>
       testCase.run(constructed, deferred),
     )
   }
 
-  runSuite(suite)
+  runSuite(suite, cb)
 }
 
-export function fxTest<E, A, E1>(init: () => Fx.Fx<never, E, A, E1>) {
+export function fxTest<E, A>(init: () => Fx.Fx<never, E, A>) {
   return PerformanceTestCase(
     'Fx',
-    () => Fx.drainNow(init()),
+    () => {
+      const push = init()
+
+      return Fx.runDrain(push)
+    },
     (fx, deferred) => Effect.unsafeRunAsyncWith(fx, () => deferred.resolve()),
   )
 }

package/perf/cases/filter-map-reduce.ts

@@ -0,0 +1,48 @@
+import * as EffectStream from '@effect/core/Stream/Stream'
+import { pipe } from '@fp-ts/data/Function'
+import * as M from '@most/core'
+import * as Chunk from '@tsplus/stdlib/collections/Chunk'
+import * as rxjs from 'rxjs'
+
+import {
+  array,
+  effectTsStreamTest,
+  fxEffectTest,
+  iterations,
+  mostStreamTest,
+  rxjsObservableTest,
+} from '../_internal.js'
+
+import * as Stream from '@/index.js'
+
+const filterEvens = (x: number) => x % 2 === 0
+const addOne = (x: number) => x + 1
+const add = (x: number, y: number): number => x + y
+
+export const name = 'filter -> map -> scan ' + iterations + ' integers'
+
+export const cases = [
+  fxEffectTest(() =>
+    pipe(
+      Stream.fromIterable(array),
+      Stream.filter(filterEvens),
+      Stream.map(addOne),
+      Stream.runReduce(0, add),
+    ),
+  ),
+  mostStreamTest(() =>
+    pipe(M.periodic(0), M.withItems(array), M.filter(filterEvens), M.map(addOne), M.scan(add, 0)),
+  ),
+  rxjsObservableTest(() =>
+    pipe(rxjs.from(array), rxjs.filter(filterEvens), rxjs.map(addOne), rxjs.scan(add, 0)),
+  ),
+
+  effectTsStreamTest(() =>
+    pipe(
+      EffectStream.fromChunk(Chunk.from(array)),
+      EffectStream.filter(filterEvens),
+      EffectStream.map(addOne),
+      EffectStream.scan(0, add),
+    ),
+  ),
+]

package/perf/cases/flatMap.ts

@@ -0,0 +1,49 @@
+import * as EffectStream from '@effect/core/Stream/Stream'
+import { pipe } from '@fp-ts/data/Function'
+import * as M from '@most/core'
+import * as Chunk from '@tsplus/stdlib/collections/Chunk'
+import * as rxjs from 'rxjs'
+
+import {
+  array,
+  effectTsStreamTest,
+  fxTest,
+  iterations,
+  mostStreamTest,
+  rxjsObservableTest,
+} from '../_internal.js'
+
+import * as Stream from '@/index.js'
+
+const nestedArray = array.map((x) => Array.from({ length: x }, (_, i) => x * 1000 + i))
+
+const add = (x: number, y: number): number => x + y
+
+export const name = 'flatMap ' + iterations + ' x ' + iterations + ' integers'
+export const cases = [
+  fxTest(() =>
+    pipe(
+      Stream.fromIterable(nestedArray),
+      Stream.flatMap(Stream.fromIterable),
+      Stream.scan(0, add),
+    ),
+  ),
+  mostStreamTest(() =>
+    pipe(
+      M.periodic(0),
+      M.withItems(nestedArray),
+      M.chain((ns) => pipe(M.periodic(0), M.withItems(ns))),
+      M.scan(add, 0),
+    ),
+  ),
+  rxjsObservableTest(() =>
+    pipe(rxjs.from(nestedArray), rxjs.flatMap(rxjs.from), rxjs.scan(add, 0)),
+  ),
+  effectTsStreamTest(() =>
+    pipe(
+      EffectStream.fromChunk(Chunk.from(nestedArray)),
+      EffectStream.flatMap((ns) => EffectStream.fromChunk(Chunk.from(ns))),
+      EffectStream.scan(0, add),
+    ),
+  ),
+]

package/perf/cases/switchMap.ts

@@ -0,0 +1,36 @@
+import { pipe } from '@fp-ts/data/Function'
+import * as M from '@most/core'
+import * as rxjs from 'rxjs'
+
+import { array, fxTest, iterations, mostStreamTest, rxjsObservableTest } from '../_internal.js'
+
+import * as Stream from '@/index.js'
+
+const nestedArray = array.map((x) => Array.from({ length: x }, (_, i) => x * 1000 + i))
+
+const add = (x: number, y: number): number => x + y
+
+export const name = 'switchMap ' + iterations + ' x ' + iterations + ' integers'
+
+export const cases = [
+  fxTest(() =>
+    pipe(
+      Stream.fromIterable(nestedArray),
+      Stream.switchMap(Stream.fromIterable),
+      Stream.scan(0, add),
+    ),
+  ),
+  mostStreamTest(() =>
+    pipe(
+      M.periodic(0),
+      M.withItems(nestedArray),
+      M.map((ns) => pipe(M.periodic(0), M.withItems(ns))),
+      M.switchLatest,
+      M.scan(add, 0),
+    ),
+  ),
+  rxjsObservableTest(() =>
+    pipe(rxjs.from(nestedArray), rxjs.switchMap(rxjs.from), rxjs.scan(add, 0)),
+  ),
+  // Effect Stream is pull-based and does not offer switchMap
+]

package/perf/readme-base.md

@@ -0,0 +1,14 @@
+# Performance Tests
+
+Here is the latest output of the perf test suite run on a 2020 13" macbook pro.
+It is worth noting that all the tests utilize entirely synchronous workflows, and thus
+have a great favoring towards Most.js/RxJS in terms of raw performance overhead. 
+
+If you need strict performance over push-based streams, definitely use Most.js, but if you are
+interested in the superpowers of `Effect`, and are interested in using push-based streams as a means
+of orchestration `Fx` is still a great bet as it won't often be your bottleneck.
+
+If you need strict performance no matter what, none of these abstractions should be utilized at all.
+
+## Test Results
+

package/perf/readme.md

@@ -0,0 +1,40 @@
+# Performance Tests
+
+Here is the latest output of the perf test suite run on a 2020 13" macbook pro.
+It is worth noting that all the tests utilize entirely synchronous workflows, and thus
+have a great favoring towards Most.js/RxJS in terms of raw performance overhead. 
+
+If you need strict performance over push-based streams, definitely use Most.js, but if you are
+interested in the superpowers of `Effect`, and are interested in using push-based streams as a means
+of orchestration `Fx` is still a great bet as it won't often be your bottleneck.
+
+If you need strict performance no matter what, none of these abstractions should be utilized at all.
+
+## Test Results
+
+### filter -> map -> scan 10000 integers
+| Library       | Ops/sec    | ±      | Samples |
+| --------------|------------|--------|---------|
+| Fx            | 3801.43    | 5.81%  | 82      |
+| @most/core    | 384094.58  | 12.96% | 64      |
+| RxJS @7       | 2255.04    | 12.60% | 87      |
+| Effect/Stream | 91.50      | 29.12% | 41      |
+-------------------------------------------------------
+
+### flatMap 10000 x 10000 integers
+| Library       | Ops/sec    | ±      | Samples |
+| --------------|------------|--------|---------|
+| Fx            | 6474.91    | 11.85% | 76      |
+| @most/core    | 276654.02  | 19.33% | 46      |
+| RxJS @7       | 10322.11   | 52.99% | 77      |
+| Effect/Stream | 2.29       | 124.34% | 9      |
+-------------------------------------------------------
+
+### switchMap 10000 x 10000 integers
+| Library       | Ops/sec    | ±      | Samples |
+| --------------|------------|--------|---------|
+| Fx            | 4759.84    | 13.52% | 63      |
+| @most/core    | 300663.64  | 14.57% | 55      |
+| RxJS @7       | 16469.83   | 2.63%  | 75      |
+-------------------------------------------------------
+