@typed/fx 1.23.0 → 1.24.0

package/src/Guard.ts

@@ -10,7 +10,7 @@ import * as Option from "effect/Option"
 /**
  * @since 1.18.0
  */
-export type Guard<in I, out R, out E, out O> = (input: I) => Effect.Effect<Option.Option<O>, E, R>
+export type Guard<in I, out O, out E = never, out R = never> = (input: I) => Effect.Effect<Option.Option<O>, E, R>
 
 /**
  * @since 1.18.0
@@ -23,27 +23,27 @@ export namespace Guard {
   /**
    * @since 1.18.0
    */
-  export type Context<T> = T extends Guard<infer _I, infer R, infer _E, infer _O> ? R : never
+  export type Context<T> = T extends Guard<infer _I, infer _O, infer _E, infer R> ? R : never
   /**
    * @since 1.18.0
    */
-  export type Error<T> = T extends Guard<infer _I, infer _R, infer E, infer _O> ? E : never
+  export type Error<T> = T extends Guard<infer _I, infer _O, infer E, infer _R> ? E : never
   /**
    * @since 1.18.0
    */
-  export type Output<T> = T extends Guard<infer _I, infer _R, infer _E, infer O> ? O : never
+  export type Output<T> = T extends Guard<infer _I, infer O, infer _E, infer _R> ? O : never
 }
 
 /**
  * @since 1.18.0
  */
 export const compose: {
-  <O, R2, E2, B>(output: Guard<O, R2, E2, B>): <I, R, E>(input: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, B>
-  <I, R, E, O, R2, E2, B>(input: Guard<I, R, E, O>, output: Guard<O, R2, E2, B>): Guard<I, R | R2, E | E2, B>
-} = dual(2, function flatMap<I, R, E, O, R2, E2, B>(
-  input: Guard<I, R, E, O>,
-  output: Guard<O, R2, E2, B>
-): Guard<I, R | R2, E | E2, B> {
+  <O, B, E2, R2>(output: Guard<O, B, E2, R2>): <I, R, E>(input: Guard<I, O, E, R>) => Guard<I, B, E | E2, R | R2>
+  <I, O, E, R, B, E2, R2>(input: Guard<I, O, E, R>, output: Guard<O, B, E2, R2>): Guard<I, B, E | E2, R | R2>
+} = dual(2, function flatMap<I, O, E, R, B, E2, R2>(
+  input: Guard<I, O, E, R>,
+  output: Guard<O, B, E2, R2>
+): Guard<I, B, E | E2, R | R2> {
   return (i) =>
     Effect.flatMap(
       input(i),
@@ -58,14 +58,14 @@ export const compose: {
  * @since 1.18.0
  */
 export const mapEffect: {
-  <O, R2, E2, B>(
+  <O, B, E2, R2>(
     f: (o: O) => Effect.Effect<B, E2, R2>
-  ): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, B>
-  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<B, E2, R2>): Guard<I, R | R2, E | E2, B>
-} = dual(2, function mapEffect<I, R, E, O, R2, E2, B>(
-  guard: Guard<I, R, E, O>,
+  ): <I, R, E>(guard: Guard<I, O, E, R>) => Guard<I, B, E | E2, R | R2>
+  <I, O, E, R, B, E2, R2>(guard: Guard<I, O, E, R>, f: (o: O) => Effect.Effect<B, E2, R2>): Guard<I, B, E | E2, R | R2>
+} = dual(2, function mapEffect<I, O, E, R, B, E2, R2>(
+  guard: Guard<I, O, E, R>,
   f: (o: O) => Effect.Effect<B, E2, R2>
-): Guard<I, R | R2, E | E2, B> {
+): Guard<I, B, E | E2, R | R2> {
   return compose(guard, (o) => Effect.asSome(f(o)))
 })
 
@@ -73,12 +73,12 @@ export const mapEffect: {
  * @since 1.18.0
  */
 export const map: {
-  <O, B>(f: (o: O) => B): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, B>
-  <I, R, E, O, B>(guard: Guard<I, R, E, O>, f: (o: O) => B): Guard<I, R, E, B>
-} = dual(2, function map<I, R, E, O, B>(
-  guard: Guard<I, R, E, O>,
+  <O, B>(f: (o: O) => B): <I, R, E>(guard: Guard<I, O, E, R>) => Guard<I, B, E, R>
+  <I, O, E, R, B>(guard: Guard<I, O, E, R>, f: (o: O) => B): Guard<I, B, E, R>
+} = dual(2, function map<I, O, E, R, B>(
+  guard: Guard<I, O, E, R>,
   f: (o: O) => B
-): Guard<I, R, E, B> {
+): Guard<I, B, E, R> {
   return mapEffect(guard, (o) => Effect.sync(() => f(o)))
 })
 
@@ -86,14 +86,14 @@ export const map: {
  * @since 1.18.0
  */
 export const tap: {
-  <O, R2, E2, B>(
+  <O, B, E2, R2>(
     f: (o: O) => Effect.Effect<B, E2, R2>
-  ): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, O>
-  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<B, E2, R2>): Guard<I, R | R2, E | E2, O>
-} = dual(2, function tap<I, R, E, O, R2, E2, B>(
-  guard: Guard<I, R, E, O>,
+  ): <I, R, E>(guard: Guard<I, O, E, R>) => Guard<I, O, E | E2, R | R2>
+  <I, O, E, R, B, E2, R2>(guard: Guard<I, O, E, R>, f: (o: O) => Effect.Effect<B, E2, R2>): Guard<I, O, E | E2, R | R2>
+} = dual(2, function tap<I, O, E, R, B, E2, R2>(
+  guard: Guard<I, O, E, R>,
   f: (o: O) => Effect.Effect<B, E2, R2>
-): Guard<I, R | R2, E | E2, O> {
+): Guard<I, O, E | E2, R | R2> {
   return compose(guard, (o) => Effect.as(f(o), Option.some(o)))
 })
 
@@ -101,11 +101,11 @@ export const tap: {
  * @since 1.18.0
  */
 export const filterMap: {
-  <O, B>(f: (o: O) => Option.Option<B>): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, B>
-  <I, R, E, O, B>(guard: Guard<I, R, E, O>, f: (o: O) => Option.Option<B>): Guard<I, R, E, B>
+  <O, B>(f: (o: O) => Option.Option<B>): <I, R, E>(guard: Guard<I, O, E, R>) => Guard<I, B, E, R>
+  <I, O, E, R, B>(guard: Guard<I, O, E, R>, f: (o: O) => Option.Option<B>): Guard<I, B, E, R>
 } = dual(
   2,
-  <I, R, E, O, B>(guard: Guard<I, R, E, O>, f: (o: O) => Option.Option<B>): Guard<I, R, E, B> => (i) =>
+  <I, O, E, R, B>(guard: Guard<I, O, E, R>, f: (o: O) => Option.Option<B>): Guard<I, B, E, R> => (i) =>
     Effect.map(guard(i), Option.filterMap(f))
 )
 
@@ -113,13 +113,13 @@ export const filterMap: {
  * @since 1.18.0
  */
 export const filter: {
-  <O, O2 extends O>(predicate: (o: O) => o is O2): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, O2>
-  <O>(predicate: (o: O) => boolean): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R, E, O>
-  <I, R, E, O, O2 extends O>(guard: Guard<I, R, E, O>, predicate: (o: O) => o is O2): Guard<I, R, E, O2>
-  <I, R, E, O>(guard: Guard<I, R, E, O>, predicate: (o: O) => boolean): Guard<I, R, E, O>
+  <O, O2 extends O>(predicate: (o: O) => o is O2): <I, R, E>(guard: Guard<I, O, E, R>) => Guard<I, O, E, R>
+  <O>(predicate: (o: O) => boolean): <I, R, E>(guard: Guard<I, O, E, R>) => Guard<I, O, E, R>
+  <I, O, E, R, O2 extends O>(guard: Guard<I, O, E, R>, predicate: (o: O) => o is O2): Guard<I, O, E, R>
+  <I, O, E, R>(guard: Guard<I, O, E, R>, predicate: (o: O) => boolean): Guard<I, O, E, R>
 } = dual(
   2,
-  <I, R, E, O>(guard: Guard<I, R, E, O>, predicate: (o: O) => boolean): Guard<I, R, E, O> => (i) =>
+  <I, O, E, R>(guard: Guard<I, O, E, R>, predicate: (o: O) => boolean): Guard<I, O, E, R> => (i) =>
     Effect.map(guard(i), Option.filter(predicate))
 )
 
@@ -128,7 +128,7 @@ export const filter: {
  */
 export function any<const GS extends Readonly<Record<string, Guard<any, any, any, any>>>>(
   guards: GS
-): Guard<AnyInput<GS>, Guard.Context<GS[keyof GS]>, Guard.Context<GS[keyof GS]>, AnyOutput<GS>> {
+): Guard<AnyInput<GS>, AnyOutput<GS>, Guard.Error<GS[keyof GS]>, Guard.Context<GS[keyof GS]>> {
   const entries = Object.entries(guards)
   return (i: AnyInput<GS>) =>
     Effect.gen(function*(_) {
@@ -163,8 +163,8 @@ export type AnyOutput<GS extends Readonly<Record<string, Guard<any, any, any, an
 /**
  * @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> {
+export function liftPredicate<A, B extends A>(predicate: Predicate.Refinement<A, B>): Guard<A, B>
+export function liftPredicate<A>(predicate: Predicate.Predicate<A>): Guard<A, A>
+export function liftPredicate<A>(predicate: Predicate.Predicate<A>): Guard<A, A> {
   return (a) => Effect.sync(() => (predicate(a) ? Option.some(a) : Option.none()))
 }

package/src/Idle.ts

@@ -112,7 +112,7 @@ export const defaultIdleScheduler: IdleScheduler = globalValue(
  * @since 1.18.0
  * @category combinators
  */
-export const withIdleScheduler: <R, E, B>(self: Effect.Effect<B, E, R>) => Effect.Effect<B, E, R> = Effect
+export const withIdleScheduler: <B, E, R>(self: Effect.Effect<B, E, R>) => Effect.Effect<B, E, R> = Effect
   .withScheduler(defaultIdleScheduler)
 
 /**
@@ -173,13 +173,13 @@ export const whileIdle = <R, E, R2, E2>(
  * Dequeue values and perform an Effect while the event loop is not busy with any other work.
  * @since 1.18.0
  */
-export function dequeueWhileIdle<A, R2, E2, B>(
+export function dequeueWhileIdle<A, B, E2, R2>(
   dequeue: Queue.Dequeue<A>,
   f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
 ): Effect.Effect<void, E2, R2 | Scope.Scope>
 
-export function dequeueWhileIdle<I, A, R2, E2, B>(
+export function dequeueWhileIdle<I, A, B, E2, R2>(
   dequeue: Context.Dequeue<I, A>,
   f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
@@ -191,7 +191,7 @@ export function dequeueWhileIdle<I = never, A = unknown, R2 = never, E2 = never,
   options?: IdleRequestOptions
 ): Effect.Effect<void, E2, I | R2 | Scope.Scope>
 
-export function dequeueWhileIdle<I, A, R2, E2, B>(
+export function dequeueWhileIdle<I, A, B, E2, R2>(
   dequeue: Context.Dequeue<I, A> | Queue.Dequeue<A>,
   f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions

package/src/Match.ts

@@ -33,49 +33,49 @@ export type MatcherTypeId = typeof MatcherTypeId
 /**
  * @since 1.18.0
  */
-export interface TypeMatcher<out R, out E, in out I, out O> {
+export interface TypeMatcher<I, O = never, E = never, R = never> {
   readonly _tag: "TypeMatcher"
 
-  readonly [MatcherTypeId]: Matcher.Variance<R, E, I, O>
+  readonly [MatcherTypeId]: Matcher.Variance<I, O, E, R>
 
   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.Fx<R3, E3, B>
-  ) => TypeMatcher<R | R2 | R3, E | E2 | E3, I, O | B>
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
+    onMatch: (value: RefSubject.RefSubject<A>) => Fx.Fx<B, E3, R3>
+  ) => TypeMatcher<I, O | B, E | E2 | E3, R | R2 | R3>
 
   readonly to: <R2 = never, E2 = never, A = never, B = never>(
-    guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
     onMatch: B
-  ) => TypeMatcher<R | R2, E | E2, I, O | B>
+  ) => TypeMatcher<I, O | B, E | E2, R | R2>
 
   readonly run: <R2 = never, E2 = never>(
-    input: Fx.Fx<R2, E2, I>
-  ) => Fx.Fx<R | R2 | Scope.Scope, E | E2, Option.Option<O>>
+    input: Fx.Fx<I, E2, R2>
+  ) => Fx.Fx<Option.Option<O>, E | E2, R | R2 | Scope.Scope>
 }
 
 /**
  * @since 1.18.0
  */
-export interface ValueMatcher<out R, out E, in out I, out O> extends Fx.Fx<R | Scope.Scope, E, Option.Option<O>> {
+export interface ValueMatcher<I, O = never, E = never, R = never> extends Fx.Fx<Option.Option<O>, E, R | Scope.Scope> {
   readonly _tag: "ValueMatcher"
 
-  readonly [MatcherTypeId]: Matcher.Variance<R, E, I, O>
+  readonly [MatcherTypeId]: Matcher.Variance<I, O, E, R>
 
-  readonly value: Fx.Fx<R, E, I>
+  readonly value: Fx.Fx<I, E, R>
 
-  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.Fx<R3, E3, B>
-  ) => ValueMatcher<R | R2 | R3, E | E2 | E3, I, O | B>
+  readonly when: <A, E2, R2, R3 = never, E3 = never, B = never>(
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
+    onMatch: (value: RefSubject.RefSubject<A>) => Fx.Fx<B, E3, R3>
+  ) => ValueMatcher<I, O | B, E | E2 | E3, R | R2 | R3>
 
-  readonly to: <R2, E2, A, B>(
-    guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
+  readonly to: <A, E2, R2, B>(
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
     onMatch: B
-  ) => ValueMatcher<R | R2, E | E2, I, O | B>
+  ) => ValueMatcher<I, O | B, E | E2, R | R2>
 
   readonly getOrElse: <R2 = never, E2 = never, B = never>(
-    f: () => Fx.Fx<R2, E2, B>
-  ) => Fx.Fx<R | R2 | Scope.Scope, E | E2, O | B>
+    f: () => Fx.Fx<B, E2, R2>
+  ) => Fx.Fx<O | B, E | E2, R | R2 | Scope.Scope>
 }
 
 /**
@@ -85,7 +85,7 @@ export namespace Matcher {
   /**
    * @since 1.18.0
    */
-  export interface Variance<R, E, I, O> {
+  export interface Variance<I, O, E, R> {
     readonly _R: (_: never) => R
     readonly _E: (_: never) => E
     readonly _I: (_: I) => unknown
@@ -96,13 +96,12 @@ export namespace Matcher {
 /**
  * @since 1.18.0
  */
-export const type = <I>(): TypeMatcher<never, never, I, never> =>
-  new TypeMatcherImpl<never, never, I, never>(Chunk.empty())
+export const type = <I>(): TypeMatcher<I> => new TypeMatcherImpl<I, never, never, never>(Chunk.empty())
 
 /**
  * @since 1.18.0
  */
-export const value = <R, E, I>(input: Fx.Fx<R, E, I>): ValueMatcher<R, E, I, never> =>
+export const value = <I, E = never, R = never>(input: Fx.Fx<I, E, R>): ValueMatcher<I, never, E, R> =>
   new ValueMatcherImpl(input, type<I>())
 
 // Internals
@@ -117,48 +116,48 @@ const variance: Matcher.Variance<any, any, any, any> = {
 class When<R, E, I, A, O> {
   constructor(
     readonly guard: (input: I) => Effect.Effect<Option.Option<A>, E, R>,
-    readonly onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R, E, O>
+    readonly onMatch: (value: RefSubject.RefSubject<A>) => Fx.Fx<O, E, R>
   ) {}
 }
 
 class Matched<R, E, I, A, O> {
   constructor(
     readonly when: When<R, E, I, A, O>,
-    readonly ref: RefSubject.RefSubject<never, never, A>,
+    readonly ref: RefSubject.RefSubject<A>,
     readonly fiber: Fiber.Fiber<unknown>,
     readonly interrupt: Effect.Effect<void>
   ) {}
 }
 
-class TypeMatcherImpl<R, E, I, O> implements TypeMatcher<R, E, I, O> {
+class TypeMatcherImpl<I, O, E, R> implements TypeMatcher<I, O, E, R> {
   readonly _tag = "TypeMatcher"
-  readonly [MatcherTypeId]: TypeMatcher<R, E, I, O>[MatcherTypeId] = variance as any
+  readonly [MatcherTypeId]: TypeMatcher<I, O, E, R>[MatcherTypeId] = variance as any
 
   constructor(readonly cases: Chunk.Chunk<When<any, any, I, any, any>>) {
     this.when = this.when.bind(this)
     this.run = this.run.bind(this)
   }
 
-  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.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))
+  when<A, E2, R2, R3 = never, E3 = never, B = never>(
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
+    onMatch: (value: RefSubject.RefSubject<A>) => Fx.Fx<B, E3, R3>
+  ): TypeMatcher<I, O | B, E | E2 | E3, R | R2 | R3> {
+    return new TypeMatcherImpl<I, O | B, E | E2 | E3, R | R2 | R3>(
+      Chunk.append(this.cases, new When<R | R2 | R3, E | E2 | E3, I, A, O | B>(getGuard(guard), onMatch))
     )
   }
 
-  to<R2, E2, A, B>(
-    guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
+  to<A, E2, R2, B>(
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
     onMatch: B
-  ): TypeMatcher<R | R2, E | E2, I, O | B> {
+  ): TypeMatcher<I, O | B, E | E2, R | R2> {
     return this.when(guard, () => Fx.succeed(onMatch))
   }
 
-  run<R2, E2>(input: Fx.Fx<R2, E2, I>): Fx.Fx<R | R2 | Scope.Scope, E | E2, Option.Option<O>> {
+  run<E2, R2>(input: Fx.Fx<I, E2, R2>): Fx.Fx<Option.Option<O>, E | E2, R | R2 | Scope.Scope> {
     const { cases } = this
 
-    return Fx.make<R | R2 | Scope.Scope, E | E2, Option.Option<O>>((sink) =>
+    return Fx.make<Option.Option<O>, E | E2, R | R2 | Scope.Scope>((sink) =>
       withScopedFork(
         (fork, parentScope) => {
           let previous: Matched<any, any, I, any, O>
@@ -182,7 +181,7 @@ class TypeMatcherImpl<R, E, I, O> implements TypeMatcher<R, E, I, O> {
                 // 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)
+                const endSignal = Subject.unsafeMake<void>(0)
 
                 // Run the case
                 const fiber = yield* _(
@@ -279,51 +278,51 @@ class TypeMatcherImpl<R, E, I, O> implements TypeMatcher<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>
+class ValueMatcherImpl<I, O, E, R> extends FxBase<Option.Option<O>, E, R | Scope.Scope>
+  implements ValueMatcher<I, O, E, R>
 {
   readonly _tag = "ValueMatcher"
-  readonly [MatcherTypeId]: ValueMatcher<R, E, I, O>[MatcherTypeId] = variance
+  readonly [MatcherTypeId]: ValueMatcher<I, O, E, R>[MatcherTypeId] = variance
 
-  constructor(readonly value: Fx.Fx<R, E, I>, readonly matcher: TypeMatcher<R, E, I, O>) {
+  constructor(readonly value: Fx.Fx<I, E, R>, readonly matcher: TypeMatcher<I, O, E, R>) {
     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>>) {
+  run<R2>(sink: Sink.Sink<Option.Option<O>, E, R2>) {
     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.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>(
+  when<A, E2, R2, R3 = never, E3 = never, B = never>(
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
+    onMatch: (value: RefSubject.RefSubject<A>) => Fx.Fx<B, E3, R3>
+  ): ValueMatcher<I, O | B, E | E2 | E3, R | R2 | R3> {
+    return new ValueMatcherImpl<I, O | B, E | E2 | E3, R | R2 | R3>(
       this.value,
       this.matcher.when(guard, onMatch)
     )
   }
 
-  to<R2, E2, A, B>(
-    guard: Guard<I, R2, E2, A> | AsGuard<I, R2, E2, A>,
+  to<A, E2, R2, B>(
+    guard: Guard<I, A, E2, R2> | AsGuard<I, A, E2, R2>,
     onMatch: B
-  ): ValueMatcher<R | R2, E | E2, I, O | B> {
+  ): ValueMatcher<I, O | B, E | E2, R | R2> {
     return this.when(guard, () => Fx.succeed(onMatch))
   }
 
-  getOrElse: ValueMatcher<R, E, I, O>["getOrElse"] = (f) => Fx.getOrElse(this.matcher.run(this.value), f)
+  getOrElse: ValueMatcher<I, O, E, R>["getOrElse"] = (f) => Fx.getOrElse(this.matcher.run(this.value), f)
 }
 
 /**
  * @since 1.18.0
  */
-export interface AsGuard<I, R, E, A> {
-  readonly asGuard: () => Guard<I, R, E, A>
+export interface AsGuard<I, A, E = never, R = never> {
+  readonly asGuard: () => Guard<I, A, E, R>
 }
 
-function getGuard<I, R, E, A>(guard: Guard<I, R, E, A> | AsGuard<I, R, E, A>): Guard<I, R, E, A> {
+function getGuard<I, A, E = never, R = never>(guard: Guard<I, A, E, R> | AsGuard<I, A, E, R>): Guard<I, A, E, R> {
   if (typeof guard === "function") return guard
   return guard.asGuard()
 }

package/src/Pull.ts

@@ -19,28 +19,27 @@ import type { Sink } from "./Sink.js"
  * An Effect which can be used to pull values of a Stream.
  * @since 1.18.0
  */
-export interface Pull<out R, out E, out A> extends Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> {}
+export interface Pull<out A, out E = never, out R = never> extends Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> {}
 
-function schedulePull<R, E, A, R2, R3>(
-  pull: Pull<R, E, A>,
+function schedulePull<A, E, R, R2, R3>(
+  pull: Pull<A, E, R>,
   f: (effect: Effect.Effect<unknown, never, R | R3>) => Effect.Effect<unknown, never, R2>,
-  sink: Sink<R3, E, A>
+  sink: Sink<A, E, R3>
 ): Effect.Effect<void, never, R2> {
   return Effect.asyncEffect<void, never, never, void, never, R2>((resume) =>
-    pull.pipe(
-      Effect.matchCauseEffect({
-        onFailure: (cause: Cause.Cause<Option.Option<E>>) =>
-          Cause.failureOrCause(cause).pipe(
-            Either.match({
-              onLeft: Option.match({
-                onNone: () => Effect.sync(() => resume(Effect.unit)),
-                onSome: (e: E) => sink.onFailure(Cause.fail(e))
-              }),
-              onRight: sink.onFailure
-            })
-          ),
-        onSuccess: (chunk) => Effect.forEach(chunk, sink.onSuccess)
-      }),
+    Effect.matchCauseEffect(pull, {
+      onFailure: (cause: Cause.Cause<Option.Option<E>>) =>
+        Cause.failureOrCause(cause).pipe(
+          Either.match({
+            onLeft: Option.match({
+              onNone: () => Effect.sync(() => resume(Effect.unit)),
+              onSome: (e: E) => sink.onFailure(Cause.fail(e))
+            }),
+            onRight: sink.onFailure
+          })
+        ),
+      onSuccess: (chunk: Chunk.Chunk<A>) => Effect.forEach(chunk, sink.onSuccess, { discard: true })
+    }).pipe(
       f,
       Effect.flatMap(() => Effect.sync(() => resume(Effect.unit)))
     )
@@ -53,20 +52,20 @@ function schedulePull<R, E, A, R2, R3>(
  * @since 1.18.0
  */
 export const schedule: {
-  <R2, R3, E, A>(
+  <R2, A, E, R3>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
-  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<unknown, never, R | R2 | R3>
+    sink: Sink<A, E, R3>
+  ): <R>(pull: Pull<A, E, R>) => Effect.Effect<unknown, never, R | R2 | R3>
 
-  <R, E, A, R2, R3>(
-    pull: Pull<R, E, A>,
+  <A, E, R, R2, R3>(
+    pull: Pull<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
+    sink: Sink<A, E, R3>
   ): Effect.Effect<unknown, never, R | R2 | R3>
-} = dual(3, function schedule<R, E, A, R2, R3>(
-  pull: Pull<R, E, A>,
+} = dual(3, function schedule<A, E, R, R2, R3>(
+  pull: Pull<A, E, R>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
-  sink: Sink<R3, E, A>
+  sink: Sink<A, E, R3>
 ): Effect.Effect<void, never, R | R2 | R3> {
   return schedulePull(pull, Effect.schedule(schedule), sink)
 })
@@ -77,20 +76,20 @@ export const schedule: {
  * @since 1.18.0
  */
 export const repeat: {
-  <R2, R3, E, A>(
+  <R2, A, E, R3>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
-  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<unknown, never, R | R2 | R3>
+    sink: Sink<A, E, R3>
+  ): <R>(pull: Pull<A, E, R>) => Effect.Effect<unknown, never, R | R2 | R3>
 
-  <R, E, A, R2, R3>(
-    pull: Pull<R, E, A>,
+  <A, E, R, R2, R3>(
+    pull: Pull<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
+    sink: Sink<A, E, R3>
   ): Effect.Effect<unknown, never, R | R2 | R3>
-} = dual(3, function repeat<R, E, A, R2, R3>(
-  pull: Pull<R, E, A>,
+} = dual(3, function repeat<A, E, R, R2, R3>(
+  pull: Pull<A, E, R>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
-  sink: Sink<R3, E, A>
+  sink: Sink<A, E, R3>
 ): Effect.Effect<void, never, R | R2 | R3> {
   return schedulePull(pull, Effect.repeat(schedule), sink)
 })