@typed/fx 0.0.9 → 0.0.12

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      |
+-------------------------------------------------------
+

package/perf/runFullSuite.ts

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

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

@@ -2,6 +2,6 @@
   "$schema": "https://json.schemastore.org/tsconfig",
   "extends": "../tsconfig.base.json",
   "include": [
-    "./*.ts"
+    "."
   ]
 }

package/src/Fx.ts

@@ -1,18 +1,43 @@
+import { Cause } from '@effect/core/io/Cause'
 import * as Effect from '@effect/core/io/Effect'
+import { Scope } from '@effect/core/io/Scope'
 
-import { Sink } from './Sink.js'
-
-export interface Fx<R, E, A, E1 = never> {
-  readonly run: <R2, E2, B>(sink: Sink<E, A, R2, E2, B>) => Effect.Effect<R | R2, E1 | E2, B>
+export interface Fx<R, E, A> {
+  run<R2>(emitter: Emitter<R2, E, A>): Effect.Effect<R | R2 | Scope, never, unknown>
 }
 
-export function Fx<R, E, A, E1 = never>(run: Fx<R, E, A, E1>['run']): Fx<R, E, A, E1> {
-  return { run }
+export function Fx<R, E, A>(run: Fx<R, E, A>['run']): Fx<R, E, A> {
+  return {
+    run,
+  }
 }
 
 export namespace Fx {
-  export type ResourcesOf<T> = T extends Fx<infer R, any, any, any> ? R : never
-  export type ErrorsOf<T> = T extends Fx<any, infer E, any, any> ? E : never
-  export type OutputOf<T> = T extends Fx<any, any, infer A, any> ? A : never
-  export type ReturnErrorsOf<T> = T extends Fx<any, any, any, infer E1> ? E1 : never
+  export type ResourcesOf<T> = T extends Fx<infer R, any, any> ? R : never
+  export type ErrorsOf<T> = T extends Fx<any, infer E, any> ? E : never
+  export type OutputOf<T> = T extends Fx<any, any, infer A> ? A : never
+}
+
+export interface Emitter<R, E, A> {
+  readonly emit: (a: A) => Effect.Effect<R, never, unknown>
+  readonly failCause: (e: Cause<E>) => Effect.Effect<R, never, unknown>
+  readonly end: Effect.Effect<R, never, unknown>
+}
+
+export function Emitter<R, E, A>(
+  emit: Emitter<R, E, A>['emit'],
+  failCause: Emitter<R, E, A>['failCause'],
+  end: Emitter<R, E, A>['end'],
+): Emitter<R, E, A> {
+  return {
+    emit,
+    failCause,
+    end,
+  }
+}
+
+export namespace Emitter {
+  export type ResourcesOf<T> = T extends Emitter<infer R, any, any> ? R : never
+  export type ErrorsOf<T> = T extends Emitter<any, infer E, any> ? E : never
+  export type OutputOf<T> = T extends Emitter<any, any, infer A> ? A : never
 }

package/src/Subject.ts

@@ -0,0 +1,46 @@
+import * as Effect from '@effect/core/io/Effect'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+import { pipe } from 'node_modules/@fp-ts/data/Function.js'
+import { LazyArg } from 'node_modules/@tsplus/stdlib/data/Function.js'
+
+import { Emitter, Fx } from './Fx.js'
+import { never } from './fromEffect.js'
+import { Hold } from './hold.js'
+import { Multicast } from './multicast.js'
+
+export interface Subject<E, A> extends Emitter<never, E, A>, Fx<never, E, A> {}
+
+export namespace Subject {
+  export const unsafeMake = <E, A>(): Subject<E, A> => new Multicast<never, E, A>(never)
+}
+
+export interface HoldSubject<E, A> extends Subject<E, A> {
+  readonly get: Effect.Effect<never, never, Maybe.Maybe<A>>
+}
+
+export namespace HoldSubject {
+  export const unsafeMake = <E, A>(): HoldSubject<E, A> => new Hold<never, E, A>(never)
+}
+
+export interface BehaviorSubject<E, A> extends Subject<E, A> {
+  readonly get: Effect.Effect<never, never, A>
+}
+
+export namespace BehaviorSubject {
+  export const unsafeMake = <E, A>(initial: LazyArg<A>): BehaviorSubject<E, A> => {
+    const hold = new Hold<never, E, A>(never)
+
+    // We're mutating a protected variable here to ensure an initial value is held.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    hold._value = Maybe.some(initial())
+
+    return {
+      emit: hold.emit.bind(hold),
+      failCause: hold.failCause.bind(hold),
+      end: hold.end,
+      run: hold.run.bind(hold),
+      get: pipe(hold.get, Effect.map(Maybe.getOrElse(initial))),
+    }
+  }
+}

package/src/_internal.ts

@@ -1,129 +1,74 @@
+import {
+  CountdownLatch,
+  CountdownLatchInternal,
+} from '@effect/core/concurrent/CountdownLatch/definition'
+import * as Cause from '@effect/core/io/Cause'
 import * as Deferred from '@effect/core/io/Deferred'
 import * as Effect from '@effect/core/io/Effect'
-import { Exit } from '@effect/core/io/Exit'
-import * as Fiber from '@effect/core/io/Fiber'
 import * as Ref from '@effect/core/io/Ref'
-import * as Schedule from '@effect/core/io/Schedule'
 import { pipe } from '@fp-ts/data/Function'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { isSome } from '@tsplus/stdlib/data/Maybe'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
-export const asap = Schedule.delayed(() => Duration.millis(0))(Schedule.once)
-
-export function refCountDeferred<E, A>(initialEnded = false, initialCount = 0) {
-  return Effect.gen(function* ($) {
-    const ended = yield* $(Ref.makeRef<boolean>(() => initialEnded))
-    const ref = yield* $(Ref.makeSynchronized(() => initialCount))
-    const deferred = yield* $(Deferred.make<E, A>())
-    const increment = ref.update((a) => a + 1)
-    const decrement = ref.update((a) => Math.max(0, a - 1))
-    const refCount = ref.get
+export const EARLY_EXIT_FAILURE = Symbol('EarlyExitFailure')
+export interface EarlyExitFailure {
+  readonly sym: typeof EARLY_EXIT_FAILURE
+}
+export const EarlyExitFailure: EarlyExitFailure = { sym: EARLY_EXIT_FAILURE }
 
-    return {
-      await: deferred.await,
-      endIfComplete: <R>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, never, void> =>
-        Effect.gen(function* ($) {
-          if ((yield* $(ended.get)) && (yield* $(refCount)) === 0) {
-            yield* $(pipe(effect, Effect.intoDeferred(deferred)))
-          }
-        }),
-      error: <R>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, never, void> =>
-        Effect.gen(function* ($) {
-          yield* $(ended.set(true))
-          yield* $(pipe(effect, Effect.intoDeferred(deferred)))
-        }),
-      increment,
-      decrement,
-      refCount,
-      ended: ended.get,
-      end: ended.set(true),
-    }
-  })
+export function isEarlyExitFailure(u: unknown): u is EarlyExitFailure {
+  return typeof u === 'object' && u !== null && (u as any).sym === EARLY_EXIT_FAILURE
 }
 
-export function deferredCallback<E, A, R2, E2>(
-  f: (cb: (exit: Exit<E, A>) => Effect.Effect<never, never, never>) => Effect.Effect<R2, E2, A>,
-): Effect.Effect<R2, E | E2, A> {
-  return Effect.scoped(
-    Effect.gen(function* ($) {
-      const deferred = yield* $(Deferred.make<E, A>())
-      const fiber = yield* $(
-        Effect.forkScoped(
-          f((exit) => {
-            deferred.unsafeDone(Effect.done(exit))
+export const exitEarly = Effect.die(EarlyExitFailure)
 
-            return Effect.never
-          }),
-        ),
-      )
+export const onEarlyExitFailure =
+  <R2, E2, B>(handler: Effect.Effect<R2, E2, B>) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<R | R2, E | E2, A | B> =>
+    pipe(
+      effect,
+      Effect.foldCauseEffect<E, A, R | R2, E | E2, A | B, R | R2, E | E2, A | B>(
+        (e) =>
+          pipe(
+            e,
+            Cause.dieMaybe,
+            Maybe.fold(
+              () => Effect.failCause(e),
+              (d) => (isEarlyExitFailure(d) ? handler : Effect.failCause(e)),
+            ),
+          ),
+        Effect.succeed,
+      ),
+    )
 
-      yield* $(Effect.addFinalizer(Fiber.interrupt(fiber)))
+/**
+ * A small wrapper around CountdownLatch which enables incrementing
+ * the latch count dynamically
+ */
+export type DynamicCountdownLatch = {
+  readonly increment: Effect.Effect<never, never, void>
+  readonly latch: CountdownLatch
+}
 
-      return yield* $(Effect.race(deferred.await)(Fiber.join(fiber)))
-    }),
+export function makeDynamicCountdownLatch(
+  initialCount: number,
+): Effect.Effect<never, never, DynamicCountdownLatch> {
+  return pipe(
+    Ref.makeRef<number>(() => initialCount),
+    Effect.zipWith(Deferred.make<never, void>(), (ref, deferred) => ({
+      increment: ref.update((x) => x + 1),
+      latch: new CountdownLatchInternal(ref, deferred),
+    })),
   )
 }
 
-type RefOutput<T> = T extends Ref.Ref<infer R> ? R : never
-
-export function tupleRef<Refs extends ReadonlyArray<Ref.Ref<any>>>(
-  refs: readonly [...Refs],
-): Ref.Ref<{ readonly [K in keyof Refs]: RefOutput<Refs[K]> }> {
-  const get = Effect.gen(function* ($) {
-    const result: any[] = []
-
-    for (const ref of refs) {
-      result.push(yield* $(ref.get))
-    }
-
-    return result as unknown as { readonly [K in keyof Refs]: RefOutput<Refs[K]> }
-  })
-
-  const set = (a: { readonly [K in keyof Refs]: RefOutput<Refs[K]> }) =>
-    Effect.gen(function* ($) {
-      let i = 0
-      for (const ref of refs) {
-        yield* $(ref.set(a[i++]))
-      }
-    })
-
-  const tupledRef = {
-    [Ref.RefSym]: Ref.RefSym,
-    get,
-    set,
-    update: (f) =>
-      pipe(
-        get,
-        Effect.flatMap((a) => set(f(a))),
-      ),
-    updateSome: (f) =>
-      pipe(
-        get,
-        Effect.map(f),
-        Effect.flatMap((a) => (isSome(a) ? set(a.value) : Effect.unit)),
-      ),
-    modify: (f) =>
-      pipe(
-        get,
-        Effect.map(f),
-        Effect.flatMap(([b, a]) => pipe(a, set, Effect.as(b))),
-      ),
-    modifySome: (fallback, f) =>
-      pipe(
-        get,
-        Effect.map(f),
-        Effect.flatMap((maybe) =>
-          isSome(maybe)
-            ? pipe(maybe.value[1], set, Effect.as(maybe.value[0]))
-            : Effect.succeed(fallback),
-        ),
-      ),
-    getAndSet: (a) => pipe(get, Effect.zipLeft(set(a))),
-    getAndUpdate: (f) => pipe(get, Effect.zipLeft(tupledRef.update(f))),
-    getAndUpdateSome: (f) => pipe(get, Effect.zipLeft(tupledRef.updateSome(f))),
-    updateAndGet: (f) => pipe(tupledRef.update(f), Effect.zipRight(get)),
-    updateSomeAndGet: (f) => pipe(tupledRef.updateSome(f), Effect.zipRight(get)),
-  } as Ref.Ref<{ readonly [K in keyof Refs]: RefOutput<Refs[K]> }>
-
-  return tupledRef
+export function withDynamicCountdownLatch<R, E, A, R2, E2, B>(
+  initialCount: number,
+  f: (latch: DynamicCountdownLatch) => Effect.Effect<R, E, A>,
+  onEnd: Effect.Effect<R2, E2, B>,
+): Effect.Effect<R | R2, E | E2, B> {
+  return pipe(
+    makeDynamicCountdownLatch(initialCount),
+    Effect.tap(f),
+    Effect.flatMap(({ latch }) => pipe(latch.await, Effect.zipRight(onEnd))),
+  )
 }

package/src/combine.test.ts

@@ -1,34 +1,33 @@
 import { deepStrictEqual } from 'assert'
 
-import { unsafeRunPromise } from '@effect/core/io/Effect'
+import * as Effect from '@effect/core/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 import * as Duration from '@tsplus/stdlib/data/Duration'
 
-import { combine } from './combine.js'
-import { delay } from './delay.js'
-import { flatMap } from './flatMap.js'
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
   describe('combine', () => {
     it('combines 2 fx together', async () => {
       const values = [1, 2, 3]
       const test = pipe(
-        from(values),
-        flatMap((a) =>
-          pipe(from([a, a + 1]), combine(pipe(from([a * a, a ** a]), delay(Duration.millis(10))))),
+        Fx.fromIterable(values),
+        Fx.flatMap((a) =>
+          pipe(
+            Fx.fromIterable([a, a + 1]),
+            Fx.combine(pipe(Fx.fromIterable([a * a, a ** a]), Fx.delay(Duration.millis(10)))),
+          ),
         ),
       )
-      const events = await pipe(test, collectAll, unsafeRunPromise)
+      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
 
       deepStrictEqual(events, [
-        [values[0] + 1, values[0] * values[0]],
-        [values[1] + 1, values[1] * values[1]],
-        [values[2] + 1, values[2] * values[2]],
-        [values[0] + 1, values[0] ** values[0]],
-        [values[1] + 1, values[1] ** values[1]],
-        [values[2] + 1, values[2] ** values[2]],
+        [1 + 1, 1 * 1],
+        [2 + 1, 2 * 2],
+        [3 + 1, 3 * 3],
+        [1 + 1, 1 ** 1],
+        [2 + 1, 2 ** 2],
+        [3 + 1, 3 ** 3],
       ])
     })
   })