@typed/fx 1.18.4 → 1.20.0

package/src/Stream.ts

@@ -12,7 +12,7 @@ import * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Fx from "./Fx.js"
-import { Sink } from "./Sink.js"
+import * as Sink from "./Sink.js"
 
 /**
  * Convert an Fx to a Stream
@@ -21,9 +21,8 @@ import { Sink } from "./Sink.js"
  */
 export function toStream<R, E, A>(fx: Fx.Fx<R, E, A>): Stream.Stream<R, E, A> {
   return Stream.asyncScoped<R | Scope.Scope, E, A>((emit) =>
-    Fx.run(
-      fx,
-      Sink(
+    fx.run(
+      Sink.make(
         (cause) => Effect.promise(() => emit(Effect.failCause(Cause.map(cause, Option.some)))),
         (a) => Effect.promise(() => emit(Effect.succeed(Chunk.of(a))))
       )
@@ -54,20 +53,20 @@ export const toStreamQueued: {
   fx: Fx.Fx<R, E, A>,
   make: Effect.Effect<R2, E2, Queue.Queue<Exit.Exit<Option.Option<E>, A>>>
 ): Stream.Stream<R | R2, E | E2, A> {
-  return Stream.flattenExitOption(Stream.unwrapScoped(Effect.gen(function*(_) {
-    const queue = yield* _(make)
-
-    yield* _(
-      fx,
-      Fx.mapError(Option.some),
-      Fx.exit,
-      Fx.toEnqueue(queue),
-      Effect.ensuring(queue.offer(Exit.fail(Option.none()))),
-      Effect.forkScoped
-    )
-
-    return Stream.fromQueue(queue)
-  })))
+  return make.pipe(
+    Effect.tap((queue) =>
+      fx.pipe(
+        Fx.mapError(Option.some),
+        Fx.exit,
+        Fx.toEnqueue(queue),
+        Effect.ensuring(queue.offer(Exit.fail(Option.none()))),
+        Effect.forkScoped
+      )
+    ),
+    Effect.map((queue) => Stream.fromQueue(queue)),
+    Stream.unwrapScoped,
+    Stream.flattenExitOption
+  )
 })
 
 /**
@@ -118,11 +117,24 @@ export const toStreamBounded: {
   }
 )
 
+/**
+ * Convert a Stream to an Fx
+ * @since 1.18.0
+ * @category conversions
+ */
+export function fromStream<R, E, A>(
+  stream: Stream.Stream<R, E, A>
+): Fx.Fx<R, E, A> {
+  return Fx.make<R, E, A>((sink) => Effect.catchAllCause(Stream.runForEach(stream, sink.onSuccess), sink.onFailure))
+}
+
 /**
  * Convert a Stream to an Fx of chunks
  * @since 1.18.0
  * @category conversions
  */
-export function chunked<R, E, A>(stream: Stream.Stream<R, E, A>): Fx.Fx<R, E, Chunk.Chunk<A>> {
-  return Fx.fromSink((sink) => Effect.catchAllCause(Stream.runForEachChunk(stream, sink.onSuccess), sink.onFailure))
+export function fromStreamChunked<R, E, A>(stream: Stream.Stream<R, E, A>): Fx.Fx<R, E, Chunk.Chunk<A>> {
+  return Fx.make<R, E, Chunk.Chunk<A>>((sink) =>
+    Effect.catchAllCause(Stream.runForEachChunk(stream, sink.onSuccess), sink.onFailure)
+  )
 }

package/src/Subject.ts

@@ -1,143 +1,286 @@
 /**
- * Subjects are the basis for sharing events between multiple consumers in an effecient manner
- * and for event-bus-like functionality.
- * @since 1.18.0
+ * Subject is an Fx type which can also be imperatively pushed into.
+ * @since 1.20.0
  */
 
 import * as C from "@typed/context"
-import type { Cause } from "effect/Cause"
+import type { Cause, Layer, Pipeable } from "effect"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import type * as Layer from "effect/Layer"
-import { type Fx, ToFx } from "./Fx.js"
-import * as internal from "./internal/core-subject.js"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
+import { dual, identity } from "effect/Function"
+import * as MutableRef from "effect/MutableRef"
+import * as Option from "effect/Option"
+import { hasProperty } from "effect/Predicate"
+import * as Scope from "effect/Scope"
+import { type Fx } from "./Fx.js"
 import { provide } from "./internal/core.js"
-import { fromFxEffect } from "./internal/fx.js"
-import type { WithContext } from "./Sink.js"
+import { awaitScopeClose, RingBuffer, withScope } from "./internal/helpers.js"
+import { FxBase } from "./internal/protos.js"
+import type { Push } from "./Push.js"
+import type { Sink } from "./Sink.js"
+import { TypeId } from "./TypeId.js"
 
 /**
- * A Subject is an Fx which is also a Sink, and can be used to
- * broadcast events to many consumers.
- * @since 1.18.0
- * @category models
+ * Subject is an Fx type which can also be imperatively pushed into.
+ * @since 1.20.0
  */
-export interface Subject<R, E, A> extends Fx<R, E, A>, WithContext<R, E, A> {
+export interface Subject<R, E, A>
+  extends Push<R, E, A, R | Scope.Scope, E, A>, Fx<R | Scope.Scope, E, A>, Pipeable.Pipeable
+{
   readonly subscriberCount: Effect.Effect<R, never, number>
   readonly interrupt: Effect.Effect<R, never, void>
 }
 
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export namespace Subject {
   /**
-   * A Contextual wrapper around a Subject
-   * @since 1.18.0
-   * @category models
+   * @since 1.20.0
    */
   export interface Tagged<I, E, A> extends Subject<I, E, A> {
     readonly tag: C.Tagged<I, Subject<never, E, A>>
 
-    readonly interrupt: Effect.Effect<I, never, void>
+    readonly make: (replay?: number) => Layer.Layer<never, never, I>
+    readonly provide: Provide<I>
+  }
+
+  /**
+   * @since 1.20.0
+   */
+  export type Provide<I> = <
+    const Args extends
+      | readonly [
+        | Fx<any, any, any>
+        | Effect.Effect<any, any, any>,
+        number?
+      ]
+      | readonly [
+        number
+      ]
+  >(
+    ...args: Args
+  ) => Args extends readonly [infer _ extends number] ? <T extends Fx<any, any, any> | Effect.Effect<any, any, any>>(
+      fxOrEffect: T
+    ) => [T] extends [Fx<infer R2, infer E2, infer B>] ? Fx<Exclude<R2, I>, E2, B>
+      : [T] extends [Effect.Effect<infer R2, infer E2, infer B>] ? Effect.Effect<Exclude<R2, I>, E2, B>
+      : never
+    : Args extends readonly [Fx<infer R2, infer E2, infer B>] ? Fx<Exclude<R2, I>, E2, B>
+    : Args extends readonly [Effect.Effect<infer R2, infer E2, infer B>] ? Effect.Effect<Exclude<R2, I>, E2, B>
+    : never
+}
 
-    readonly provide: (
-      replay?: number
-    ) => <R2, E2, B>(effect: Effect.Effect<R2, E2, B>) => Effect.Effect<Exclude<R2, I>, E2, B>
+const DISCARD = { discard: true } as const
 
-    readonly provideFx: (
-      replay?: number
-    ) => <R2, E2, B>(fx: Fx<R2, E2, B>) => Fx<Exclude<R2, I>, E2, B>
+/**
+ * @internal
+ */
+export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subject<never, E, A> {
+  protected sinks: Set<readonly [Sink<any, E, A>, Context.Context<any>]> = new Set()
+  protected scopes: Set<Scope.CloseableScope> = new Set()
 
-    readonly make: (replay?: number) => Layer.Layer<never, never, I>
+  constructor() {
+    super()
+    this.onFailure = this.onFailure.bind(this)
+    this.onSuccess = this.onSuccess.bind(this)
+  }
+
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+    return this.addSink(sink, awaitScopeClose)
+  }
+
+  // Emit a failure to all sinks
+  onFailure(cause: Cause.Cause<E>) {
+    return this.onCause(cause)
+  }
+
+  // Emit an event to all sinks
+  onSuccess(a: A) {
+    return this.onEvent(a)
+  }
+
+  readonly interrupt = Effect.fiberIdWith((id) =>
+    Effect.forEach(this.scopes, (scope) => Scope.close(scope, Exit.interrupt(id)), DISCARD)
+  )
+
+  protected addSink<R, R2, B>(
+    sink: Sink<R, E, A>,
+    f: (scope: Scope.Scope) => Effect.Effect<R2, never, B>
+  ): Effect.Effect<R2 | Scope.Scope, never, B> {
+    return withScope(
+      (innerScope) =>
+        Effect.contextWithEffect((ctx) => {
+          const entry = [sink, Context.add(ctx, Scope.Scope, innerScope)] as const
+          const add = Effect.sync(() => {
+            this.sinks.add(entry)
+            this.scopes.add(innerScope)
+          })
+          const remove = Effect.sync(() => {
+            this.sinks.delete(entry)
+            this.scopes.delete(innerScope)
+          })
+
+          return Effect.zipRight(
+            Scope.addFinalizer(innerScope, remove),
+            Effect.zipRight(add, f(innerScope))
+          )
+        }),
+      ExecutionStrategy.sequential
+    )
+  }
+
+  readonly subscriberCount: Effect.Effect<never, never, number> = Effect.sync(() => this.sinks.size)
+
+  protected onEvent(a: A) {
+    if (this.sinks.size === 0) return Effect.unit
+    else {
+      return Effect.forEach(this.sinks, ([sink, ctx]) => Effect.provide(sink.onSuccess(a), ctx), DISCARD)
+    }
+  }
+
+  protected onCause(cause: Cause.Cause<E>) {
+    return Effect.forEach(
+      this.sinks,
+      ([sink, ctx]) => Effect.provide(sink.onFailure(cause), ctx),
+      DISCARD
+    )
   }
 }
 
 /**
- * Constructs a Subject that can be used to broadcast events to many consumers.
- * @since 1.18.0
- * @category constructors
+ * @internal
  */
-export const make: <E, A>() => Subject<never, E, A> = internal.makeSubject
+export class HoldSubjectImpl<E, A> extends SubjectImpl<E, A> implements Subject<never, E, A> {
+  private lastValue: MutableRef.MutableRef<Option.Option<A>> = MutableRef.make(Option.none())
+
+  // Emit an event to all sinks
+  onSuccess = (a: A) =>
+    Effect.suspend(() => {
+      MutableRef.set(this.lastValue, Option.some(a))
+
+      return this.onEvent(a)
+    })
+
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+    return this.addSink(sink, (scope) =>
+      Option.match(MutableRef.get(this.lastValue), {
+        onNone: () => awaitScopeClose(scope),
+        onSome: (a) => Effect.zipRight(sink.onSuccess(a), awaitScopeClose(scope))
+      }))
+  }
+}
 
 /**
- * Constructs a Subject that can be used to broadcast events to many consumers.
- * If a previous event has been consumed previously, any "late" subscribers will
- * receive that previous event.
- * @since 1.18.0
- * @category constructors
+ * @internal
  */
-export const makeHold: <E, A>() => Subject<never, E, A> = internal.makeHoldSubject
+export class ReplaySubjectImpl<E, A> extends SubjectImpl<E, A> {
+  constructor(readonly buffer: RingBuffer<A>) {
+    super()
+  }
+
+  // Emit an event to all sinks
+  onSuccess = (a: A) =>
+    Effect.suspend(() => {
+      this.buffer.push(a)
+
+      return this.onEvent(a)
+    })
+
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+    return this.addSink(
+      sink,
+      (scope) => Effect.zipRight(this.buffer.forEach((a) => sink.onSuccess(a)), awaitScopeClose(scope))
+    )
+  }
+}
 
 /**
- * Constructs a Subject that can be used to broadcast events to many consumers.
- * If a previous event has been consumed previously, any "late" subscribers will
- * receive _up to_ `capacity` previous events.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const makeReplay: <E, A>(capacity: number) => Subject<never, E, A> = internal.makeReplaySubject
+export function unsafeMake<E, A>(replay: number = 0): Subject<never, E, A> {
+  replay = Math.max(0, replay)
+
+  if (replay === 0) {
+    return new SubjectImpl<E, A>()
+  } else if (replay === 1) {
+    return new HoldSubjectImpl<E, A>()
+  } else {
+    return new ReplaySubjectImpl<E, A>(new RingBuffer(replay))
+  }
+}
 
 /**
- * Construct a contextual Subject
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function tagged<E, A>(): {
-  <const I extends C.IdentifierFactory<any>>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A>
-  <const I>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A>
-} {
-  function makeTagged<const I extends C.IdentifierFactory<any>>(
-    identifier: I
-  ): Subject.Tagged<C.IdentifierOf<I>, E, A>
-  function makeTagged<const I>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A>
-  function makeTagged<const I>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A> {
-    return new ContextImpl(C.Tagged<I, Subject<never, E, A>>(identifier))
-  }
+export function make<E, A>(replay?: number): Effect.Effect<Scope.Scope, never, Subject<never, E, A>> {
+  return Effect.acquireRelease(Effect.sync(() => unsafeMake(replay)), (subject) => subject.interrupt)
+}
 
-  return makeTagged
+/**
+ * @since 1.20.0
+ */
+export function fromTag<I, S, R, E, A>(tag: C.Tag<I, S>, f: (s: S) => Subject<R, E, A>): Subject<I | R, E, A> {
+  return new FromTag(tag, f)
 }
 
-class ContextImpl<I, E, A> extends ToFx<I, E, A> implements Subject.Tagged<I, E, A> {
-  interrupt: Subject.Tagged<I, E, A>["interrupt"]
-  subscriberCount: Subject.Tagged<I, E, A>["subscriberCount"]
+class FromTag<I, S, R, E, A> extends FxBase<I | R | Scope.Scope, E, A> implements Subject<I | R, E, A> {
+  private get: Effect.Effect<I, never, Subject<R, E, A>>
 
-  constructor(readonly tag: C.Tagged<I, Subject<never, E, A>>) {
+  readonly subscriberCount: Effect.Effect<I | R, never, number>
+  readonly interrupt: Effect.Effect<I | R, never, void>
+
+  constructor(readonly tag: C.Tag<I, S>, readonly f: (s: S) => Subject<R, E, A>) {
     super()
 
-    this.onFailure = this.onFailure.bind(this)
-    this.onSuccess = this.onSuccess.bind(this)
-    this.provide = this.provide.bind(this)
-    this.make = this.make.bind(this)
-    this.interrupt = tag.withEffect((subject) => subject.interrupt)
-    this.subscriberCount = tag.withEffect((subject) => subject.subscriberCount)
+    this.get = Effect.map(tag, f)
+    this.subscriberCount = Effect.flatMap(this.get, (subject) => subject.subscriberCount)
+    this.interrupt = Effect.flatMap(this.get, (subject) => subject.interrupt)
   }
 
-  toFx() {
-    return fromFxEffect(this.tag)
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<I | R | R2 | Scope.Scope, never, unknown> {
+    return Effect.flatMap(this.get, (subject) => subject.run(sink))
   }
 
-  onFailure(cause: Cause<E>) {
-    return this.tag.withEffect((subject) => subject.onFailure(cause))
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<I | R, never, unknown> {
+    return Effect.flatMap(this.get, (subject) => subject.onFailure(cause))
   }
 
-  onSuccess(a: A) {
-    return this.tag.withEffect((subject) => subject.onSuccess(a))
+  onSuccess(value: A): Effect.Effect<I | R, never, unknown> {
+    return Effect.flatMap(this.get, (subject) => subject.onSuccess(value))
   }
+}
 
-  make(replay?: number): Layer.Layer<never, never, I> {
-    return this.tag.layer(Effect.sync(() => {
-      if (replay === undefined || replay <= 0) {
-        return make<E, A>()
-      } else if (replay === 1) {
-        return makeHold<E, A>()
-      } else {
-        return makeReplay<E, A>(replay)
+/**
+ * @since 1.20.0
+ */
+export function tagged<E, A>(): {
+  <const I extends C.IdentifierFactory<any>>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A>
+  <const I>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A>
+} {
+  return <const I>(identifier: I) => new TaggedImpl(C.Tagged<I, Subject<never, E, A>>(identifier))
+}
+
+const isDataFirst = (args: IArguments): boolean =>
+  args.length === 2 || Effect.isEffect(args[0]) || hasProperty(args[0], TypeId)
+
+class TaggedImpl<I, E, A> extends FromTag<I, Subject<never, E, A>, never, E, A> implements Subject.Tagged<I, E, A> {
+  readonly provide: Subject.Tagged<I, E, A>["provide"]
+
+  constructor(readonly tag: C.Tagged<I, Subject<never, E, A>>) {
+    super(tag, identity)
+
+    this.provide = dual(
+      isDataFirst,
+      <R2, E2, B>(fxOrEffect: Fx<R2, E2, B> | Effect.Effect<R2, E2, B>, replay?: number) => {
+        if (TypeId in fxOrEffect) return provide(fxOrEffect as Fx<Exclude<R2, I>, E2, B>, this.make(replay))
+        else return Effect.provide(fxOrEffect as Effect.Effect<R2, E2, B>, this.make(replay))
       }
-    }))
+    )
   }
 
-  provide: (replay?: number) => <R2, E2, B>(effect: Effect.Effect<R2, E2, B>) => Effect.Effect<Exclude<R2, I>, E2, B> =
-    (replay) => (effect) => Effect.provide(effect, this.make(replay))
-
-  provideFx: (replay?: number) => <R2, E2, B>(fx: Fx<R2, E2, B>) => Fx<Exclude<R2, I>, E2, B> = (replay) => (fx) =>
-    provide(fx, this.make(replay))
+  make(replay?: number): Layer.Layer<never, never, I> {
+    return this.tag.scoped(make(replay))
+  }
 }

package/src/TypeId.ts

@@ -2,7 +2,7 @@
  * @since 1.18.0
  * @category symbols
  */
-export const TypeId = Symbol.for("./Fx.js")
+export const TypeId = Symbol.for("@typed/fx/Fx")
 
 /**
  * @since 1.18.0
@@ -14,7 +14,7 @@ export type TypeId = typeof TypeId
  * @since 1.18.0
  * @category symbols
  */
-export const RefSubjectTypeId = Symbol.for("./RefSubject.js")
+export const RefSubjectTypeId = Symbol.for("@typed/fx/RefSubject")
 
 /**
  * @since 1.18.0
@@ -26,7 +26,7 @@ export type RefSubjectTypeId = typeof RefSubjectTypeId
  * @since 1.18.0
  * @category symbols
  */
-export const ComputedTypeId = Symbol.for("./Computed.js")
+export const ComputedTypeId = Symbol.for("@typed/fx/Computed")
 
 /**
  * @since 1.18.0
@@ -38,10 +38,22 @@ export type ComputedTypeId = typeof ComputedTypeId
  * @since 1.18.0
  * @category symbols
  */
-export const FilteredTypeId = Symbol.for("./Filtered.js")
+export const FilteredTypeId = Symbol.for("@typed/fx/Filtered")
 
 /**
  * @since 1.18.0
  * @category symbols
  */
 export type FilteredTypeId = typeof FilteredTypeId
+
+/**
+ * @since 1.18.0
+ * @category symbols
+ */
+export const PushTypeId = Symbol.for("@typed/fx/Push")
+
+/**
+ * @since 1.18.0
+ * @category symbols
+ */
+export type PushTypeId = typeof PushTypeId