@typed/fx 1.19.0 → 1.20.0

package/src/internal/share.ts

@@ -1,19 +1,19 @@
+import { ExecutionStrategy, type Scope } from "effect"
 import * as Effect from "effect/Effect"
 import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import type { Fx } from "../Fx.js"
-import type { Subject } from "../Subject.js"
-import { makeHoldSubject, makeReplaySubject, makeSubject } from "./core-subject.js"
-import { withScopedFork } from "./core.js"
-import { ToFx } from "./fx-primitive.js"
-import { run } from "./run.js"
+import type { Sink } from "../Sink.js"
+import * as Subject from "../Subject.js"
+import { withScopedFork } from "./helpers.js"
+import { FxBase } from "./protos.js"
 
 export function share<R, E, A, R2>(
   fx: Fx<R, E, A>,
-  subject: Subject<R2, E, A>
-): Fx<R | R2, E, A> {
+  subject: Subject.Subject<R2, E, A>
+): Fx<R | R2 | Scope.Scope, E, A> {
   return new Share(fx, subject)
 }
 
@@ -29,32 +29,34 @@ class RefCounter {
   }
 }
 
-export class Share<R, E, A, R2> extends ToFx<R | R2, E, A> {
+export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
   _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<never, unknown>>> = MutableRef.make(Option.none())
   _RefCount = new RefCounter()
 
   constructor(
     readonly i0: Fx<R, E, A>,
-    readonly i1: Subject<R2, E, A>
+    readonly i1: Subject.Subject<R2, E, A>
   ) {
-    super(i0, i1)
+    super()
   }
 
-  toFx(): Fx<R | R2, E, A> {
-    return withScopedFork(({ fork, sink }) =>
-      Effect.flatMap(
-        fork(
-          Effect.onExit(run(this.i1, sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.unit)
+  run<R3>(sink: Sink<R3, E, A>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+    return withScopedFork(
+      (fork) =>
+        Effect.flatMap(
+          fork(
+            Effect.onExit(this.i1.run(sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.unit)
+          ),
+          () => this.initialize()
         ),
-        () => this.initialize()
-      )
+      ExecutionStrategy.sequential
     )
   }
 
   private initialize(): Effect.Effect<R | R2, never, unknown> {
     return Effect.suspend(() => {
       if (this._RefCount.increment() === 1) {
-        return run(this.i0, this.i1).pipe(
+        return this.i0.run(this.i1).pipe(
           Effect.onExit(() => Effect.sync(() => MutableRef.set(this._FxFiber, Option.none()))),
           Effect.interruptible,
           Effect.forkDaemon,
@@ -84,14 +86,14 @@ export class Share<R, E, A, R2> extends ToFx<R | R2, E, A> {
 
 export function multicast<R, E, A>(
   fx: Fx<R, E, A>
-): Fx<R, E, A> {
-  return new Share(fx, makeSubject<E, A>())
+): Fx<R | Scope.Scope, E, A> {
+  return new Share(fx, Subject.unsafeMake<E, A>(0))
 }
 
 export function hold<R, E, A>(
   fx: Fx<R, E, A>
-): Fx<R, E, A> {
-  return new Share(fx, makeHoldSubject<E, A>())
+): Fx<R | Scope.Scope, E, A> {
+  return new Share(fx, Subject.unsafeMake<E, A>(1))
 }
 
 export const replay: {
@@ -100,6 +102,6 @@ export const replay: {
 } = dual(2, function replay<R, E, A>(
   fx: Fx<R, E, A>,
   capacity: number
-): Fx<R, E, A> {
-  return new Share(fx, makeReplaySubject<E, A>(capacity))
+): Fx<R | Scope.Scope, E, A> {
+  return new Share(fx, Subject.unsafeMake<E, A>(capacity))
 })

package/src/internal/sync-operator.ts

@@ -1,6 +1,10 @@
+import * as ReadonlyArray from "effect/ReadonlyArray"
+
 import * as Effect from "effect/Effect"
+import { flow } from "effect/Function"
 import * as Option from "effect/Option"
-import { WithContext } from "../Sink.js"
+import * as Sink from "../Sink.js"
+import * as SyncProducer from "./sync-producer.js"
 
 // Sync operators are a subset of operators which can be safely fused together synchronously
 
@@ -41,13 +45,13 @@ type SyncOperatorFusionMap = {
 
 const SyncOperatorFusionMap: SyncOperatorFusionMap = {
   Map: {
-    Map: (op1, op2) => Map((a: any) => op2.f(op1.f(a))),
+    Map: (op1, op2) => Map(flow(op1.f, op2.f)),
     Filter: (op1, op2) =>
       FilterMap((a: any) => {
         const b = op1.f(a)
         return op2.f(b) ? Option.some(b) : Option.none()
       }),
-    FilterMap: (op1, op2) => FilterMap((a: any) => op2.f(op1.f(a)))
+    FilterMap: (op1, op2) => FilterMap(flow(op1.f, op2.f))
   },
   Filter: {
     Map: (op1, op2) => FilterMap((a: any) => op1.f(a) ? Option.some(op2.f(a)) : Option.none()),
@@ -71,41 +75,29 @@ export function matchSyncOperator<A>(operator: SyncOperator, matchers: {
   readonly Filter: (f: Filter<any>) => A
   readonly FilterMap: (f: FilterMap<any, any>) => A
 }): A {
-  switch (operator._tag) {
-    case "Map":
-      return matchers.Map(operator)
-    case "Filter":
-      return matchers.Filter(operator)
-    case "FilterMap":
-      return matchers.FilterMap(operator)
-  }
+  return matchers[operator._tag](operator as any)
 }
 
 export function compileSyncOperatorSink<R>(
   operator: SyncOperator,
-  sink: WithContext<R, any, any>
-): WithContext<R, any, any> {
+  sink: Sink.Sink<R, any, any>
+): Sink.Sink<R, any, any> {
   return matchSyncOperator(operator, {
-    Map: (op) => WithContext(sink.onFailure, (a) => sink.onSuccess(op.f(a))),
-    Filter: (op) => WithContext(sink.onFailure, (a) => op.f(a) ? sink.onSuccess(a) : Effect.unit),
-    FilterMap: (op) =>
-      WithContext(sink.onFailure, (a) =>
-        Option.match(op.f(a), {
-          onNone: () => Effect.unit,
-          onSome: sink.onSuccess
-        }))
+    Map: (op) => Sink.map(sink, op.f),
+    Filter: (op) => Sink.filter(sink, op.f),
+    FilterMap: (op) => Sink.filterMap(sink, op.f)
   })
 }
 
-export function compileSyncOperatorFailureSink<R>(
+export function compileCauseSyncOperatorSink<R>(
   operator: SyncOperator,
-  sink: WithContext<R, any, any>
-): WithContext<R, any, any> {
+  sink: Sink.Sink<R, any, any>
+): Sink.Sink<R, any, any> {
   return matchSyncOperator(operator, {
-    Map: (op) => WithContext((a) => sink.onFailure(op.f(a)), sink.onSuccess),
-    Filter: (op) => WithContext((a) => op.f(a) ? sink.onFailure(a) : Effect.unit, sink.onSuccess),
+    Map: (op) => Sink.make((a) => sink.onFailure(op.f(a)), sink.onSuccess),
+    Filter: (op) => Sink.make((a) => op.f(a) ? sink.onFailure(a) : Effect.unit, sink.onSuccess),
     FilterMap: (op) =>
-      WithContext((a) =>
+      Sink.make((a) =>
         Option.match(op.f(a), {
           onNone: () => Effect.unit,
           onSome: sink.onFailure
@@ -123,3 +115,52 @@ export function compileSyncReducer<A, B, C>(
     FilterMap: (op) => (b, i) => Option.map(op.f(i), (a) => f(b, a))
   })
 }
+
+export function applyArray<A, B>(array: ReadonlyArray<A>, operator: SyncOperator): ReadonlyArray<B> {
+  return matchSyncOperator(operator, {
+    Map: (op) => ReadonlyArray.map(array, op.f),
+    Filter: (op) => ReadonlyArray.filter(array, op.f),
+    FilterMap: (op) => ReadonlyArray.filterMap(array, op.f)
+  })
+}
+
+export function applyArrayReducer<A, B>(
+  array: Iterable<any>,
+  operator: SyncOperator,
+  seed: B,
+  f: (acc: B, a: A) => B
+): B {
+  return matchSyncOperator(operator, {
+    Map: (op) => ReadonlyArray.reduce(array, seed, (b, a) => f(b, op.f(a))),
+    Filter: (op) => ReadonlyArray.reduce(array, seed, (b, a) => op.f(a) ? f(b, a) : b),
+    FilterMap: (op) =>
+      ReadonlyArray.reduce(array, seed, (b, a) => {
+        const o = op.f(a)
+        if (Option.isSome(o)) return f(b, o.value)
+        else return b
+      })
+  })
+}
+
+export function runSyncReduce<A, B>(
+  producer: SyncProducer.SyncProducer<A>,
+  op: SyncOperator,
+  seed: B,
+  f: (acc: B, a: any) => B
+): B {
+  return SyncProducer.matchSyncProducer(producer, {
+    Success: (a) =>
+      matchSyncOperator(op, {
+        Map: (op) => f(seed, op.f(a)),
+        Filter: (op) => op.f(a) ? f(seed, a) : seed,
+        FilterMap: (op) =>
+          Option.match(op.f(a), {
+            onNone: () => seed,
+            onSome: (a) => f(seed, a)
+          })
+      }),
+    FromSync: (g) => f(seed, g()),
+    FromArray: (array) => applyArrayReducer(array, op, seed, f),
+    FromIterable: (iterable) => applyArrayReducer(iterable, op, seed, f)
+  })
+}

package/src/internal/sync-producer.ts

@@ -0,0 +1,146 @@
+import { Effect, Option, ReadonlyArray } from "effect"
+import type { Sink } from "../Sink.js"
+
+const DISCARD = { discard: true } as const
+
+export type SyncProducer<A> = Success<A> | FromSync<A> | FromArray<A> | FromIterable<A>
+
+export interface Success<A> {
+  readonly _tag: "Success"
+  readonly source: A
+}
+
+export const Success = <A>(value: A): Success<A> => ({ _tag: "Success", source: value })
+
+export interface FromSync<A> {
+  readonly _tag: "FromSync"
+  readonly source: () => A
+}
+
+export const FromSync = <A>(f: () => A): FromSync<A> => ({ _tag: "FromSync", source: f })
+
+export interface FromArray<A> {
+  readonly _tag: "FromArray"
+  readonly source: ReadonlyArray<A>
+}
+
+export const FromArray = <A>(array: ReadonlyArray<A>): FromArray<A> => ({ _tag: "FromArray", source: array })
+
+export interface FromIterable<A> {
+  readonly _tag: "FromIterable"
+  readonly source: Iterable<A>
+}
+
+export const FromIterable = <A>(iterable: Iterable<A>): FromIterable<A> => ({ _tag: "FromIterable", source: iterable })
+
+export const matchSyncProducer = <A, R>(
+  producer: SyncProducer<A>,
+  matchers: {
+    readonly Success: (a: A) => R
+    readonly FromSync: (a: () => A) => R
+    readonly FromArray: (a: ReadonlyArray<A>) => R
+    readonly FromIterable: (a: Iterable<A>) => R
+  }
+): R => {
+  return matchers[producer._tag](producer.source as any)
+}
+
+export function runSink<A, R, E>(
+  producer: SyncProducer<A>,
+  sink: Sink<R, E, A>
+): Effect.Effect<R, never, unknown> {
+  return matchSyncProducer(producer, {
+    Success: (a) => sink.onSuccess(a),
+    FromSync: (a) => Effect.suspend(() => sink.onSuccess(a())),
+    FromArray: (a) => arrayToSink(a, sink),
+    FromIterable: (a) => iterableToSink(a, sink)
+  })
+}
+
+export function runReduce<A, B>(
+  producer: SyncProducer<A>,
+  initial: B,
+  f: (b: B, a: any) => B
+): Effect.Effect<never, never, B> {
+  return matchSyncProducer(producer, {
+    Success: (a) => syncOnce(() => f(initial, a)),
+    FromSync: (a) => syncOnce(() => f(initial, a())),
+    FromArray: (a) => syncOnce(() => ReadonlyArray.reduce(a, initial, f)),
+    FromIterable: (a) => syncOnce(() => ReadonlyArray.reduce(a, initial, f))
+  })
+}
+
+export function runReduceEffect<A, R2, E2, B>(
+  producer: SyncProducer<A>,
+  initial: B,
+  f: (b: B, a: any) => Effect.Effect<R2, E2, B>
+): Effect.Effect<R2, E2, B> {
+  return matchSyncProducer(producer, {
+    Success: (a) => effectOnce(() => f(initial, a)),
+    FromSync: (a) => Effect.suspend(() => f(initial, a())),
+    FromArray: (a) => Effect.reduce(a, initial, f),
+    FromIterable: (a) => Effect.reduce(a, initial, f)
+  })
+}
+
+function arrayToSink<A, R2>(array: ReadonlyArray<A>, sink: Sink<R2, never, A>): Effect.Effect<R2, never, unknown> {
+  if (array.length === 0) return Effect.unit
+  else if (array.length === 1) return sink.onSuccess(array[0])
+  else {
+    const [first, ...rest] = array
+    let effect = sink.onSuccess(first)
+    for (const item of rest) {
+      effect = Effect.zipRight(effect, sink.onSuccess(item))
+    }
+    return effect
+  }
+}
+
+function iterableToSink<A, R2>(array: Iterable<A>, sink: Sink<R2, never, A>): Effect.Effect<R2, never, unknown> {
+  let effect: Effect.Effect<R2, never, any> = Effect.unit
+
+  for (const item of array) {
+    effect = Effect.zipRight(effect, sink.onSuccess(item))
+  }
+
+  return effect
+}
+
+export const syncOnce = <A>(f: () => A): Effect.Effect<never, never, A> => {
+  let memoized: Option.Option<A> = Option.none()
+  const get = () => {
+    if (Option.isSome(memoized)) {
+      return memoized.value
+    } else {
+      const a = f()
+      memoized = Option.some(a)
+      return a
+    }
+  }
+
+  return Effect.sync(get)
+}
+
+export const effectOnce = <R, E, A>(f: () => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> => {
+  let memoized: Option.Option<A> = Option.none()
+
+  return Effect.suspend(() => {
+    if (Option.isSome(memoized)) {
+      return Effect.succeed(memoized.value)
+    } else {
+      return Effect.tap(f(), (a) => Effect.sync(() => memoized = Option.some(a)))
+    }
+  })
+}
+
+export function runEffect<A, R2, E2, B>(
+  producer: SyncProducer<A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>
+): Effect.Effect<R2, E2, void> {
+  return matchSyncProducer(producer, {
+    Success: (a): Effect.Effect<R2, E2, void> => f(a),
+    FromSync: (a) => Effect.suspend(() => f(a())),
+    FromArray: (a) => Effect.forEach(a, f, DISCARD),
+    FromIterable: (a) => Effect.forEach(a, f, DISCARD)
+  })
+}

package/src/internal/withKey.ts

@@ -1,92 +1,82 @@
 import * as Effect from "effect/Effect"
-import { equals } from "effect/Equal"
-import * as Fiber from "effect/Fiber"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Option from "effect/Option"
-import * as Scope from "effect/Scope"
-import type { Fx, FxInput } from "../Fx.js"
+import type * as Scope from "effect/Scope"
+
+import type { Fx, WithKeyOptions } from "../Fx.js"
 import * as RefSubject from "../RefSubject.js"
 import * as Sink from "../Sink.js"
-import * as core from "./core.js"
-import { adjustTime } from "./helpers.js"
-import { run } from "./run.js"
+import { withSwitchFork } from "./helpers.js"
+import { FxBase } from "./protos.js"
 
-export function withKey<R, E, A, B, R2, E2, C>(
+export function withKey<R, E, A, B extends PropertyKey, R2, E2, C>(
   fx: Fx<R, E, A>,
-  getKey: (a: A) => B,
-  onValue: (ref: RefSubject.RefSubject<never, never, A>, key: B) => FxInput<R2, E2, C>
-): Fx<R | R2, E | E2, C> {
-  return core.withScopedFork(({ fork, scope, sink }) =>
-    Effect.gen(function*(_) {
-      let current: Option.Option<
-        [B, { value: A }, RefSubject.RefSubject<never, never, A>, Fiber.Fiber<never, unknown>]
-      > = Option.none()
+  options: WithKeyOptions<A, B, R2, E2, C>
+): Fx<R | R2 | Scope.Scope, E | E2, C> {
+  return new WithKey(fx, options)
+}
+
+class WithKey<R, E, A, B extends PropertyKey, R2, E2, C> extends FxBase<R | R2 | Scope.Scope, E | E2, C> {
+  constructor(readonly fx: Fx<R, E, A>, readonly options: WithKeyOptions<A, B, R2, E2, C>) {
+    super()
+  }
 
-      const lock = (yield* _(Effect.makeSemaphore(1))).withPermits(1)
+  run<R3>(sink: Sink.Sink<R3, E | E2, C>) {
+    return runWithKey(this.fx, this.options, sink)
+  }
+}
 
-      const make = (a: A) =>
-        Effect.uninterruptibleMask((restore) =>
-          Effect.gen(function*(_) {
-            const key = getKey(a)
-            // We use a simple mutable object to track the current value
-            // of the state coming from the "outside", such that any internal
-            // usage of RefSubject.delete will reset to the latest value emitted
-            // from here.
-            const currentValue = { value: a }
-            const ref = yield* _(
-              RefSubject.fromEffect(Effect.sync(() => currentValue.value)),
-              Effect.provideService(Scope.Scope, scope)
-            )
-            const fiber = yield* _(
-              run(core.from(onValue(ref, key)), sink),
-              restore,
-              fork
-            )
+function runWithKey<R, E, A, B extends PropertyKey, R2, E2, C, R3>(
+  fx: Fx<R, E, A>,
+  options: WithKeyOptions<A, B, R2, E2, C>,
+  sink: Sink.Sink<R3, E | E2, C>
+) {
+  return withSwitchFork((fork) => {
+    let previous: Option.Option<WithKeyState<A, B>> = Option.none()
 
-            // Save our state
-            current = Option.some([key, currentValue, ref, fiber])
+    const run = fx.run(Sink.make(
+      (cause) => sink.onFailure(cause),
+      (value) =>
+        Effect.gen(function*(_) {
+          const key = options.getKey(value)
 
-            // Allow our Fibers to start
-            yield* _(adjustTime(1))
-          })
-        )
+          // We don't need to do anything if the key is the same as the previous one
+          if (Option.isSome(previous)) {
+            const prev = previous.value
 
-      yield* _(run(
-        fx,
-        Sink.WithContext(
-          sink.onFailure,
-          (a) =>
-            lock(Effect.gen(function*(_) {
-              if (Option.isNone(current)) {
-                yield _(make(a))
-              } else {
-                const [key, currentValue, ref, fiber] = current.value
+            // If the key is the same, we just need to update the value
+            if (prev.key === key) {
+              prev.value = value
+              yield* _(RefSubject.set(prev.ref, value))
+              return
+            } else {
+              // Otherwise, we need to remove the previous value
+              yield* _(prev.ref.interrupt)
+            }
+          }
 
-                if (equals(key, getKey(a))) {
-                  // Key didn't change, so we just set an updated value.
+          const ref = yield* _(RefSubject.fromEffect(Effect.sync(() => state.value)))
 
-                  currentValue.value = a
-                  yield* _(ref.set(a))
-                } else {
-                  // Cleanup previous resources
-                  yield* _(Fiber.interrupt(fiber))
+          // Create a new state
+          const state: WithKeyState<A, B> = {
+            value,
+            key,
+            ref
+          }
 
-                  // Create a new RefSubject
-                  yield* _(make(a))
-                }
-              }
-            }))
-        )
-      ))
+          previous = Option.some(state)
 
-      if (Option.isSome(current)) {
-        const [, , ref, fiber] = current.value
+          // Create a new listener
+          yield* _(fork(options.onValue(state.ref, state.key).run(sink)))
+        })
+    ))
 
-        // Signal there will be no more input events
-        yield* _(fork(ref.interrupt))
+    return Effect.flatMap(run, () => Option.isSome(previous) ? previous.value.ref.interrupt : Effect.unit)
+  }, ExecutionStrategy.sequential)
+}
 
-        // Wait for the last Fiber to complete
-        yield* _(Effect.fromFiber(fiber))
-      }
-    })
-  )
+type WithKeyState<A, B> = {
+  value: A
+  key: B
+  ref: RefSubject.RefSubject<never, never, A>
 }

package/Computed/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Computed.js",
-  "module": "../dist/esm/Computed.js",
-  "types": "../dist/dts/Computed.d.ts",
-  "sideEffects": []
-}

package/Filtered/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Filtered.js",
-  "module": "../dist/esm/Filtered.js",
-  "types": "../dist/dts/Filtered.d.ts",
-  "sideEffects": []
-}

package/Model/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Model.js",
-  "module": "../dist/esm/Model.js",
-  "types": "../dist/dts/Model.d.ts",
-  "sideEffects": []
-}

package/RefAsyncData/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/RefAsyncData.js",
-  "module": "../dist/esm/RefAsyncData.js",
-  "types": "../dist/dts/RefAsyncData.d.ts",
-  "sideEffects": []
-}

package/RefAsyncDataArray/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/RefAsyncDataArray.js",
-  "module": "../dist/esm/RefAsyncDataArray.js",
-  "types": "../dist/dts/RefAsyncDataArray.d.ts",
-  "sideEffects": []
-}

package/RefBoolean/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/RefBoolean.js",
-  "module": "../dist/esm/RefBoolean.js",
-  "types": "../dist/dts/RefBoolean.d.ts",
-  "sideEffects": []
-}

package/RefNumber/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/RefNumber.js",
-  "module": "../dist/esm/RefNumber.js",
-  "types": "../dist/dts/RefNumber.d.ts",
-  "sideEffects": []
-}