@typed/fx 1.18.4 → 1.20.0

package/src/Guard.ts

@@ -2,8 +2,10 @@
  * @since 1.18.0
  */
 
-import { Effect, Option } from "effect"
+import type { Predicate } from "effect"
+import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import * as Option from "effect/Option"
 
 /**
  * @since 1.18.0
@@ -157,3 +159,12 @@ export type AnyOutput<GS extends Readonly<Record<string, Guard<any, any, any, an
     [K in keyof GS]: { readonly _tag: K; readonly value: Guard.Output<GS[K]> }
   }[keyof GS]
 ] extends [infer R] ? R : never
+
+/**
+ * @since 1.20.0
+ */
+export function liftPredicate<A, B extends A>(predicate: Predicate.Refinement<A, B>): Guard<A, never, never, B>
+export function liftPredicate<A>(predicate: Predicate.Predicate<A>): Guard<A, never, never, A>
+export function liftPredicate<A>(predicate: Predicate.Predicate<A>): Guard<A, never, never, A> {
+  return (a) => Effect.sync(() => (predicate(a) ? Option.some(a) : Option.none()))
+}

package/src/Idle.ts

@@ -5,19 +5,22 @@
  */
 
 import type * as Context from "@typed/context"
-import { MutableHashMap, Option } from "effect"
 import * as Effect from "effect/Effect"
-import * as Fiber from "effect/Fiber"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
+import type * as Fiber from "effect/Fiber"
 import { constant, constVoid } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
-import type { Hash } from "effect/Hash"
 import * as Layer from "effect/Layer"
 import type * as Queue from "effect/Queue"
 import * as Scheduler from "effect/Scheduler"
 import * as Scope from "effect/Scope"
-import { dequeueIsActive } from "./internal/fx.js"
+import { dequeueIsActive } from "./Fx.js"
+import { withScope } from "./internal/helpers.js"
 import { cancelIdleCallback, requestIdleCallback } from "./internal/requestIdleCallback.js"
 
+// TODO: Why is this even in the Fx package?? Where should we put it?
+
 /**
  * The IdleScheduler is an implementation of Effect's Scheduler interface, which utilizes a priority queue
  * to order tasks to be run when the event loop is idle through the usage of requestIdleCallback.
@@ -42,7 +45,7 @@ class IdleSchedulerImpl implements IdleScheduler {
     this.#tasks.scheduleTask(task, priority)
 
     // If we're not running yet, schedule the next run
-    if (!this.#running) {
+    if (this.#running === false) {
       this.#running = true
       this.scheduleNextRun()
     }
@@ -62,23 +65,30 @@ class IdleSchedulerImpl implements IdleScheduler {
   }
 
   private scheduleNextRun() {
-    this.#id = requestIdleCallback((deadline) => this.runTasks(deadline), this.options)
+    this.#id = requestIdleCallback((deadline) => this.runTasks(deadline), { timeout: 1000, ...this.options })
   }
 
   private runTasks(deadline: IdleDeadline) {
-    const buckets = this.#tasks.buckets
+    const buckets = this.#tasks.buckets.slice(0)
+    this.#tasks.buckets = []
     const length = buckets.length
 
     let i = 0
     for (; shouldContinue(deadline) && i < length; ++i) {
-      buckets[i][1].forEach((f) => f())
+      const tasks = buckets[i][1].slice()
+      tasks.forEach((f) => f())
     }
 
     // Remove all the buckets we were able to complete
     buckets.splice(0, i)
 
-    // If there are more tasks to run, schedule the next run
+    // If there are leftover tasks, requeue them
     if (buckets.length > 0) {
+      buckets.forEach(([priority, tasks]) => tasks.forEach((f) => this.#tasks.scheduleTask(f, priority)))
+    }
+
+    // If there are more tasks to run, schedule the next run
+    if (this.#tasks.buckets.length > 0) {
       this.scheduleNextRun()
     } else {
       // Otherwise we're done for now
@@ -130,7 +140,7 @@ export const whenIdle = (options?: IdleRequestOptions): Effect.Effect<Scope.Scop
  * @since 1.18.0
  */
 export function shouldContinue(deadline: IdleDeadline): boolean {
-  return deadline.didTimeout === false && deadline.timeRemaining() > 0
+  return deadline.didTimeout || deadline.timeRemaining() > 0
 }
 
 /**
@@ -200,85 +210,89 @@ export function dequeueWhileIdle<I, A, R2, E2, B>(
 /**
  * @since 1.18.0
  */
-export interface IdleQueue<I extends Hash> {
+export interface IdleQueue<I> {
   readonly add: <R>(
     part: I,
     task: Effect.Effect<R, never, unknown>
   ) => Effect.Effect<R | Scope.Scope, never, void>
+
+  readonly interrupt: Effect.Effect<never, never, void>
 }
 
 /**
  * @since 1.18.0
  */
-export const makeIdleQueue = <I extends Hash>(
+export const makeIdleQueue = <I>(
   options?: IdleRequestOptions
 ): Effect.Effect<Scope.Scope, never, IdleQueue<I>> =>
-  Effect.scopeWith((scope) => Effect.sync(() => new IdleQueueImpl<I>(scope, options)))
+  withScope((scope) => Effect.sync(() => new IdleQueueImpl<I>(scope, options)), ExecutionStrategy.sequential)
 
-class IdleQueueImpl<I extends Hash> implements IdleQueue<I> {
-  queue = MutableHashMap.empty<I, Effect.Effect<never, never, unknown>>()
+class IdleQueueImpl<I> implements IdleQueue<I> {
+  queue = new Map<I, Effect.Effect<never, never, unknown>>()
   scheduled = false
 
-  constructor(readonly scope: Scope.Scope, readonly options?: IdleRequestOptions) {}
+  readonly interrupt: Effect.Effect<never, never, void>
+  readonly scheduleNextRun: Effect.Effect<never, never, void>
+
+  constructor(readonly scope: Scope.CloseableScope, readonly options?: IdleRequestOptions) {
+    this.interrupt = Effect.fiberIdWith((id) => Scope.close(scope, Exit.interrupt(id)))
+
+    const run: Effect.Effect<Scope.Scope, never, void> = Effect.flatMap(
+      whenIdle(this.options),
+      (deadline) =>
+        Effect.gen(this, function*(_) {
+          const iterator = this.queue[Symbol.iterator]()
+
+          while (shouldContinue(deadline)) {
+            const result = iterator.next()
+
+            if (result.done) break
+            else {
+              const [part, task] = result.value
+              this.queue.delete(part)
+              yield* _(task)
+            }
+          }
+
+          if (this.queue.size > 0) {
+            yield* _(run)
+          } else {
+            this.scheduled = false
+          }
+        })
+    )
+
+    this.scheduleNextRun = Effect.provideService(
+      Effect.suspend(() => {
+        if (this.queue.size === 0) return Effect.unit
+
+        this.scheduled = true
+
+        return withScope(
+          (childScope) => Effect.provideService(run, Scope.Scope, childScope),
+          ExecutionStrategy.sequential
+        )
+      }),
+      Scope.Scope,
+      scope
+    )
+  }
 
   add = <R>(part: I, task: Effect.Effect<R, never, unknown>) =>
     Effect.contextWithEffect((ctx: Context.Context<R>) => {
       const provided = Effect.provide(task, ctx)
-      MutableHashMap.set(this.queue, part, provided)
+      this.queue.set(part, provided)
 
       return Effect.zipRight(
         Effect.addFinalizer(() =>
           Effect.sync(() => {
-            const currentTask = MutableHashMap.get(this.queue, part)
-
             // If the current task is still the same we'll delete it from the queue
-            if (Option.isSome(currentTask) && currentTask.value === provided) {
-              MutableHashMap.remove(this.queue, part)
+            if (this.queue.get(part) === provided) {
+              this.queue.delete(part)
             }
           })
         ),
         this.scheduleNextRun
       )
     })
-
-  scheduleNextRun = Effect.suspend(() => {
-    if (MutableHashMap.size(this.queue) === 0) return Effect.unit
-
-    this.scheduled = true
-
-    return Scope.addFinalizer(this.scope, Fiber.interrupt(Effect.runFork(this.run)))
-  })
-
-  run: Effect.Effect<never, never, void> = Effect.suspend(() =>
-    Effect.provideService(
-      Effect.flatMap(
-        whenIdle(this.options),
-        (deadline) =>
-          Effect.gen(this, function*(_) {
-            const iterator = this.queue[Symbol.iterator]()
-
-            while (shouldContinue(deadline)) {
-              const result = iterator.next()
-
-              if (result.done) break
-              else {
-                const [part, task] = result.value
-                MutableHashMap.remove(this.queue, part)
-                yield* _(task)
-              }
-            }
-
-            if (MutableHashMap.size(this.queue) > 0) {
-              return this.run
-            }
-
-            this.scheduled = false
-
-            return Effect.unit
-          })
-      ),
-      Scope.Scope,
-      this.scope
-    )
-  )
 }

package/src/Match.ts

@@ -2,20 +2,29 @@
  * @since 1.18.0
  */
 
-import { Effect, Exit } from "effect"
 import * as Cause from "effect/Cause"
 import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
 import { identity } from "effect/Function"
+import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import { isNonEmptyReadonlyArray, reduce } from "effect/ReadonlyArray"
+import * as Scope from "effect/Scope"
 import * as Fx from "./Fx.js"
 import type { Guard } from "./Guard.js"
+import { withScopedFork } from "./internal/helpers.js"
+import { FxBase } from "./internal/protos.js"
 import * as RefSubject from "./RefSubject.js"
+import * as Sink from "./Sink.js"
+import * as Subject from "./Subject.js"
 
 /**
  * @since 1.18.0
  */
-export const MatcherTypeId: unique symbol = Symbol.for("./Matcher.js")
+export const MatcherTypeId: unique symbol = Symbol.for("@typed/fx/Matcher")
 /**
  * @since 1.18.0
  */
@@ -29,23 +38,25 @@ export interface TypeMatcher<R, E, I, O> {
 
   readonly [MatcherTypeId]: Matcher.Variance<R, E, I, O>
 
-  readonly when: <R2, E2, A, R3 = never, E3 = never, B = never>(
+  readonly when: <R2 = never, E2 = never, A = never, R3 = never, E3 = never, B = never>(
     guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
-    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.FxInput<R3, E3, B>
+    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R3, E3, B>
   ) => TypeMatcher<R | R2 | R3, E | E2 | E3, I, O | B>
 
-  readonly to: <R2, E2, A, B>(
+  readonly to: <R2 = never, E2 = never, A = never, B = never>(
     guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
     onMatch: B
   ) => TypeMatcher<R | R2, E | E2, I, O | B>
 
-  readonly run: <R2 = never, E2 = never>(input: Fx.FxInput<R2, E2, I>) => Fx.Fx<R | R2, E | E2, Option.Option<O>>
+  readonly run: <R2 = never, E2 = never>(
+    input: Fx.Fx<R2, E2, I>
+  ) => Fx.Fx<R | R2 | Scope.Scope, E | E2, Option.Option<O>>
 }
 
 /**
  * @since 1.18.0
  */
-export interface ValueMatcher<R, E, I, O> {
+export interface ValueMatcher<R, E, I, O> extends Fx.Fx<R | Scope.Scope, E, Option.Option<O>> {
   readonly _tag: "ValueMatcher"
 
   readonly [MatcherTypeId]: Matcher.Variance<R, E, I, O>
@@ -54,7 +65,7 @@ export interface ValueMatcher<R, E, I, O> {
 
   readonly when: <R2, E2, A, R3 = never, E3 = never, B = never>(
     guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
-    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.FxInput<R3, E3, B>
+    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R3, E3, B>
   ) => ValueMatcher<R | R2 | R3, E | E2 | E3, I, O | B>
 
   readonly to: <R2, E2, A, B>(
@@ -62,11 +73,9 @@ export interface ValueMatcher<R, E, I, O> {
     onMatch: B
   ) => ValueMatcher<R | R2, E | E2, I, O | B>
 
-  readonly run: Fx.Fx<R, E, Option.Option<O>>
-
   readonly getOrElse: <R2 = never, E2 = never, B = never>(
-    f: () => Fx.FxInput<R2, E2, B>
-  ) => Fx.Fx<R | R2, E | E2, O | B>
+    f: () => Fx.Fx<R2, E2, B>
+  ) => Fx.Fx<R | R2 | Scope.Scope, E | E2, O | B>
 }
 
 /**
@@ -93,8 +102,8 @@ export const type = <I>(): TypeMatcher<never, never, I, never> =>
 /**
  * @since 1.18.0
  */
-export const value = <R, E, I>(input: Fx.FxInput<R, E, I>): ValueMatcher<R, E, I, never> =>
-  new ValueMatcherImpl(Fx.from(input), type<I>())
+export const value = <R, E, I>(input: Fx.Fx<R, E, I>): ValueMatcher<R, E, I, never> =>
+  new ValueMatcherImpl(input, type<I>())
 
 // Internals
 
@@ -108,7 +117,16 @@ const variance: Matcher.Variance<any, any, any, any> = {
 class When<R, E, I, A, O> {
   constructor(
     readonly guard: (input: I) => Effect.Effect<R, E, Option.Option<A>>,
-    readonly onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.FxInput<R, E, O>
+    readonly onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R, E, O>
+  ) {}
+}
+
+class Matched<R, E, I, A, O> {
+  constructor(
+    readonly when: When<R, E, I, A, O>,
+    readonly ref: RefSubject.RefSubject<never, never, A>,
+    readonly fiber: Fiber.Fiber<never, unknown>,
+    readonly interrupt: Effect.Effect<never, never, void>
   ) {}
 }
 
@@ -123,7 +141,7 @@ class TypeMatcherImpl<R, E, I, O> implements TypeMatcher<R, E, I, O> {
 
   when<R2, E2, A, R3 = never, E3 = never, B = never>(
     guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
-    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.FxInput<R3, E3, B>
+    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R3, E3, B>
   ): TypeMatcher<R | R2 | R3, E | E2 | E3, I, O | B> {
     return new TypeMatcherImpl<R | R2 | R3, E | E2 | E3, I, O | B>(
       Chunk.append(this.cases, new When<R2 | R3, E2 | E3, I, A, B>(getGuard(guard), onMatch))
@@ -134,112 +152,153 @@ class TypeMatcherImpl<R, E, I, O> implements TypeMatcher<R, E, I, O> {
     guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
     onMatch: B
   ): TypeMatcher<R | R2, E | E2, I, O | B> {
-    return this.when(guard, () => Effect.succeed(onMatch))
+    return this.when(guard, () => Fx.succeed(onMatch))
   }
 
-  run<R2, E2>(input: Fx.FxInput<R2, E2, I>): Fx.Fx<R | R2, E | E2, Option.Option<O>> {
+  run<R2, E2>(input: Fx.Fx<R2, E2, I>): Fx.Fx<R | R2 | Scope.Scope, E | E2, Option.Option<O>> {
     const { cases } = this
 
-    return Fx.suspend(() => {
-      const refSubjects = new WeakMap<When<any, any, I, any, any>, RefSubject.RefSubject<never, never, any>>()
-
-      const getRefSubject = (_case: When<any, any, I, any, any>, value: any) =>
-        Effect.gen(function*(_) {
-          let refSubject = refSubjects.get(_case)
-
-          if (refSubject) {
-            yield* _(refSubject.set(value))
-          } else {
-            refSubject = yield* _(RefSubject.of(value))
-          }
+    return Fx.make<R | R2 | Scope.Scope, E | E2, Option.Option<O>>((sink) =>
+      withScopedFork(
+        (fork, parentScope) => {
+          let previous: Matched<any, any, I, any, O>
+
+          const onMatch = <A>(
+            when: When<R | R2 | Scope.Scope, E | E2, I, A, O>,
+            value: A
+          ) =>
+            Effect.gen(function*(_) {
+              if (previous?.when === when) {
+                yield* _(RefSubject.set(previous.ref, value))
+              } else {
+                // Interrupt any previous resources
+                if (previous !== undefined) {
+                  yield* _(previous.interrupt)
+                }
 
-          return refSubject
-        })
+                // RefSubject to pass along to our matching function
+                const refSubject = yield* _(RefSubject.of(value))
+
+                // Track if the case is ended
+                const hasEnded = MutableRef.make(false)
+                // Used to signal when the case has ended
+                const endSignal = Subject.unsafeMake<never, void>(0)
+
+                // Run the case
+                const fiber = yield* _(
+                  fork(
+                    Fx.mergeFirst(when.onMatch(refSubject), Fx.tap(endSignal, () => MutableRef.set(hasEnded, true)))
+                      .run(
+                        Sink.make(
+                          (cause) =>
+                            MutableRef.get(hasEnded) || Cause.isInterruptedOnly(cause)
+                              ? Effect.unit
+                              : sink.onFailure(cause),
+                          (value) => MutableRef.get(hasEnded) ? Effect.unit : sink.onSuccess(Option.some(value))
+                        )
+                      )
+                  )
+                )
+
+                previous = new Matched(
+                  when,
+                  refSubject,
+                  fiber,
+                  // Interrupt the case when the endSignal first to disallow emissions of values, but asynchonously
+                  // interrupt the fiber without blocking the next match to take over.
+                  Effect.all([endSignal.onSuccess(undefined), Fiber.interruptFork(fiber)], { discard: true })
+                )
+              }
+            }).pipe(Effect.provideService(Scope.Scope, parentScope))
 
-      let previous: When<any, any, I, any, any>
+          function matchWhen<A>(input: I, when: When<R | R2 | Scope.Scope, E | E2, I, A, O>) {
+            return Effect.gen(function*(_) {
+              const matched = yield* _(when.guard(input))
 
-      return Fx.from(input).pipe(
-        Fx.switchMap((input) =>
-          Effect.gen(function*(_) {
-            // Allow failures to be accumulated, such that errors do not break the overall match
-            // and additional matchers can be attempted against first
-            const causes: Array<Cause.Cause<E>> = []
+              if (Option.isSome(matched)) {
+                yield* _(onMatch(when, matched.value))
 
-            // If there's a previous match, attempt it first
-            if (previous) {
-              const matchedExit = yield* _(previous.guard(input), Effect.exit)
+                return true
+              } else {
+                return false
+              }
+            })
+          }
 
-              if (Exit.isSuccess(matchedExit)) {
-                const matched = matchedExit.value
+          function matchInput(input: I) {
+            return Effect.gen(function*(_) {
+              // Allow failures to be accumulated, such that errors do not break the overall match
+              // and additional matchers can be attempted against first
+              const causes: Array<Cause.Cause<E | E2>> = []
 
-                if (Option.isSome(matched)) {
-                  const refSubject = yield* _(getRefSubject(previous, matched.value))
+              // If there's a previous match, attempt it first to avoid re-testing all cases in order
+              if (previous !== undefined) {
+                const matchedExit = yield* _(matchWhen(input, previous.when), Effect.exit)
 
-                  return Option.some([previous, refSubject] as const)
+                if (Exit.isFailure(matchedExit)) {
+                  causes.push(matchedExit.cause)
+                } else if (matchedExit.value) {
+                  return
                 }
-              } else {
-                causes.push(matchedExit.cause)
               }
-            }
-
-            for (const _case of cases) {
-              // Don't test this case twice
-              if (_case === previous) continue
-
-              const matchedExit = yield* _(_case.guard(input), Effect.exit)
 
-              if (Exit.isSuccess(matchedExit)) {
-                const matched = matchedExit.value
+              for (const when of cases) {
+                // Don't test this case twice
+                if (when === previous?.when) continue
 
-                if (Option.isSome(matched)) {
-                  const refSubject = yield* _(getRefSubject(_case, matched.value))
-                  previous = _case
+                const matchedExit = yield* _(matchWhen(input, when), Effect.exit)
 
-                  return Option.some([_case, refSubject] as const)
+                if (Exit.isFailure(matchedExit)) {
+                  causes.push(matchedExit.cause)
+                } else if (matchedExit.value) {
+                  return
                 }
+              }
+
+              if (isNonEmptyReadonlyArray(causes)) {
+                const [first, ...rest] = causes
+                yield* _(sink.onFailure(reduce(rest, first, Cause.sequential)))
               } else {
-                causes.push(matchedExit.cause)
+                if (previous !== undefined) {
+                  yield* _(previous.interrupt)
+                }
+
+                yield* _(sink.onSuccess(Option.none()))
               }
-            }
-
-            if (isNonEmptyReadonlyArray(causes)) {
-              const [first, ...rest] = causes
-
-              return yield* _(Effect.failCause(reduce(rest, first, Cause.sequential)))
-            } else {
-              return Option.none()
-            }
-          })
-        ),
-        // Avoid restarting based on the Case that was matched to keep a peristent
-        // workflow for matcher that has its input values change
-        Fx.skipRepeatsWith(Option.getEquivalence(([a], [b]) => a === b)),
-        Fx.switchMap(
-          Option.match({
-            onNone: () => Effect.succeedNone,
-            onSome: ([when, ref]) => {
-              return Fx.map(Fx.from(when.onMatch(ref)), Option.some)
-            }
-          })
-        )
+            })
+          }
+
+          return Fx.skipRepeats(input).run(Sink.make(
+            sink.onFailure,
+            matchInput
+          ))
+        },
+        ExecutionStrategy.sequential
       )
-    })
+    )
   }
 }
 
-class ValueMatcherImpl<R, E, I, O> implements ValueMatcher<R, E, I, O> {
+class ValueMatcherImpl<R, E, I, O> extends FxBase<R | Scope.Scope, E, Option.Option<O>>
+  implements ValueMatcher<R, E, I, O>
+{
   readonly _tag = "ValueMatcher"
   readonly [MatcherTypeId]: ValueMatcher<R, E, I, O>[MatcherTypeId] = variance
 
   constructor(readonly value: Fx.Fx<R, E, I>, readonly matcher: TypeMatcher<R, E, I, O>) {
+    super()
     this.when = this.when.bind(this)
     this.to = this.to.bind(this)
     this.getOrElse = this.getOrElse.bind(this)
   }
 
+  run<R2>(sink: Sink.Sink<R2, E, Option.Option<O>>) {
+    return this.matcher.run(this.value).run(sink)
+  }
+
   when<R2, E2, A, R3 = never, E3 = never, B = never>(
     guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
-    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.FxInput<R3, E3, B>
+    onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R3, E3, B>
   ): ValueMatcher<R | R2 | R3, E | E2 | E3, I, O | B> {
     return new ValueMatcherImpl<R | R2 | R3, E | E2 | E3, I, O | B>(
       this.value,
@@ -251,13 +310,10 @@ class ValueMatcherImpl<R, E, I, O> implements ValueMatcher<R, E, I, O> {
     guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
     onMatch: B
   ): ValueMatcher<R | R2, E | E2, I, O | B> {
-    return this.when(guard, () => Effect.succeed(onMatch))
+    return this.when(guard, () => Fx.succeed(onMatch))
   }
 
-  run: ValueMatcher<R, E, I, O>["run"] = Fx.suspend(() => this.matcher.run(this.value))
-
-  getOrElse: ValueMatcher<R, E, I, O>["getOrElse"] = (f) =>
-    Fx.suspend(() => Fx.getOrElse(this.matcher.run(this.value), f))
+  getOrElse: ValueMatcher<R, E, I, O>["getOrElse"] = (f) => Fx.getOrElse(this.matcher.run(this.value), f)
 }
 
 /**

package/src/Pull.ts

@@ -13,7 +13,7 @@ import * as Either from "effect/Either"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
 import type * as Schedule from "effect/Schedule"
-import type { WithContext } from "./Sink.js"
+import type { Sink } from "./Sink.js"
 
 /**
  * An Effect which can be used to pull values of a Stream.
@@ -24,7 +24,7 @@ export interface Pull<R, E, A> extends Effect.Effect<R, Option.Option<E>, Chunk.
 function schedulePull<R, E, A, R2, R3>(
   pull: Pull<R, E, A>,
   f: (effect: Effect.Effect<R | R3, never, unknown>) => Effect.Effect<R2, never, unknown>,
-  sink: WithContext<R3, E, A>
+  sink: Sink<R3, E, A>
 ): Effect.Effect<R2, never, void> {
   return Effect.asyncEffect((resume) =>
     pull.pipe(
@@ -55,18 +55,18 @@ function schedulePull<R, E, A, R2, R3>(
 export const schedule: {
   <R2, R3, E, A>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: WithContext<R3, E, A>
+    sink: Sink<R3, E, A>
   ): <R>(pull: Pull<R, E, A>) => Effect.Effect<R | R2 | R3, never, unknown>
 
   <R, E, A, R2, R3>(
     pull: Pull<R, E, A>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: WithContext<R3, E, A>
+    sink: Sink<R3, E, A>
   ): Effect.Effect<R | R2 | R3, never, unknown>
 } = dual(3, function schedule<R, E, A, R2, R3>(
   pull: Pull<R, E, A>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
-  sink: WithContext<R3, E, A>
+  sink: Sink<R3, E, A>
 ): Effect.Effect<R | R2 | R3, never, void> {
   return schedulePull(pull, Effect.schedule(schedule), sink)
 })
@@ -79,18 +79,18 @@ export const schedule: {
 export const repeat: {
   <R2, R3, E, A>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: WithContext<R3, E, A>
+    sink: Sink<R3, E, A>
   ): <R>(pull: Pull<R, E, A>) => Effect.Effect<R | R2 | R3, never, unknown>
 
   <R, E, A, R2, R3>(
     pull: Pull<R, E, A>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: WithContext<R3, E, A>
+    sink: Sink<R3, E, A>
   ): Effect.Effect<R | R2 | R3, never, unknown>
 } = dual(3, function repeat<R, E, A, R2, R3>(
   pull: Pull<R, E, A>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
-  sink: WithContext<R3, E, A>
+  sink: Sink<R3, E, A>
 ): Effect.Effect<R | R2 | R3, never, void> {
   return schedulePull(pull, Effect.repeat(schedule), sink)
 })