@typed/fx 1.22.2 → 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<R, E, Option.Option<O>>
+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>(
-    f: (o: O) => Effect.Effect<R2, E2, B>
-  ): <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<R2, E2, B>): Guard<I, R | R2, E | E2, B>
-} = dual(2, function mapEffect<I, R, E, O, R2, E2, B>(
-  guard: Guard<I, R, E, O>,
-  f: (o: O) => Effect.Effect<R2, E2, B>
-): Guard<I, R | R2, E | E2, B> {
+  <O, B, E2, R2>(
+    f: (o: O) => Effect.Effect<B, E2, R2>
+  ): <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, 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>(
-    f: (o: O) => Effect.Effect<R2, E2, B>
-  ): <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<R2, E2, B>): Guard<I, R | R2, E | E2, O>
-} = dual(2, function tap<I, R, E, O, R2, E2, B>(
-  guard: Guard<I, R, E, O>,
-  f: (o: O) => Effect.Effect<R2, E2, B>
-): Guard<I, R | R2, E | E2, O> {
+  <O, B, E2, R2>(
+    f: (o: O) => Effect.Effect<B, E2, R2>
+  ): <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, 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<R, E, B>) => Effect.Effect<R, E, B> = Effect
+export const withIdleScheduler: <B, E, R>(self: Effect.Effect<B, E, R>) => Effect.Effect<B, E, R> = Effect
   .withScheduler(defaultIdleScheduler)
 
 /**
@@ -120,14 +120,14 @@ export const withIdleScheduler: <R, E, B>(self: Effect.Effect<R, E, B>) => Effec
  * @since 1.18.0
  * @category layers
  */
-export const setIdleScheduler: Layer.Layer<never, never, never> = Layer.setScheduler(defaultIdleScheduler)
+export const setIdleScheduler: Layer.Layer<never> = Layer.setScheduler(defaultIdleScheduler)
 
 /**
  * Request to run some work with requestIdleCallback returning an IdleDeadline
  * @since 1.18.0
  * @category scoped
  */
-export const whenIdle = (options?: IdleRequestOptions): Effect.Effect<Scope.Scope, never, IdleDeadline> =>
+export const whenIdle = (options?: IdleRequestOptions): Effect.Effect<IdleDeadline, never, Scope.Scope> =>
   Effect.asyncEffect((resume) => {
     const id = requestIdleCallback((deadline) => resume(Effect.succeed(deadline)), options)
 
@@ -148,8 +148,8 @@ export function shouldContinue(deadline: IdleDeadline): boolean {
  * @category params
  */
 export interface WhileIdleRequestOptions<R, E, R2, E2> extends IdleRequestOptions {
-  readonly while: Effect.Effect<R, E, boolean>
-  readonly body: Effect.Effect<R2, E2, unknown>
+  readonly while: Effect.Effect<boolean, E, R>
+  readonly body: Effect.Effect<unknown, E2, R2>
 }
 
 /**
@@ -158,7 +158,7 @@ export interface WhileIdleRequestOptions<R, E, R2, E2> extends IdleRequestOption
  */
 export const whileIdle = <R, E, R2, E2>(
   options: WhileIdleRequestOptions<R, E, R2, E2>
-): Effect.Effect<Scope.Scope | R | R2, E | E2, void> =>
+): Effect.Effect<void, E | E2, Scope.Scope | R | R2> =>
   Effect.gen(function*(_) {
     while (yield* _(options.while)) {
       const deadline = yield* _(whenIdle(options))
@@ -173,29 +173,29 @@ 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<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<R2 | Scope.Scope, E2, void>
+): 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<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<I | R2 | Scope.Scope, E2, void>
+): Effect.Effect<void, E2, I | R2 | Scope.Scope>
 
 export function dequeueWhileIdle<I = never, A = unknown, R2 = never, E2 = never, B = unknown>(
   dequeue: Context.Dequeue<I, A> | Queue.Dequeue<A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<I | R2 | Scope.Scope, E2, void>
+): 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<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<I | R2 | Scope.Scope, E2, void> {
+): Effect.Effect<void, E2, I | R2 | Scope.Scope> {
   return whileIdle({
     while: dequeueIsActive(dequeue),
     body: Effect.flatMap(dequeue.take, f),
@@ -209,10 +209,10 @@ export function dequeueWhileIdle<I, A, R2, E2, B>(
 export interface IdleQueue<I> {
   readonly add: <R>(
     part: I,
-    task: Effect.Effect<R, never, unknown>
-  ) => Effect.Effect<R | Scope.Scope, never, void>
+    task: Effect.Effect<unknown, never, R>
+  ) => Effect.Effect<void, never, R | Scope.Scope>
 
-  readonly interrupt: Effect.Effect<never, never, void>
+  readonly interrupt: Effect.Effect<void>
 }
 
 /**
@@ -220,20 +220,20 @@ export interface IdleQueue<I> {
  */
 export const makeIdleQueue = <I>(
   options?: IdleRequestOptions
-): Effect.Effect<Scope.Scope, never, IdleQueue<I>> =>
+): Effect.Effect<IdleQueue<I>, never, Scope.Scope> =>
   withScope((scope) => Effect.sync(() => new IdleQueueImpl<I>(scope, options)), ExecutionStrategy.sequential)
 
 class IdleQueueImpl<I> implements IdleQueue<I> {
-  queue = new Map<I, Effect.Effect<never, never, unknown>>()
+  queue = new Map<I, Effect.Effect<unknown>>()
   scheduled = false
 
-  readonly interrupt: Effect.Effect<never, never, void>
-  readonly scheduleNextRun: Effect.Effect<never, never, void>
+  readonly interrupt: Effect.Effect<void>
+  readonly scheduleNextRun: Effect.Effect<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(
+    const run: Effect.Effect<void, never, Scope.Scope> = Effect.flatMap(
       whenIdle(this.options),
       (deadline) =>
         Effect.gen(this, function*(_) {
@@ -274,7 +274,7 @@ class IdleQueueImpl<I> implements IdleQueue<I> {
     )
   }
 
-  add = <R>(part: I, task: Effect.Effect<R, never, unknown>) =>
+  add = <R>(part: I, task: Effect.Effect<unknown, never, R>) =>
     Effect.contextWithEffect((ctx: Context.Context<R>) => {
       const provided = Effect.provide(task, ctx)
       this.queue.set(part, provided)

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
@@ -116,49 +115,49 @@ 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.Fx<R, E, O>
+    readonly guard: (input: I) => Effect.Effect<Option.Option<A>, E, R>,
+    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 fiber: Fiber.Fiber<never, unknown>,
-    readonly interrupt: Effect.Effect<never, never, void>
+    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()
 }