@typed/fx 1.27.4 → 1.29.0

package/src/Sink.ts

@@ -4,13 +4,14 @@
  */
 
 import * as C from "@typed/context"
-import type { Predicate, Tracer } from "effect"
 import * as Cause from "effect/Cause"
 import * as Clock from "effect/Clock"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
+import type * as Predicate from "effect/Predicate"
+import type * as Tracer from "effect/Tracer"
 import { type Bounds } from "./internal/bounds.js"
 
 /**
@@ -98,13 +99,13 @@ export function withEarlyExit<A, E, R, B, R2>(
   return Effect.asyncEffect((resume: (effect: Effect.Effect<void>) => void) => {
     const earlyExit: WithEarlyExit<A, E, R> = {
       ...sink,
-      earlyExit: Effect.sync(() => resume(Effect.unit))
+      earlyExit: Effect.sync(() => resume(Effect.void))
     }
 
-    return Effect.asUnit(Effect.matchCauseEffect(f(earlyExit), {
-      onFailure: (cause) => sink.onFailure(cause),
+    return Effect.matchCauseEffect(f(earlyExit), {
+      onFailure: (cause) => Effect.asVoid(sink.onFailure(cause)),
       onSuccess: () => earlyExit.earlyExit
-    }))
+    })
   })
 }
 
@@ -163,7 +164,7 @@ class FilterSink<A, E, R> implements Sink<A, E, R> {
 
   onSuccess(value: A) {
     if (this.predicate(value)) return this.sink.onSuccess(value)
-    else return Effect.unit
+    else return Effect.void
   }
 }
 
@@ -190,7 +191,7 @@ class FilterMapSink<A, E, R, B> implements Sink<A, E, R> {
   onSuccess(value: A) {
     const option = this.f(value)
     if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-    else return Effect.unit
+    else return Effect.void
   }
 }
 
@@ -264,7 +265,7 @@ class FilterMapEffectSink<A, E, R, B, E2, R2> implements Sink<B, E2, R | R2> {
       onFailure: (cause) => this.sink.onFailure(cause),
       onSuccess: (option) => {
         if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -303,7 +304,7 @@ class FilterEffectSink<A, E, R> implements Sink<A, E, R> {
       onFailure: (cause) => this.sink.onFailure(cause),
       onSuccess: (b) => {
         if (b) return this.sink.onSuccess(value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -457,7 +458,7 @@ class FilterMapLoopSink<A, E, R, B, C> implements Sink<A, E, R> {
     const [option, acc] = this.f(this.seed, value)
     this.seed = acc
     if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-    else return Effect.unit
+    else return Effect.void
   }
 }
 
@@ -495,7 +496,7 @@ class FilterMapLoopCauseSink<A, E, R, B, C> implements Sink<A, E, R> {
     const [option, acc] = this.f(this.seed, cause)
     this.seed = acc
     if (Option.isSome(option)) return this.sink.onFailure(option.value)
-    else return Effect.unit
+    else return Effect.void
   }
 
   onSuccess(value: A) {
@@ -588,7 +589,7 @@ class FilterMapLoopEffectSink<A, E, R, B, R2, C> implements Sink<A, E, R | R2> {
       onSuccess: ([option, acc]) => {
         this.seed = acc
         if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -669,7 +670,7 @@ class FilterMapLoopCauseEffectSink<A, E, R, B, E2, R2, C> implements Sink<A, E,
       onSuccess: ([option, acc]) => {
         this.seed = acc
         if (Option.isSome(option)) return this.sink.onFailure(option.value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -721,10 +722,10 @@ class SliceSink<A, E, R> implements Sink<A, E, R> {
   onSuccess(value: A) {
     if (this.drop > 0) {
       this.drop--
-      return Effect.unit
+      return Effect.void
     }
     if (this.take-- > 0) {
-      return Effect.tap(this.sink.onSuccess(value), () => this.take === 0 ? this.sink.earlyExit : Effect.unit)
+      return Effect.tap(this.sink.onSuccess(value), () => this.take === 0 ? this.sink.earlyExit : Effect.void)
     }
     return this.sink.earlyExit
   }
@@ -794,25 +795,43 @@ export const dropWhile: {
 })
 
 /**
- * @since 1.20.0
+ * @since 2.0.0
  */
 export const dropAfter: {
-  <A>(predicate: Predicate.Predicate<A>): <E, R>(
-    sink: Sink<A, E, R>
-  ) => Sink<A, E, R>
-  <A, E, R>(sink: Sink<A, E, R>, predicate: Predicate.Predicate<A>): Sink<A, E, R>
-} = dual(2, function dropAfter<A, E, R>(
+  <A, E, R, R2>(
+    sink: Sink<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    f: (sink: Sink<A, E, R>) => Effect.Effect<unknown, E, R2>
+  ): Effect.Effect<void, never, R | R2>
+} = dual(3, function dropAfter<A, E, R, R2>(
   sink: Sink<A, E, R>,
-  predicate: Predicate.Predicate<A>
-) {
-  return filterMapLoop(sink, false, (drop: boolean, a: A) => {
-    if (drop === true) return [Option.none(), drop]
-
-    const drop2 = predicate(a)
-    return [Option.some(a), drop2]
-  })
+  predicate: Predicate.Predicate<A>,
+  f: (sink: Sink<A, E, R>) => Effect.Effect<unknown, E, R2>
+): Effect.Effect<void, never, R | R2> {
+  return withEarlyExit(sink, (s) => f(new DropAfterSink(s, predicate)))
 })
 
+class DropAfterSink<A, E, R> implements Sink<A, E, R> {
+  constructor(
+    readonly sink: WithEarlyExit<A, E, R>,
+    readonly predicate: Predicate.Predicate<A>
+  ) {
+    this.onFailure = this.onFailure.bind(this)
+    this.onSuccess = this.onSuccess.bind(this)
+  }
+
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, R> {
+    return this.sink.onFailure(cause)
+  }
+
+  onSuccess(value: A) {
+    if (this.predicate(value)) {
+      return Effect.zipRight(this.sink.onSuccess(value), this.sink.earlyExit)
+    }
+    return this.sink.onSuccess(value)
+  }
+}
+
 /**
  * @since 1.20.0
  */
@@ -1019,7 +1038,7 @@ class FromTag<I, S, B, E2, R2> implements Sink<B, E2, I | R2> {
  */
 export function ignoreInterrupt<A, E, R>(sink: Sink<A, E, R>): Sink<A, E, R> {
   return make(
-    (cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause),
+    (cause) => Cause.isInterruptedOnly(cause) ? Effect.void : sink.onFailure(cause),
     sink.onSuccess
   )
 }

package/src/Subject.ts

@@ -4,14 +4,16 @@
  */
 
 import * as C from "@typed/context"
-import type { Cause, Layer, Pipeable } from "effect"
+import type * as Cause from "effect/Cause"
 import type * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Exit from "effect/Exit"
 import { dual, identity } from "effect/Function"
+import type * as Layer from "effect/Layer"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
+import type * as Pipeable from "effect/Pipeable"
 import { hasProperty } from "effect/Predicate"
 import * as Scope from "effect/Scope"
 import { type Fx } from "./Fx.js"
@@ -101,12 +103,7 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
   }
 
   protected interruptScopes = Effect.fiberIdWith((id) =>
-    Effect.tap(
-      Effect.forEach(this.sinks, ([, , scope]) => Scope.close(scope, Exit.interrupt(id)), DISCARD),
-      () => {
-        this.sinks.clear()
-      }
-    )
+    Effect.forEach(Array.from(this.sinks), ([, , scope]) => Scope.close(scope, Exit.interrupt(id)), DISCARD)
   )
 
   readonly interrupt = this.interruptScopes
@@ -134,7 +131,7 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
   readonly subscriberCount: Effect.Effect<number> = Effect.sync(() => this.sinks.size)
 
   protected onEvent(a: A) {
-    if (this.sinks.size === 0) return Effect.unit
+    if (this.sinks.size === 0) return Effect.void
     else if (this.sinks.size === 1) {
       const [sink, ctx] = this.sinks.values().next().value
       return runSinkEvent(sink, ctx, a)
@@ -148,14 +145,14 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
   }
 
   protected onCause(cause: Cause.Cause<E>) {
-    if (this.sinks.size === 0) return Effect.unit
+    if (this.sinks.size === 0) return Effect.void
     else if (this.sinks.size === 1) {
-      const [sink, ctx] = this.sinks.values().next().value
-      return runSinkCause(sink, ctx, cause)
+      const [sink, ctx, scope] = this.sinks.values().next().value
+      return runSinkCause(sink, ctx, scope, cause)
     } else {
       return Effect.forEach(
         this.sinks,
-        ([sink, ctx]) => runSinkCause(sink, ctx, cause),
+        ([sink, ctx, scope]) => runSinkCause(sink, ctx, scope, cause),
         DISCARD
       )
     }
@@ -166,8 +163,16 @@ function runSinkEvent<A, E>(sink: Sink<A, E, any>, ctx: Context.Context<any>, a:
   return Effect.provide(Effect.catchAllCause(sink.onSuccess(a), sink.onFailure), ctx)
 }
 
-function runSinkCause<A, E>(sink: Sink<A, E, any>, ctx: Context.Context<any>, cause: Cause.Cause<E>) {
-  return Effect.provide(Effect.catchAllCause(sink.onFailure(cause), () => Effect.unit), ctx)
+function runSinkCause<A, E>(
+  sink: Sink<A, E, any>,
+  ctx: Context.Context<any>,
+  scope: Scope.CloseableScope,
+  cause: Cause.Cause<E>
+) {
+  return Effect.provide(
+    Effect.catchAllCause(sink.onFailure(cause), (error) => Scope.close(scope, Exit.failCause(error))),
+    ctx
+  )
 }
 
 /**

package/src/Versioned.ts

@@ -6,12 +6,14 @@
  */
 
 import type * as Context from "@typed/context"
-import type { Layer, Runtime, Scope } from "effect"
-import { Exit } from "effect"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import { dual, flow } from "effect/Function"
+import type * as Layer from "effect/Layer"
 import { sum } from "effect/Number"
 import * as Option from "effect/Option"
+import type * as Runtime from "effect/Runtime"
+import type * as Scope from "effect/Scope"
 import type { Fx } from "./Fx.js"
 import * as core from "./internal/core.js"
 import { MulticastEffect } from "./internal/helpers.js"

package/src/internal/DeferredRef.ts

@@ -1,35 +1,41 @@
-import type { Equivalence, FiberId } from "effect"
+import { MutableRef } from "effect"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import type * as Equivalence from "effect/Equivalence"
 import * as Exit from "effect/Exit"
+import type * as FiberId from "effect/FiberId"
 import * as Option from "effect/Option"
 import { EffectBase } from "./protos.js"
 
 export class DeferredRef<E, A> extends EffectBase<A, E, never> {
   // Keep track of the latest value emitted by the stream
-  public current!: Option.Option<Exit.Exit<A, E>>
   public version!: number
   public deferred!: Deferred.Deferred<A, E>
 
-  constructor(private id: FiberId.FiberId, private eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
+  constructor(
+    private id: FiberId.FiberId,
+    private eq: Equivalence.Equivalence<Exit.Exit<A, E>>,
+    readonly current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>
+  ) {
     super()
     this.reset()
   }
 
   toEffect() {
     return Effect.suspend(() => {
-      if (Option.isNone(this.current)) {
+      const current = MutableRef.get(this.current)
+      if (Option.isNone(current)) {
         return Deferred.await(this.deferred)
       } else {
-        return this.current.value
+        return current.value
       }
     })
   }
 
   done(exit: Exit.Exit<A, E>) {
-    const current = this.current
+    const current = MutableRef.get(this.current)
 
-    this.current = Option.some(exit)
+    MutableRef.set(this.current, Option.some(exit))
 
     if (Option.isSome(current) && this.eq(current.value, exit)) {
       return false
@@ -42,7 +48,7 @@ export class DeferredRef<E, A> extends EffectBase<A, E, never> {
   }
 
   reset() {
-    this.current = Option.none()
+    MutableRef.set(this.current, Option.none())
     this.version = -1
 
     if (this.deferred) {
@@ -54,9 +60,13 @@ export class DeferredRef<E, A> extends EffectBase<A, E, never> {
 }
 
 export function make<E, A>(eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
-  return Effect.map(Effect.fiberId, (id) => new DeferredRef(id, eq))
+  return Effect.map(Effect.fiberId, (id) => new DeferredRef(id, eq, MutableRef.make(Option.none())))
 }
 
-export function unsafeMake<E, A>(id: FiberId.FiberId, eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
-  return new DeferredRef(id, eq)
+export function unsafeMake<E, A>(
+  id: FiberId.FiberId,
+  eq: Equivalence.Equivalence<Exit.Exit<A, E>>,
+  current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>
+) {
+  return new DeferredRef(id, eq, current)
 }