@typed/fx 0.0.32 → 0.0.34

package/perf/_internal.ts

@@ -1,153 +0,0 @@
-import process from 'node:process'
-
-import * as EffectStream from '@effect/core/Stream/Stream'
-import * as Effect from '@effect/core/io/Effect'
-import * as M from '@most/core'
-import * as MS from '@most/scheduler'
-import * as MT from '@most/types'
-import benchmark, { Suite } from 'benchmark'
-import * as RxJS from 'rxjs'
-
-import * as Fx from '@/index.js'
-
-export function parseIterations() {
-  const i = parseInt(process.argv[2], 10)
-
-  return Number.isNaN(i) ? 10000 : i
-}
-
-export const iterations = parseIterations()
-export const array = Array.from({ length: iterations }, (_, i) => i)
-
-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 {
-    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(`| Library       | Ops/sec    | ±      | Samples |
-| --------------|------------|--------|---------|`)
-}
-
-function logComplete() {
-  console.log('-------------------------------------------------------\n')
-}
-
-function padl(n: number, s: string) {
-  while (s.length < n) {
-    s += ' '
-  }
-  return s
-}
-
-// function padr(n: number, s: string) {
-//   while (s.length < n) {
-//     s = ' ' + s
-//   }
-//   return s
-// }
-
-export interface PerformanceTest {
-  readonly name: string
-  readonly cases: readonly PerformanceTestCase<any>[]
-}
-
-export interface PerformanceTestCase<A> {
-  name: string
-  init: () => A
-  run: (a: A, deferred: benchmark.Deferred) => void
-}
-
-export function PerformanceTestCase<A>(
-  name: string,
-  init: () => A,
-  run: (a: A, deferred: benchmark.Deferred) => void,
-): PerformanceTestCase<A> {
-  return { name, init, run }
-}
-
-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 constructed = testCase.init()
-
-    suite = suite.add(testCase.name, (deferred: benchmark.Deferred) =>
-      testCase.run(constructed, deferred),
-    )
-  }
-
-  runSuite(suite, cb)
-}
-
-export function fxTest<E, A>(init: () => Fx.Fx<never, E, A>) {
-  return PerformanceTestCase(
-    'Fx',
-    () => {
-      const push = init()
-
-      return Fx.runDrain(push)
-    },
-    (fx, deferred) => Effect.unsafeRunAsyncWith(fx, () => deferred.resolve()),
-  )
-}
-
-export function fxEffectTest<E, A>(init: () => Effect.Effect<never, E, A>) {
-  return PerformanceTestCase('Fx', init, (e, deferred) => {
-    Effect.unsafeRunPromise(e).then(() => deferred.resolve())
-  })
-}
-
-export function mostStreamTest<A>(init: () => MT.Stream<A>) {
-  const mostScheduler = MS.newDefaultScheduler()
-
-  return PerformanceTestCase('@most/core', init, (mostStream, deferred) =>
-    M.runEffects(mostStream, mostScheduler).then(() => deferred.resolve()),
-  )
-}
-
-export function rxjsObservableTest<A>(init: () => RxJS.Observable<A>) {
-  return PerformanceTestCase('RxJS @7', init, (observable, deferred) => {
-    observable.subscribe({
-      complete: () => deferred.resolve(),
-    })
-  })
-}
-
-export function effectTsStreamTest<E, A>(init: () => EffectStream.Stream<never, E, A>) {
-  return PerformanceTestCase(
-    'Effect/Stream',
-    () => EffectStream.runDrain(init()),
-    (e, deferred) => {
-      Effect.unsafeRunPromise(e).then(() => deferred.resolve())
-    },
-  )
-}

package/perf/cases/flatMap.ts

@@ -1,49 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,14 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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      |
--------------------------------------------------------
-

package/perf/runFullSuite.ts

@@ -1,37 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import * as fs from 'node:fs'
-import { basename, dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const currentDir = dirname(fileURLToPath(import.meta.url))
-const casesDir = join(currentDir, '/cases')
-
-export const runPerfTestPath = join(currentDir, 'runPerfTest.ts')
-export const readmeBasePath = join(currentDir, 'readme-base.md')
-export const readmePath = join(currentDir, 'readme.md')
-export const fileNames = fs.readdirSync(casesDir).map((x) => basename(x))
-
-let readmeContent = fs.readFileSync(readmeBasePath, 'utf-8').toString()
-
-for (const fileName of fileNames) {
-  console.log('Running', 'cases/' + basename(fileName), '\n')
-
-  const { stdout } = spawnSync(`node`, [
-    `--loader`,
-    `@esbuild-kit/esm-loader`,
-    `${runPerfTestPath}`,
-    `${fileName}`,
-  ])
-
-  const output = stdout.toString()
-
-  console.log(output)
-
-  readmeContent += output
-}
-
-if (fs.existsSync(readmePath)) {
-  fs.unlinkSync(readmePath)
-}
-
-fs.writeFileSync(readmePath, readmeContent)

package/perf/runPerfTest.ts

@@ -1,18 +0,0 @@
-import process from 'node:process'
-
-import { runPerformanceTest } from './_internal.js'
-
-const fileName = process.argv.slice(2).filter((x) => x.trim() !== '--')[0]
-
-async function main() {
-  const { name, cases } = await import(
-    `./cases/${fileName}${fileName.endsWith('.ts') ? '' : '.ts'}`
-  )
-
-  runPerformanceTest({ name, cases }, () => process.exit(0))
-}
-
-main().catch((error) => {
-  console.error(error)
-  process.exit(1)
-})

package/perf/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "../tsconfig.base.json",
-  "include": [
-    "."
-  ]
-}