@typed/fx 1.18.4 → 1.20.0

package/src/internal/core.ts

@@ -1,2198 +1,2739 @@
-import type { Exit } from "effect"
-import {
-  Cause,
-  Chunk,
-  Deferred,
-  Effect,
-  Effectable,
-  Either,
-  Equal,
-  Fiber,
-  Layer,
-  Option,
-  Ref,
-  Scope,
-  Stream,
-  SynchronizedRef
+import * as Context from "@typed/context"
+import type {
+  ConfigProvider,
+  Duration,
+  Equivalence,
+  FiberId,
+  FiberRef,
+  HashSet,
+  Queue,
+  Request,
+  Runtime,
+  Schedule,
+  Scheduler
 } from "effect"
-
-import { dual, identity } from "effect/Function"
-
-import { type Context, isContext, type Tag } from "@typed/context"
-import * as Schedule from "effect/Schedule"
+import * as Boolean from "effect/Boolean"
+import * as Cause from "effect/Cause"
+import * as Clock from "effect/Clock"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
+import * as Equal from "effect/Equal"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import { constFalse, constTrue } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
+import * as Ref from "effect/Ref"
+import * as Scope from "effect/Scope"
+import * as Tracer from "effect/Tracer"
+import type { FlattenStrategy, Fx, FxFork, MergeStrategy } from "../Fx.js"
+import * as Sink from "../Sink.js"
+import type { Bounds } from "./bounds.js"
+import { boundsFrom, isInfiniteBounds, isNilBounds, mergeBounds } from "./bounds.js"
+import * as EffectLoopOp from "./effect-loop-operator.js"
+import * as EffectOp from "./effect-operator.js"
+import * as EffectProducer from "./effect-producer.js"
 import {
-  compileEffectLoop,
-  FilterEffect,
-  FilterMapEffect,
-  liftSyncOperator,
-  MapEffect,
-  TapEffect
-} from "./effect-operator.js"
-import * as helpers from "./helpers.js"
+  adjustTime,
+  matchEffectPrimitive,
+  tupleSink,
+  withBuffers,
+  withFlattenStrategy,
+  withScopedFork
+} from "./helpers.js"
+import * as SyncLoopOp from "./loop-operator.js"
+import * as Op from "./operator.js"
+import { EffectBase, FxBase } from "./protos.js"
 import * as Provide from "./provide.js"
-import * as strategies from "./strategies.js"
-import { compileSyncReducer, Filter, FilterMap, Map } from "./sync-operator.js"
+import { Bounded, Exhaust, ExhaustLatest, Ordered, Switch, Unbounded, Unordered } from "./strategies.js"
+import * as SyncOp from "./sync-operator.js"
+import * as SyncProducer from "./sync-producer.js"
+
+const DISCARD = { discard: true } as const
+const UNBOUNDED = { concurrency: "unbounded" } as const
+
+// TODO: Optimizations for take/drop and variants
+// TODO: Slice optimizations on synchronous producers
+// TODO: Error/Cause operator fusion
+// TODO: Double-check other optimiation opportunities
+// TODO: expose FxBase and FxEffectBase
+
+export function make<A>(
+  run: (sink: Sink.Sink<never, never, A>) => Effect.Effect<never, never, unknown>
+): Fx<never, never, A>
+export function make<E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<never, never, unknown>): Fx<never, E, A>
+export function make<R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<R, never, unknown>): Fx<R, E, A>
+export function make<R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<R, never, unknown>): Fx<R, E, A> {
+  return new Make(run)
+}
 
-import type { DurationInput } from "effect/Duration"
-import type { Equivalence } from "effect/Equivalence"
-import type { Runtime } from "effect/Runtime"
-import * as Emitter from "../Emitter.js"
-import type {
-  FlattenStrategy,
-  Fx,
-  FxInput,
-  MergeStrategy,
-  WithEarlyExitParams,
-  WithFlattenStrategyParams,
-  WithScopedForkParams
-} from "../Fx.js"
-import * as Sink from "../Sink.js"
-import { type Bounds, boundsFrom, mergeBounds } from "./bounds.js"
-import { type InternalEffect, matchEffectPrimitive } from "./effect-primitive.js"
-import {
-  Empty,
-  Fail,
-  FromIterable,
-  FromSink,
-  Never,
-  Succeed,
-  Suspend,
-  Sync,
-  ToFx,
-  Transformer,
-  TransformerCause,
-  TransformerEffect,
-  WithEarlyExit,
-  WithFlattenStrategy,
-  WithScopedFork
-} from "./fx-primitive.js"
-import { adjustTime } from "./helpers.js"
-import { matchFxInput } from "./matchers.js"
-import { OnceEffect } from "./protos.js"
-import { run } from "./run.js"
+class Make<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly _run: Fx<R, E, A>["run"]) {
+    super()
+  }
 
-const constUnit = () => Effect.unit
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return Effect.contextWithEffect((ctx) => this._run(Sink.provide(sink, ctx)))
+  }
+}
 
-class Merge<R, E, A> extends ToFx<R, E, A> {
-  constructor(readonly i0: ReadonlyArray<Fx<R, E, A>>, readonly i1: MergeStrategy) {
-    super(i0, i1)
+class Producer<A> extends FxBase<never, never, A> {
+  constructor(readonly i0: SyncProducer.SyncProducer<A>) {
+    super()
   }
 
-  static make<R, E, A>(fx: ReadonlyArray<Fx<R, E, A>>, strategy: MergeStrategy): Fx<R, E, A> {
-    // TODO: Flatten nested Merges
+  run<R2>(sink: Sink.Sink<R2, never, A>): Effect.Effect<R2, never, unknown> {
+    return SyncProducer.runSink(this.i0, sink)
+  }
+}
+/**
+ * @internal
+ */
+export function isProducer<R, E, A>(fx: Fx<R, E, A>): fx is Producer<A> {
+  return fx.constructor === Producer
+}
 
-    if (fx.length === 0) return empty
-    const nonEmptyFx = fx.filter((fx) => !(fx instanceof Empty))
+export const succeed = <A>(value: A): Fx<never, never, A> => new Producer(SyncProducer.Success(value))
 
-    if (nonEmptyFx.length === 0) return empty
-    if (nonEmptyFx.length === 1) return nonEmptyFx[0]
+export const fromSync = <A>(f: () => A): Fx<never, never, A> => new Producer(SyncProducer.FromSync(f))
 
-    const neverIndex = nonEmptyFx.findIndex((fx) => fx instanceof Never)
+export const fromArray = <const A extends ReadonlyArray<any>>(array: A): Fx<never, never, A[number]> =>
+  new Producer(SyncProducer.FromArray(array))
 
-    if (neverIndex === -1) return new Merge(nonEmptyFx, strategy)
+export const fromIterable = <A>(iterable: Iterable<A>): Fx<never, never, A> =>
+  new Producer(SyncProducer.FromIterable(iterable))
 
-    switch (strategy._tag) {
-      case "Switch":
-      case "Ordered":
-        // Will only emit up to the first Never
-        return new Merge(nonEmptyFx.slice(0, neverIndex + 1), strategy)
-      // No use creating fibers for Fx that don't emit
-      case "Unordered":
-        return new Merge(nonEmptyFx, strategy)
-    }
+class ProducerEffect<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: EffectProducer.EffectProducer<R, E, A>) {
+    super()
   }
 
-  toFx(): Fx<R, E, A> {
-    const { i0, i1 } = this
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return EffectProducer.runSink(this.i0, sink)
+  }
+}
 
-    switch (i1._tag) {
-      case "Ordered": {
-        const concurrency = i1.concurrency === Infinity ? "unbounded" : i1.concurrency
+/**
+ * @internal
+ */
+export function isProducerEffect<R, E, A>(fx: Fx<R, E, A>): fx is ProducerEffect<R, E, A> {
+  return fx.constructor === ProducerEffect
+}
 
-        return fromSink((sink) => (
-          Effect.flatMap(helpers.withBuffers(i0.length, sink), (buffers) =>
-            Effect.all(
-              i0.map((fx, i) =>
-                Effect.flatMap(
-                  run(
-                    fx,
-                    Sink.WithContext(
-                      (cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause),
-                      (a) => buffers.onSuccess(i, a)
-                    )
-                  ),
-                  () => buffers.onEnd(i)
-                )
-              ),
-              {
-                concurrency
-              }
-            ))
-        ))
-      }
-      case "Switch":
-        return fromSink((sink) => Effect.all(i0.map((fx) => run(fx, sink)), { concurrency: 1 }))
-      case "Unordered":
-        return fromSink((sink) =>
-          Effect.all(i0.map((fx) => run(fx, sink)), {
-            concurrency: i1.concurrency === Infinity ? "unbounded" : i1.concurrency
-          })
-        )
-    }
+export const fromEffect = <R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> =>
+  matchEffectPrimitive<R, E, A, Fx<R, E, A>>(effect, {
+    // Match over Effect primitives and return Fx primitives to allow fusion to take place
+    Success: succeed,
+    Failure: failCause,
+    Sync: fromSync,
+    Left: fail,
+    Right: succeed,
+    Some: succeed,
+    None: fail,
+    Otherwise: (effect) => new ProducerEffect(EffectProducer.FromEffect(effect))
+  })
+
+export const fromScheduled = <R, E, I, R2, O>(
+  input: Effect.Effect<R, E, I>,
+  schedule: Schedule.Schedule<R2, I, O>
+): Fx<R | R2, E, O> => new ProducerEffect(EffectProducer.FromScheduled(input, schedule))
+
+export const schedule = <R, E, A, R2, O>(
+  input: Effect.Effect<R, E, A>,
+  schedule: Schedule.Schedule<R2, unknown, O>
+): Fx<R | R2, E, A> => new ProducerEffect(EffectProducer.Scheduled(input, schedule))
+
+class FailCause<E> extends FxBase<never, E, never> {
+  constructor(readonly i0: Cause.Cause<E>) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, E, never>): Effect.Effect<R2, never, unknown> {
+    return sink.onFailure(this.i0)
   }
 }
 
-class Slice<R, E, A> extends ToFx<R, E, A> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: Bounds
-  ) {
-    super(i0, i1)
+/**
+ * @internal
+ */
+export function isFailCause<R, E, A>(fx: Fx<R, E, A>): fx is FailCause<E> {
+  return fx.constructor === FailCause
+}
+
+export const failCause = <E>(cause: Cause.Cause<E>): Fx<never, E, never> => new FailCause(cause)
+
+export const fail = <E>(error: E): Fx<never, E, never> => failCause(Cause.fail(error))
+
+export const die = (error: unknown): Fx<never, never, never> => failCause(Cause.die(error))
+
+class Transformer<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: Fx<R, E, any>, readonly i1: Op.Operator) {
+    super()
   }
 
-  static make<R, E, A>(fx: Fx<R, E, A>, bounds: Bounds): Fx<R, E, A> {
-    if (fx instanceof Slice) {
-      return new Slice(fx.i0, mergeBounds(fx.i1, bounds))
-    } else if (fx instanceof Transformer && fx.i1._tag === "Map") {
-      return new Transformer(Slice.make(fx.i0, bounds), fx.i1)
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0.run(Op.compileOperatorSink(this.i1, sink))
+  }
+
+  static make<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, operator: Op.Operator): Fx<R | R2, E | E2, B> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else if (isProducer(fx)) {
+      return new ProducerSyncTransformer(fx.i0, operator)
+    } else if (isTransformer(fx)) {
+      return new Transformer(fx.i0, Op.fuseOperators(fx.i1, operator))
+    } else if (isProducerSyncTransformer(fx)) {
+      return new ProducerSyncTransformer(fx.i0, Op.fuseOperators(fx.i1, operator))
+    } else if (isProducerEffect(fx)) {
+      return new ProducerEffectTransformer(fx.i0, operator)
+    } else if (isProducerEffectTransformer(fx)) {
+      return new ProducerEffectTransformer(fx.i0, Op.fuseOperators(fx.i1, operator))
+    } else if (isSuspend(fx)) {
+      return new SuspendedTransformer(fx.i0, operator)
+    } else if (isSuspendedTransformer(fx)) {
+      return new SuspendedTransformer(fx.i0, Op.fuseOperators(fx.i1, operator))
+    } else if (isFailCause(fx)) {
+      return fx
     } else {
-      return new Slice(fx, bounds)
+      return new Transformer<R, E, B>(fx, operator)
     }
   }
+}
 
-  toFx(): Fx<R, E, A> {
-    const fx = this.i0
-    const { max, min } = this.i1
-
-    return withEarlyExit(({ sink }) =>
-      Effect.suspend(() => {
-        let toSkip = min
-        let toTake = max
-
-        return run(
-          fx,
-          Sink.WithContext(sink.onFailure, (a) =>
-            Effect.suspend(() => {
-              if (toSkip > 0) {
-                toSkip -= 1
-                return Effect.unit
-              } else if (toTake > 0) {
-                toTake -= 1
-                return Effect.flatMap(sink.onSuccess(a), () => toTake <= 0 ? sink.earlyExit : Effect.unit)
-              } else {
-                return sink.earlyExit
-              }
-            }))
-        )
-      })
-    )
-  }
+/**
+ * @internal
+ */
+export function isTransformer<R, E, A>(fx: Fx<R, E, A>): fx is Transformer<R, E, A> {
+  return fx.constructor === Transformer
 }
 
-class Loop<R, E, A, B, C> extends ToFx<R, E, C> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (b: B, a: A) => readonly [C, B],
-    readonly i2: B
-  ) {
-    super(i0, i1, i2)
+class ProducerSyncTransformer<R, E, A> extends FxBase<R, E, A> implements Fx<R, E, A> {
+  constructor(readonly i0: SyncProducer.SyncProducer<any>, readonly i1: Op.Operator) {
+    super()
   }
 
-  static make<R, E, A, B, C>(fx: Fx<R, E, A>, b: B, f: (b: B, a: A) => readonly [C, B]): Fx<R, E, C> {
-    if (fx instanceof Transformer) {
-      return FilterMapLoop.make(fx.i0 as Fx<R, E, any>, b, compileSyncReducer(fx.i1, f))
-    } else if (fx instanceof TransformerEffect) {
-      return new FilterMapLoopEffect(
-        fx.i0 as Fx<R, E, any>,
-        b,
-        compileEffectLoop(fx.i1, (b: B, a: A) => Effect.sync(() => f(b, a)))
-      )
-    } else {
-      return new Loop(fx, f, b)
-    }
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return SyncProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink))
   }
+}
 
-  toFx(): Fx<R, E, C> {
-    return fromSink((sink) =>
-      Effect.suspend(() => {
-        let acc = this.i2
+/**
+ * @internal
+ */
+export function isProducerSyncTransformer<R, E, A>(fx: Fx<R, E, A>): fx is ProducerSyncTransformer<R, E, A> {
+  return fx.constructor === ProducerSyncTransformer
+}
 
-        return run(
-          this.i0,
-          Sink.WithContext(
-            sink.onFailure,
-            (a) =>
-              Effect.suspend(() => {
-                const [c, b] = this.i1(acc, a)
+export const map = <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> => Transformer.make(fx, SyncOp.Map(f))
 
-                acc = b
+export const filter = <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A> =>
+  Transformer.make(fx, SyncOp.Filter(f))
 
-                return sink.onSuccess(c)
-              })
-          )
-        )
-      })
-    )
-  }
-}
+export const filterMap = <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B> =>
+  Transformer.make(fx, SyncOp.FilterMap(f))
 
-class FilterMapLoop<R, E, A, B, C> extends ToFx<R, E, C> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: B,
-    readonly i2: (b: B, a: A) => Option.Option<readonly [C, B]>
-  ) {
-    super(i0, i1, i2)
-  }
+export const mapEffect = <R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>
+): Fx<R | R2, E | E2, B> => Transformer.make(fx, EffectOp.MapEffect(f))
 
-  static make<R, E, A, B, C>(
-    fx: Fx<R, E, A>,
-    b: B,
-    f: (b: B, a: A) => Option.Option<readonly [C, B]>
-  ): Fx<R, E, C> {
-    return new FilterMapLoop(fx, b, f)
-  }
+export const filterMapEffect = <R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+): Fx<R | R2, E | E2, B> => Transformer.make(fx, EffectOp.FilterMapEffect(f))
 
-  toFx(): Fx<R, E, C> {
-    return fromSink((sink) =>
-      Effect.suspend(() => {
-        let acc = this.i1
+export const filterEffect = <R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, boolean>
+): Fx<R | R2, E | E2, A> => Transformer.make(fx, EffectOp.FilterEffect(f))
 
-        return run(
-          this.i0,
-          Sink.WithContext(
-            sink.onFailure,
-            (a) =>
-              Effect.suspend(() => {
-                const optionCB = this.i2(acc, a)
+export const tapEffect = <R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, unknown>
+): Fx<R | R2, E | E2, A> => Transformer.make(fx, EffectOp.TapEffect(f))
 
-                if (Option.isNone(optionCB)) return Effect.unit
+export const loop = <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<R, E, C> =>
+  Transformer.make(fx, SyncLoopOp.LoopOperator(seed, f))
 
-                const [c, b] = optionCB.value
-                acc = b
+export const withPrevious = <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, readonly [Option.Option<A>, A]> =>
+  loop(fx, Option.none<A>(), (acc, a) => [[acc, a], Option.some(a)] as const)
 
-                return sink.onSuccess(c)
-              })
-          )
-        )
-      })
-    )
-  }
-}
+export const filterMapLoop = <R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (acc: B, a: A) => readonly [Option.Option<C>, B]
+): Fx<R, E, C> => Transformer.make(fx, SyncLoopOp.FilterMapLoopOperator(seed, f))
 
-class LoopEffect<R, E, A, R2, E2, B, C> extends ToFx<R | R2, E | E2, C> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (b: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>,
-    readonly i2: B
-  ) {
-    super(i0, i1, i2)
-  }
+export const loopEffect = <R, E, A, R2, E2, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
+): Fx<R | R2, E | E2, C> => Transformer.make(fx, EffectLoopOp.LoopEffectOperator(seed, f))
 
-  static make<R, E, A, R2, E2, B, C>(
-    fx: Fx<R, E, A>,
-    f: (b: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>,
-    b: B
-  ): Fx<R | R2, E | E2, C> {
-    if (fx instanceof TransformerEffect) {
-      return new FilterMapLoopEffect(fx.i0 as Fx<R, E, any>, b, compileEffectLoop(fx.i1, f))
-    } else if (fx instanceof Transformer) {
-      return new FilterMapLoopEffect(fx.i0 as Fx<R, E, any>, b, compileEffectLoop(liftSyncOperator(fx.i1), f))
-    } else {
-      return new LoopEffect(fx, f, b)
-    }
-  }
+export const filterMapLoopEffect = <R, E, A, R2, E2, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>
+): Fx<R | R2, E | E2, C> => Transformer.make(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f))
 
-  toFx(): Fx<R | R2, E | E2, C> {
-    const { i0, i1, i2 } = this
-
-    return fromSink((sink) =>
-      Effect.flatMap(SynchronizedRef.make(i2), (ref) =>
-        run(
-          i0,
-          Sink.WithContext(sink.onFailure, (a) =>
-            SynchronizedRef.updateEffect(ref, (b) =>
-              Effect.matchCauseEffect(i1(b, a), {
-                onFailure: (cause) => Effect.as(sink.onFailure(cause), b),
-                onSuccess: ([c, b2]: readonly [C, B]) => Effect.as(sink.onSuccess(c), b2)
-              })))
-        ))
-    )
-  }
-}
+export const observe = <R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>
+): Effect.Effect<R | R2, E | E2, void> => Observe.make(fx, f)
+
+const constUnit = () => Effect.unit
+
+export const drain = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, void> => Observe.make(fx, constUnit)
 
-class FilterMapLoopEffect<R, E, A, R2, E2, B, C> extends ToFx<R | R2, E | E2, C> {
+class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
   constructor(
     readonly i0: Fx<R, E, A>,
-    readonly i1: B,
-    readonly i2: (b: B, a: A) => Effect.Effect<R2, E2, Option.Option<readonly [C, B]>>
+    readonly i1: (a: A) => Effect.Effect<R2, E2, B>
   ) {
-    super(i0, i1, i2)
+    super()
   }
 
-  toFx(): Fx<R | R2, E | E2, C> {
-    return fromSink((sink) =>
-      Effect.suspend(() => {
-        let acc = this.i1
-
-        return run(
-          this.i0,
-          Sink.WithContext(
-            sink.onFailure,
-            (a) =>
-              this.i2(acc, a).pipe(
-                Effect.matchCauseEffect({
-                  onFailure: sink.onFailure,
-                  onSuccess: (optionCB) =>
-                    Effect.suspend(() => {
-                      if (Option.isNone(optionCB)) return Effect.unit
-
-                      const [c, b] = optionCB.value
-                      acc = b
-
-                      return sink.onSuccess(c)
-                    })
-                })
-              )
-          )
-        )
-      })
-    )
-  }
-}
+  toEffect(): Effect.Effect<R | R2, E | E2, void> {
+    return Effect.asyncEffect((resume) => {
+      const { i0: fx, i1: f } = this
+      const onFailure = (cause: Cause.Cause<E | E2>) => Effect.sync(() => resume(Effect.failCause(cause)))
 
-class FxProvide<R, E, A, R2, E2, B> extends ToFx<Exclude<R, B> | R2, E | E2, A> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: Provide.Provide<R2, E2, B>
-  ) {
-    super(i0, i1)
+      return Effect.zipRight(
+        fx.run(Sink.make(onFailure, (a) => Effect.catchAllCause(f(a), onFailure))),
+        Effect.sync(() => resume(Effect.unit))
+      )
+    })
   }
 
   static make<R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    provide: Provide.Provide<R2, E2, B>
-  ): Fx<Exclude<R, B> | R2, E | E2, A> {
-    if (fx instanceof FxProvide) {
-      return new FxProvide(fx.i0, Provide.merge(fx.i1, provide))
+    f: (a: A) => Effect.Effect<R2, E2, B>
+  ): Effect.Effect<R | R2, E | E2, void> {
+    if (isEmpty(fx)) {
+      return Effect.unit
+    } else if (isNever(fx)) {
+      return Effect.never
+    } else if (isProducer(fx)) {
+      return SyncProducer.runEffect(fx.i0, f)
+    } else if (isProducerSyncTransformer(fx)) {
+      return Op.matchOperator(fx.i1, {
+        SyncOperator: (op): Effect.Effect<R | R2, E | E2, void> =>
+          SyncOp.matchSyncOperator(op, {
+            Map: (op): Effect.Effect<R | R2, E | E2, void> =>
+              SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
+            Filter: (op) =>
+              SyncProducer.effectOnce(() =>
+                SyncProducer.runEffect(fx.i0, Effect.unifiedFn((a) => op.f(a) ? f(a) : Effect.unit))
+              ),
+            FilterMap: (op) =>
+              SyncProducer.effectOnce(() =>
+                SyncProducer.runEffect(
+                  fx.i0,
+                  Effect.unifiedFn((a) => Option.match(op.f(a), { onNone: () => Effect.unit, onSome: f }))
+                )
+              )
+          }),
+        EffectOperator: (op) =>
+          EffectOp.matchEffectOperator(op, {
+            MapEffect: (op): Effect.Effect<R | R2, E | E2, void> =>
+              SyncProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
+            FilterMapEffect: (op) =>
+              SyncProducer.runEffect(fx.i0, (a) =>
+                Effect.flatMap(op.f(a), Effect.unifiedFn(Option.match({ onNone: () => Effect.unit, onSome: f })))),
+            FilterEffect: (op) =>
+              SyncProducer.runEffect(
+                fx.i0,
+                Effect.unifiedFn((a) =>
+                  Effect.flatMap(op.f(a), Effect.unifiedFn((b) => b ? f(a) : Effect.unit))
+                )
+              ),
+            TapEffect: (op) => SyncProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), () => f(a)))
+          }),
+        SyncLoopOperator: (op) =>
+          SyncLoopOp.matchSyncLoopOperator(op, {
+            Loop: (op) =>
+              SyncProducer.effectOnce(() =>
+                SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+                  const [c, b] = op.f(acc, a)
+                  return Effect.as(f(c), b)
+                })
+              ),
+            FilterMapLoop: (op) =>
+              SyncProducer.effectOnce(() =>
+                SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+                  const [c, b] = op.f(acc, a)
+                  return Option.match(c, { onNone: () => Effect.succeed(acc), onSome: (c) => Effect.as(f(c), b) })
+                })
+              )
+          }),
+        EffectLoopOperator: (op) =>
+          EffectLoopOp.matchEffectLoopOperator(op, {
+            LoopEffect: (op) =>
+              SyncProducer.runReduceEffect(
+                fx.i0,
+                op.seed,
+                (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Effect.as(f(c), b))
+              ),
+            FilterMapLoopEffect: (op) =>
+              SyncProducer.runReduceEffect(
+                fx.i0,
+                op.seed,
+                (acc, a) =>
+                  Effect.flatMap(op.f(acc, a), ([c, b]) =>
+                    Option.match(c, {
+                      onNone: () => Effect.succeed(b),
+                      onSome: (c) => Effect.as(f(c), b)
+                    }))
+              )
+          })
+      })
+    } else if (isProducerEffect(fx)) {
+      return EffectProducer.runEffect(fx.i0, f)
+    } else if (isProducerEffectTransformer(fx)) {
+      return Op.matchOperator(fx.i1, {
+        SyncOperator: (op): Effect.Effect<R | R2, E | E2, void> =>
+          SyncOp.matchSyncOperator(op, {
+            Map: (op): Effect.Effect<R | R2, E | E2, void> =>
+              SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
+            Filter: (op) =>
+              SyncProducer.effectOnce(() =>
+                EffectProducer.runEffect(fx.i0, Effect.unifiedFn((a) => op.f(a) ? f(a) : Effect.unit))
+              ),
+            FilterMap: (op) =>
+              SyncProducer.effectOnce(() =>
+                EffectProducer.runEffect(
+                  fx.i0,
+                  Effect.unifiedFn((a) => Option.match(op.f(a), { onNone: () => Effect.unit, onSome: f }))
+                )
+              )
+          }),
+        EffectOperator: (op) =>
+          EffectOp.matchEffectOperator(op, {
+            MapEffect: (op): Effect.Effect<R | R2, E | E2, void> =>
+              EffectProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
+            FilterMapEffect: (op) =>
+              EffectProducer.runEffect(fx.i0, (a) =>
+                Effect.flatMap(op.f(a), Effect.unifiedFn(Option.match({ onNone: () => Effect.unit, onSome: f })))),
+            FilterEffect: (op) =>
+              EffectProducer.runEffect(
+                fx.i0,
+                Effect.unifiedFn((a) =>
+                  Effect.flatMap(op.f(a), Effect.unifiedFn((b) => b ? f(a) : Effect.unit))
+                )
+              ),
+            TapEffect: (op) => EffectProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), () => f(a)))
+          }),
+        SyncLoopOperator: (op) =>
+          SyncLoopOp.matchSyncLoopOperator(op, {
+            Loop: (op) =>
+              SyncProducer.effectOnce(() =>
+                EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+                  const [c, b] = op.f(acc, a)
+                  return Effect.as(f(c), b)
+                })
+              ),
+            FilterMapLoop: (op) =>
+              SyncProducer.effectOnce(() =>
+                EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+                  const [c, b] = op.f(acc, a)
+                  return Option.match(c, { onNone: () => Effect.succeed(acc), onSome: (c) => Effect.as(f(c), b) })
+                })
+              )
+          }),
+        EffectLoopOperator: (op) =>
+          EffectLoopOp.matchEffectLoopOperator(op, {
+            LoopEffect: (op) =>
+              EffectProducer.runReduceEffect(
+                fx.i0,
+                op.seed,
+                (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Effect.as(f(c), b))
+              ),
+            FilterMapLoopEffect: (op) =>
+              EffectProducer.runReduceEffect(
+                fx.i0,
+                op.seed,
+                (acc, a) =>
+                  Effect.flatMap(op.f(acc, a), ([c, b]) =>
+                    Option.match(c, {
+                      onNone: () => Effect.succeed(b),
+                      onSome: (c) => Effect.as(f(c), b)
+                    }))
+              )
+          })
+      })
+    } else if (isFailCause(fx)) {
+      return Effect.failCause(fx.i0)
     } else {
-      return new FxProvide(fx, provide)
+      return new Observe(fx, f)
     }
   }
+}
 
-  protected toFx(): Fx<R2 | Exclude<R, B>, E | E2, A> {
-    return fromSink((sink) =>
-      Effect.catchAllCause(Provide.provideToEffect(run(this.i0, sink), this.i1), sink.onFailure)
-    )
+export const reduce = <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B> =>
+  Reduce.make(fx, seed, f)
+
+class Reduce<R, E, A, B> extends EffectBase<R, E, B> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: B, readonly i2: (acc: B, a: A) => B) {
+    super()
   }
-}
 
-class Snapshot<R, E, A, R2, E2, B, R3, E3, C> extends ToFx<R | R2 | R3, E | E2 | E3, C> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: FxInput<R2, E2, B>,
-    readonly i2: (a: A, b: B) => Effect.Effect<R3, E3, C>
-  ) {
-    super(i0, i1, i2)
-  }
-
-  toFx(): Fx<R | R2 | R3, E | E2 | E3, C> {
-    return matchFxInput(this.i1, {
-      RefSubject: (fx2) => this.runScoped(this.i0, fx2, this.i2),
-      Fx: (fx2) => this.runScoped(this.i0, fx2, this.i2),
-      Effect: (effect2) => mapEffect(this.i0, (a) => Effect.flatMap(effect2, (b) => this.i2(a, b))),
-      Cause: (cause2) =>
-        matchCause(this.i0, {
-          onFailure: (cause1) => Effect.failCause(Cause.sequential(cause1, cause2)),
-          onSuccess: () => Effect.failCause(cause2)
-        }),
-      Iterable: (iterable) =>
-        withEarlyExit(({ sink }) => {
-          const iterator = iterable[Symbol.iterator]()
-
-          return run(
-            this.i0,
-            Sink.WithContext(sink.onFailure, (a) => {
-              const result = iterator.next()
-              if (result.done) {
-                return sink.earlyExit
-              } else {
-                return Effect.matchCauseEffect(this.i2(a, result.value), sink)
-              }
-            })
-          )
-        }),
-      Otherwise: (b) => mapEffect(this.i0, (a) => this.i2(a, b))
+  toEffect(): Effect.Effect<R, E, B> {
+    return Effect.suspend(() => {
+      let acc = this.i1
+
+      return Effect.map(
+        observe(this.i0, (a) => Effect.sync(() => acc = this.i2(acc, a))),
+        () => acc
+      )
     })
   }
 
-  private runScoped<R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    fx2: Fx<R2, E2, B>,
-    f: (a: A, b: B) => Effect.Effect<R3, E3, C>
-  ): Fx<R | R2 | R3, E | E2 | E3, C> {
-    return withScopedFork(({ fork, sink }) =>
-      Effect.flatMap(Ref.make(Option.none<B>()), (ref) =>
-        Effect.flatMap(
-          fork(run(
-            fx2,
-            Sink.WithContext(
-              sink.onFailure,
-              (b) => Ref.set(ref, Option.some(b))
-            )
-          )),
-          () =>
-            adjustTime(1).pipe(Effect.zipRight(run(
-              fx,
-              Sink.WithContext(
-                sink.onFailure,
-                (a: A) =>
-                  Effect.flatten(Ref.get(ref)).pipe(
-                    Effect.flatMap((b: B) => Effect.matchCauseEffect(f(a, b), sink)),
-                    Effect.optionFromOptional,
-                    Effect.asUnit
-                  )
+  static make<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B) {
+    // TODO: optimize Effect trasformers
+
+    if (isEmpty(fx)) return Effect.succeed(seed)
+    else if (isProducer(fx)) {
+      return SyncProducer.runReduce(fx.i0, seed, f)
+    } else if (isProducerSyncTransformer(fx)) {
+      return Op.matchOperator(fx.i1, {
+        SyncOperator: (op) => SyncProducer.syncOnce(() => SyncOp.runSyncReduce(fx.i0, op, seed, f)),
+        EffectOperator: (op) => EffectOp.runSyncReduce(fx.i0, op, seed, f),
+        SyncLoopOperator: (op) =>
+          SyncLoopOp.matchSyncLoopOperator(op, {
+            Loop: (op) =>
+              Effect.map(
+                SyncProducer.runReduce(fx.i0, [op.seed, seed] as const, ([opAcc, acc], a) => {
+                  const [c, b] = op.f(opAcc, a)
+                  const newAcc = f(acc, c)
+                  return [b, newAcc] as const
+                }),
+                (x) => x[1]
+              ),
+            FilterMapLoop: (op) =>
+              Effect.map(
+                SyncProducer.runReduce(fx.i0, [op.seed, seed] as const, ([opAcc, acc], a) => {
+                  const [c, b] = op.f(opAcc, a)
+                  const newAcc = Option.match(c, { onNone: () => acc, onSome: (c) => f(acc, c) })
+
+                  return [b, newAcc] as const
+                }),
+                (x) => x[1]
               )
-            )))
-        ))
-    )
+          }),
+        EffectLoopOperator: (op) =>
+          EffectLoopOp.matchEffectLoopOperator(op, {
+            LoopEffect: (op) =>
+              Effect.map(
+                SyncProducer.runReduceEffect(fx.i0, [op.seed, seed] as const, ([opAcc, acc], a) => {
+                  return Effect.flatMap(op.f(opAcc, a), ([c, b]) => {
+                    const newAcc = f(acc, c)
+                    return Effect.succeed([b, newAcc] as const)
+                  })
+                }),
+                (x) => x[1]
+              ),
+            FilterMapLoopEffect: (op) =>
+              Effect.map(
+                SyncProducer.runReduceEffect(fx.i0, [op.seed, seed] as const, ([opAcc, acc], a) => {
+                  return Effect.map(op.f(opAcc, a), ([c, b]) => {
+                    const newAcc = Option.match(c, { onNone: () => acc, onSome: () => f(acc, b) })
+                    return [b, newAcc] as const
+                  })
+                }),
+                (x) => x[1]
+              )
+          })
+      })
+    } else if (isProducerEffect(fx)) {
+      return EffectProducer.runReduceEffect(fx.i0, seed, (b, a) => Effect.succeed(f(b, a)))
+    } else if (isFailCause(fx)) {
+      return Effect.failCause(fx.i0)
+    } else {
+      return new Reduce(fx, seed, f)
+    }
   }
 }
 
-class Middleware<R, E, A, R2, R3> extends ToFx<R2 | R3, E, A> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-    readonly i2: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>
-  ) {
-    super(i0, i1)
+export const toReadonlyArray = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>> =>
+  Effect.suspend(() => {
+    const init = [] as Array<A>
+    return Reduce.make(fx, init, (acc, a) => {
+      acc.push(a)
+      return acc
+    })
+  })
+
+export const slice = <R, E, A>(fx: Fx<R, E, A>, drop: number, take: number): Fx<R, E, A> =>
+  Slice.make(fx, boundsFrom(drop, take))
+
+export const take = <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A> => slice(fx, 0, n)
+
+export const drop = <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A> => slice(fx, n, Infinity)
+
+class Slice<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Bounds) {
+    super()
   }
 
-  static make<R, R2, E, A>(
-    fx: Fx<R, E, A>,
-    middleware: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-    mapSink: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>
-  ): Fx<R2, E, A> {
-    if (fx instanceof Middleware) {
-      return new Middleware(fx.i0 as Fx<R, E, any>, (effect) => middleware(fx.i1(effect)), (s) => fx.i2(mapSink(s)))
-    } else {
-      return new Middleware(fx, middleware, mapSink)
-    }
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return Sink.slice(sink, this.i1, (s) => this.i0.run(s))
   }
 
-  protected toFx(): Fx<R2, E, A> {
-    return fromSink((sink) => this.i1(run(this.i0, this.i2(sink))))
+  static make<R, E, A>(fx: Fx<R, E, A>, bounds: Bounds): Fx<R, E, A> {
+    if (isNilBounds(bounds)) return empty
+    if (isInfiniteBounds(bounds)) return fx
+
+    if (isSlice(fx)) {
+      return Slice.make(fx.i0, mergeBounds(fx.i1, bounds))
+    } else if (isTransformer(fx) && fx.i1._tag === "Map") {
+      // Commute map and slice
+      return map(Slice.make(fx.i0, bounds), fx.i1.f)
+    } else {
+      return new Slice(fx, bounds)
+    }
   }
 }
 
-export function succeed<A>(value: A): Fx<never, never, A> {
-  return new Succeed(value)
+/**
+ * @internal
+ */
+export function isSlice<R, E, A>(fx: Fx<R, E, A>): fx is Slice<R, E, A> {
+  return fx.constructor === Slice
 }
 
-export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
-  return new FromIterable(iterable)
+export function skipRepeatsWith<R, E, A>(
+  fx: Fx<R, E, A>,
+  eq: Equivalence.Equivalence<A>
+): Fx<R, E, A> {
+  return filterMapLoop(fx, Option.none<A>(), (previous, a) => {
+    if (Option.isSome(previous) && eq(a, previous.value)) {
+      return [Option.none<A>(), Option.some<A>(a)] as const
+    } else {
+      return [Option.some<A>(a), Option.some<A>(a)] as const
+    }
+  })
 }
 
-export const map: {
-  <A, B>(f: (a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B>
-} = dual(2, function map<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B) {
-  return Transformer.make<R, E, B>(fx, Map(f))
-})
-
-export const mapBoth: {
-  <E, E2, A, B>(
-    options: {
-      readonly onFailure: (e: E) => E2
-      readonly onSuccess: (a: A) => B
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R, E2, B>
+export function skipRepeats<R, E, A>(
+  fx: Fx<R, E, A>
+): Fx<R, E, A> {
+  return skipRepeatsWith(fx, Equal.equals)
+}
 
-  <R, E, A, E2, B>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (e: E) => E2
-      readonly onSuccess: (a: A) => B
-    }
-  ): Fx<R, E2, B>
-} = dual(2, function mapBoth<R, E, A, E2, B>(
-  fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (e: E) => E2
-    readonly onSuccess: (a: A) => B
+class ProducerEffectTransformer<R, E, A, R2, E2, B> extends FxBase<R | R2, E | E2, B> {
+  constructor(readonly i0: EffectProducer.EffectProducer<R, E, A>, readonly i1: Op.Operator) {
+    super()
   }
-) {
-  return map(mapError(fx, options.onFailure), options.onSuccess)
-})
-
-export const filter: {
-  <A, B extends A>(f: (a: A) => a is B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <A>(f: (a: A) => boolean): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A, B extends A>(fx: Fx<R, E, A>, f: (a: A) => a is B): Fx<R, E, B>
-  <R, E, A>(fx: Fx<R, E, A>, f: (a: A) => boolean): Fx<R, E, A>
-} = dual(2, function map<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => boolean) {
-  return Transformer.make<R, E, B>(fx, Filter(f))
-})
-
-export const filterMap: {
-  <A, B>(f: (a: A) => Option.Option<B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B>
-} = dual(2, function map<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>) {
-  return Transformer.make<R, E, B>(fx, FilterMap(f))
-})
-
-export const compact = <R, E, A>(fx: Fx<R, E, Option.Option<A>>): Fx<R, E, A> => filterMap(fx, identity)
-
-export const mapErrorCause: {
-  <E, E2>(f: (a: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => Cause.Cause<E2>): Fx<R, E2, A>
-} = dual(2, function map<R, E, A, E2>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => Cause.Cause<E2>) {
-  return TransformerCause.make<R, E2, A>(fx, Map(f))
-})
-
-export const mapError: {
-  <E, E2>(f: (a: E) => E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: E) => E2): Fx<R, E2, A>
-} = dual(2, function map<R, E, A, E2>(fx: Fx<R, E, A>, f: (a: E) => E2) {
-  return TransformerCause.make<R, E2, A>(fx, Map(Cause.map(f)))
-})
-
-export const filterCause: {
-  <E, E2 extends E>(f: (a: Cause.Cause<E>) => a is Cause.Cause<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <E>(f: (a: Cause.Cause<E>) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, E2 extends E, A>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => a is Cause.Cause<E2>): Fx<R, E2, A>
-  <R, E, A>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => boolean): Fx<R, E, A>
-} = dual(2, function map<R, E, A, E2>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => boolean) {
-  return TransformerCause.make<R, E2, A>(fx, Filter(f))
-})
-
-export const filterMapCause: {
-  <E, E2>(f: (a: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<R, E2, A>
-} = dual(2, function map<R, E, A, E2>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>) {
-  return TransformerCause.make<R, E2, A>(fx, FilterMap(f))
-})
-
-export const filterError: {
-  <E, E2 extends E>(f: (a: E) => a is E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <E>(f: (a: E) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, E2 extends E, A>(fx: Fx<R, E, A>, f: (a: E) => a is E2): Fx<R, E2, A>
-  <R, E, A>(fx: Fx<R, E, A>, f: (a: E) => boolean): Fx<R, E, A>
-} = dual(2, function map<R, E, A>(fx: Fx<R, E, A>, f: (a: E) => boolean) {
-  return filterMapCause(fx, (cause) =>
-    Cause.failureOrCause(cause).pipe(
-      Either.match({
-        onLeft: (e) => f(e) ? Option.some(Cause.fail(e)) : Option.none(),
-        onRight: Option.some
-      })
-    ))
-})
 
-export const filterMapError: {
-  <E, E2>(f: (a: E) => Option.Option<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
-  <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: E) => Option.Option<E2>): Fx<R, E2, A>
-} = dual(2, function map<R, E, A, E2>(fx: Fx<R, E, A>, f: (a: E) => Option.Option<E2>) {
-  return filterMapCause(fx, (cause) =>
-    Cause.failureOrCause(cause).pipe(
-      Either.match({
-        onLeft: (e) => Option.map(f(e), Cause.fail),
-        onRight: Option.some
-      })
-    ))
-})
-
-export const filterMapErrorEffect: {
-  <E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | B, A>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<R | R2, E2 | B, A>
-} = dual(2, <R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>
-): Fx<R | R2, B | E2, A> => {
-  return fromSink((sink) =>
-    run(
-      fx,
-      Sink.WithContext(
-        (cause) =>
-          Either.match(Cause.failureOrCause(cause), {
-            onLeft: (e) =>
-              Effect.matchCauseEffect(f(e), {
-                onFailure: sink.onFailure,
-                onSuccess: Option.match({
-                  onNone: () => Effect.unit,
-                  onSome: (b) => sink.onFailure(Cause.fail(b))
-                })
-              }),
-            onRight: sink.onFailure
-          }),
-        sink.onSuccess
-      )
-    )
-  )
-})
-
-export function observe<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  onSuccees: (a: A) => Effect.Effect<R2, E2, unknown>
-): Effect.Effect<R | R2, E | E2, void> {
-  return helpers.withScopedFork((fork) =>
-    Effect.flatMap(Deferred.make<E | E2, void>(), (deferred) =>
-      run(
-        fx,
-        Sink.WithContext(
-          (cause) => Deferred.failCause(deferred, cause),
-          (a) => Effect.catchAllCause(onSuccees(a), (cause) => Deferred.failCause(deferred, cause))
-        )
-      ).pipe(
-        Effect.intoDeferred(deferred),
-        fork,
-        Effect.flatMap(() => Deferred.await(deferred))
-      ))
-  )
+  run<R3>(sink: Sink.Sink<R3, E | E2, B>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return EffectProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink))
+  }
 }
 
-export function drain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, void> {
-  return observe(fx, constUnit)
+/**
+ * @internal
+ */
+export function isProducerEffectTransformer<R, E, A>(
+  fx: Fx<R, E, A>
+): fx is ProducerEffectTransformer<R, E, any, R, E, A> {
+  return fx.constructor === ProducerEffectTransformer
 }
 
-export function toArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, Array<A>> {
-  return Effect.suspend(() => {
-    const array: Array<A> = []
-
-    return Effect.as(
-      observe(fx, (a) => Effect.sync(() => array.push(a))),
-      array
-    )
-  })
+class Empty extends FxBase<never, never, never> {
+  run<R2>(): Effect.Effect<R2, never, unknown> {
+    return Effect.unit
+  }
 }
 
-export function toReadonlyArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>> {
-  return toArray(fx)
+/**
+ * @internal
+ */
+export function isEmpty<R, E, A>(fx: Fx<R, E, A>): fx is Empty {
+  return fx.constructor === Empty
 }
 
-export const flatMapWithStrategy: {
-  <A, R2, E2, B>(
-    f: (a: A) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): Fx<R | R2, E | E2, B>
-} = dual(
-  3,
-  function flatMapWithStrategy<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): Fx<R | R2, E | E2, B> {
-    return new WithFlattenStrategy(
-      ({ fork, sink }) => run(fx, Sink.WithContext(sink.onFailure, (a) => fork(run(from(f(a)), sink)))),
-      strategy
-    )
-  }
-)
+export const empty: Fx<never, never, never> = new Empty()
 
-export const switchMap: {
-  <A, R2, E2, B>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = dual(
-  2,
-  function switchMap<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B> {
-    return flatMapWithStrategy(fx, f, strategies.Switch)
+class Never extends FxBase<never, never, never> {
+  run<R2>(): Effect.Effect<R2, never, unknown> {
+    return Effect.never
   }
-)
+}
 
-export const exhaustMap: {
-  <A, R2, E2, B>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = dual(
-  2,
-  function exhaustmap<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B> {
-    return flatMapWithStrategy(fx, f, strategies.Exhaust)
-  }
-)
+/**
+ * @internal
+ */
+export function isNever<R, E, A>(fx: Fx<R, E, A>): fx is Never {
+  return fx.constructor === Never
+}
 
-export const exhaust = <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => exhaustMap(fx, identity)
+export const never: Fx<never, never, never> = new Never()
 
-export const exhaustMapLatest: {
-  <A, R2, E2, B>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = dual(
-  2,
-  function exhaustMapLatest<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E | E2, B> {
-    return flatMapWithStrategy(fx, f, strategies.ExhaustLatest)
-  }
-)
+export function padWith<R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  start: Iterable<B>,
+  end: Iterable<C>
+): Fx<R, E, A | B | C> {
+  return new PadWith(fx, start, end)
+}
 
-export const exhaustLatest = <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => exhaustMapLatest(fx, identity)
+export function prependAll<R, E, A, B>(
+  fx: Fx<R, E, A>,
+  start: Iterable<B>
+): Fx<R, E, A | B> {
+  return new PadWith(fx, start, [])
+}
 
-export const flatMap: {
-  <A, R2, E2, B>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = dual(
-  2,
-  function flatMap<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B> {
-    return flatMapWithStrategy(fx, f, strategies.Unbounded)
-  }
-)
+export function appendAll<R, E, A, C>(
+  fx: Fx<R, E, A>,
+  end: Iterable<C>
+): Fx<R, E, A | C> {
+  return new PadWith(fx, [], end)
+}
 
-export const flatten = <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => flatMap(fx, identity)
+export function prepend<R, E, A, B>(fx: Fx<R, E, A>, start: B): Fx<R, E, A | B> {
+  return new PadWith(fx, [start], [])
+}
 
-export const flatMapConcurrently: {
-  <A, R2, E2, B>(f: (a: A) => FxInput<R2, E2, B>, concurrency: number): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>, concurrency: number): Fx<R | R2, E | E2, B>
-} = dual(
-  3,
-  function flatMapConcurrently<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): Fx<R | R2, E | E2, B> {
-    return flatMapWithStrategy(fx, f, strategies.Bounded(concurrency))
-  }
-)
-
-export const concatMap: {
-  <A, R2, E2, B>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = dual(
-  2,
-  function concatMap<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E | E2, B> {
-    return flatMapConcurrently(fx, f, 1)
-  }
-)
-
-export const acquireUseRelease: {
-  <A, R2, E2, B, R3, E3>(
-    use: (a: A) => FxInput<R2, E2, B>,
-    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, unknown>
-  ): <R, E>(acquire: Effect.Effect<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, B>
-
-  <R, E, A, R2, E2, B, R3, E3>(
-    acquire: Effect.Effect<R, E, A>,
-    use: (a: A) => FxInput<R2, E2, B>,
-    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, unknown>
-  ): Fx<R | R2 | R3, E | E2 | E3, B>
-} = dual(3, function acquireUseRelease<R, E, A, R2, E2, B, R3, E3>(
-  acquire: Effect.Effect<R, E, A>,
-  use: (a: A) => FxInput<R2, E2, B>,
-  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, unknown>
-): Fx<R | R2 | R3, E | E2 | E3, B> {
-  return fromSink((sink) =>
-    Effect.catchAllCause(
-      Effect.acquireUseRelease(
-        acquire,
-        (a) => run(from(use(a)), sink),
-        (a, exit) => Effect.catchAllCause(release(a, exit), sink.onFailure)
-      ),
-      sink.onFailure
-    )
+export function append<R, E, A, C>(fx: Fx<R, E, A>, end: C): Fx<R, E, A | C> {
+  return new PadWith<R, E, A, never, C>(fx, [], [end])
+}
+
+export function scan<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B> {
+  return prepend(
+    loop(fx, seed, (b, a) => {
+      const b2 = f(b, a)
+      return [b2, b2] as const
+    }),
+    seed
   )
-})
+}
 
-export function combine<const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  {
-    readonly [K in keyof FX]: Fx.Success<FX[K]>
+class PadWith<
+  R,
+  E,
+  A,
+  B,
+  C
+> extends FxBase<R, E, A | B | C> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Iterable<B>, readonly i2: Iterable<C>) {
+    super()
   }
-> {
-  return fromSink((sink) =>
-    Effect.suspend(() => {
-      const total = fxs.length
-
-      if (total === 0) return Effect.unit
 
-      const values = new globalThis.Map<number, any>()
-      const sample = () =>
-        Array.from({ length: total }, (_, i) => values.get(i)) as {
-          readonly [K in keyof FX]: Fx.Success<FX[K]>
-        }
+  run<R2>(sink: Sink.Sink<R2, E, A | B | C>): Effect.Effect<R | R2, never, unknown> {
+    const onSuccess = (a: A | B | C) => sink.onSuccess(a)
 
-      const emitIfReady = (value: any, index: number) =>
-        Effect.suspend(() => {
-          values.set(index, value)
-          if (values.size === total) {
-            return sink.onSuccess(sample())
-          } else {
-            return Effect.unit
-          }
-        })
+    return Effect.forEach(this.i1, onSuccess, DISCARD).pipe(
+      Effect.zipRight(this.i0.run(sink)),
+      Effect.zipRight(Effect.forEach(this.i2, onSuccess, DISCARD))
+    )
+  }
 
-      return Effect.all(
-        fxs.map((fx, index) => run(fx, Sink.WithContext(sink.onFailure, (a) => emitIfReady(a, index)))),
-        { concurrency: "unbounded" }
-      )
-    })
-  )
+  static make<R, E, A, B, C>(
+    fx: Fx<R, E, A>,
+    start: Iterable<B>,
+    end: Iterable<C>
+  ): Fx<R, E, A | B | C> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else if (isPadWith(fx)) {
+      return new PadWith(fx.i0, concat(start, fx.i1), concat(fx.i2, end))
+    } else {
+      return new PadWith(fx, start, end)
+    }
+  }
 }
 
-export function struct<const FX extends Readonly<Record<PropertyKey, Fx<any, any, any>>>>(
-  fxs: FX
-): Fx<
-  Fx.Context<FX[string]>,
-  Fx.Error<FX[string]>,
-  {
-    readonly [K in keyof FX]: Fx.Success<FX[K]>
+function concat<A, B>(a: Iterable<A>, b: Iterable<B>): Iterable<A | B> {
+  return {
+    *[Symbol.iterator]() {
+      yield* a
+      yield* b
+    }
   }
-> {
-  return map(combine(Reflect.ownKeys(fxs).map((k) => map(fxs[k], (a) => [k, a] as const))), Object.fromEntries)
 }
 
-export function merge<const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
-> {
-  return Merge.make(fxs, strategies.Unordered(Infinity))
-}
-
-export const mergeConcurrently: {
-  (concurrency: number): <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX
-  ) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-  <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX,
-    concurrency: number
-  ): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-} = dual(2, function mergeConcurrently<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX,
-  concurrency: number
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
-> {
-  return Merge.make(fxs, strategies.Unordered(concurrency))
-})
+/**
+ * @internal
+ */
+export function isPadWith<R, E, A>(
+  fx: Fx<R, E, A>
+): fx is PadWith<R, E, A, A, A> {
+  return fx.constructor === PadWith
+}
 
-export function mergeBuffer<const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
-> {
-  return Merge.make(fxs, strategies.Ordered(Infinity))
-}
-
-export const mergeBufferConcurrently: {
-  (concurrency: number): <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX
-  ) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-  <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-    fxs: FX,
-    concurrency: number
-  ): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-} = dual(2, function mergeConcurrently<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX,
-  concurrency: number
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
-> {
-  return Merge.make(fxs, strategies.Ordered(concurrency))
-})
+export function flatMapWithStrategy<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+  strategy: FlattenStrategy,
+  executionStrategy: ExecutionStrategy.ExecutionStrategy = ExecutionStrategy.sequential
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return FlatMapWithStrategy.make(fx, f, strategy, executionStrategy)
+}
 
-export const mergeSwitch = <const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
-> => Merge.make(fxs, strategies.Switch)
+export function switchMap<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMapWithStrategy(fx, f, Switch, executionStrategy)
+}
 
-export function race<const FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fxs: FX
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
-> {
-  if (fxs.length === 0) return empty
-  if (fxs.length === 1) return fxs[0]
-
-  return withScopedFork(({ fork, sink }) =>
-    Effect.asyncEffect<
-      never,
-      never,
-      readonly [
-        number,
-        Array<Fiber.Fiber<never, unknown>>
-      ],
-      Fx.Context<FX[number]>,
-      never,
-      unknown
-    >((resume) =>
-      Effect.gen(function*(_) {
-        let winningIndex = -1
-        const fibers: Array<Fiber.Fiber<never, unknown>> = yield* _(
-          Effect.forEach(fxs, (fx, i) =>
-            fork(
-              run(
-                fx,
-                Sink.Sink(
-                  (cause) => Effect.suspend(() => pickWinner(i) ? sink.onFailure(cause) : Effect.unit),
-                  (a) => Effect.suspend(() => pickWinner(i) ? sink.onSuccess(a) : Effect.unit)
-                )
-              )
-            ))
-        )
+export function switchMapEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return switchMap(fx, (a) => fromEffect(f(a)), executionStrategy)
+}
 
-        function pickWinner(i: number) {
-          if (winningIndex === -1) {
-            winningIndex = i
-            resume(Effect.succeed([i, fibers]))
-          }
+export function exhaustMap<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMapWithStrategy(fx, f, Exhaust, executionStrategy)
+}
 
-          return winningIndex === i
-        }
+export function exhaustMapEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return exhaustMap(fx, (a) => fromEffect(f(a)), executionStrategy)
+}
+
+export function exhaustMapLatest<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMapWithStrategy(fx, f, ExhaustLatest, executionStrategy)
+}
+
+export function exhaustMapLatestEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return exhaustMapLatest(fx, (a) => fromEffect(f(a)), executionStrategy)
+}
+
+export function exhaustFilterMapLatestEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return exhaustMapLatest(fx, (a) =>
+    fromFxEffect(Effect.map(
+      f(a),
+      Option.match({
+        onNone: () => empty,
+        onSome: succeed
       })
-    ).pipe(
-      Effect.flatMap(([winningIndex, fibers]) =>
-        Effect.suspend(() => {
-          const [winner] = fibers.splice(winningIndex, 1)
+    )), executionStrategy)
+}
 
-          return Effect.flatMap(Fiber.interruptAll(fibers), () => Fiber.join(winner))
-        })
-      )
-    )
-  )
+export function flatMapConcurrently<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+  capacity: number,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMapWithStrategy(fx, f, Bounded(capacity), executionStrategy)
 }
 
-export const empty: Fx<never, never, never> = new Empty()
+export function concatMap<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMapConcurrently(fx, f, 1, executionStrategy)
+}
 
-export const never: Fx<never, never, never> = new Never()
+export function flatMapConcurrentlyEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  capacity: number,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMapConcurrently(fx, (a) => fromEffect(f(a)), capacity, executionStrategy)
+}
 
-export const failCause = <E>(cause: Cause.Cause<E>): Fx<never, E, never> => new Fail(cause)
-
-export const fail = <E>(e: E): Fx<never, E, never> => failCause(Cause.fail(e))
-
-export const fromSink = <R, E, A>(
-  f: (sink: Sink.Sink<E, A>) => Effect.Effect<R, E, unknown>
-): Fx<R, E, A> => new FromSink((sink) => Effect.catchAllCause(f(sink), sink.onFailure))
-
-export const suspend = <R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> => new Suspend(f)
-
-export const sync = <A>(f: () => A): Fx<never, never, A> => new Sync(f)
-
-export const slice: {
-  (skip: number, take: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A>
-} = dual(3, function slice<R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A> {
-  return Slice.make(fx, boundsFrom(skip, take))
-})
-
-export const take: {
-  (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
-} = dual(2, function take<R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A> {
-  return slice(fx, 0, n)
-})
-
-export const drop: {
-  (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
-} = dual(2, function drop<R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A> {
-  return slice(fx, n, Infinity)
-})
-
-export const takeWhile: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = dual(
-  2,
-  function takeWhile<R, E, A, R2, E2>(
-    fx: Fx<R, E, A>,
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Fx<R | R2, E | E2, A> {
-    return withEarlyExit(({ sink }) =>
-      run(
-        fx,
-        Sink.WithContext(sink.onFailure, (a) =>
-          Effect.matchCauseEffect(predicate(a), {
-            onFailure: sink.onFailure,
-            onSuccess: (b) => b ? sink.onSuccess(a) : sink.earlyExit
-          }))
-      )
-    )
-  }
-)
+export function flatMap<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMapWithStrategy(fx, f, Unbounded, executionStrategy)
+}
 
-export const takeUntil: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = dual(
-  2,
-  function takeUntil<R, E, A, R2, E2>(
-    fx: Fx<R, E, A>,
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Fx<R | R2, E | E2, A> {
-    return takeWhile(fx, (a) => Effect.map(predicate(a), (x) => !x))
+export function flatMapEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E | E2, B> {
+  return flatMap(fx, (a) => fromEffect(f(a)), executionStrategy)
+}
+
+class FlatMapWithStrategy<
+  R,
+  E,
+  A,
+  R2,
+  E2,
+  B
+> extends FxBase<R | R2 | Scope.Scope, E | E2, B> {
+  private withFork: <R, E, A>(
+    f: (
+      fork: FxFork,
+      scope: Scope.Scope
+    ) => Effect.Effect<R, E, A>,
+    executionStrategy: ExecutionStrategy.ExecutionStrategy
+  ) => Effect.Effect<Scope.Scope | R, E, void>
+
+  constructor(
+    readonly i0: Fx<R, E, A>,
+    readonly i1: (a: A) => Fx<R2, E2, B>,
+    readonly i2: FlattenStrategy,
+    readonly i3: ExecutionStrategy.ExecutionStrategy
+  ) {
+    super()
+
+    this.withFork = withFlattenStrategy(i2)
   }
-)
 
-export const dropWhile: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = dual(
-  2,
-  function dropWhile<R, E, A, R2, E2>(
-    fx: Fx<R, E, A>,
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Fx<R | R2, E | E2, A> {
-    return withEarlyExit(({ sink }) =>
-      Effect.suspend(() => {
-        let isDropping = true
-
-        return run(
-          fx,
-          Sink.WithContext(sink.onFailure, (a) =>
-            isDropping ?
-              Effect.matchCauseEffect(predicate(a), {
-                onFailure: sink.onFailure,
-                onSuccess: (b) => {
-                  if (b) {
-                    return Effect.unit
-                  } else {
-                    isDropping = false
-                    return sink.onSuccess(a)
-                  }
-                }
-              }) :
-              sink.onSuccess(a))
-        )
-      })
+  run<R3>(sink: Sink.Sink<R3, E | E2, B>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+    return this.withFork(
+      (fork) =>
+        Sink.withEarlyExit(sink, (sink) =>
+          this.i0.run(
+            Sink.make(
+              (cause) => Cause.isInterruptedOnly(cause) ? sink.earlyExit : sink.onFailure(cause),
+              (a) => fork(this.i1(a).run(sink))
+            )
+          )),
+      this.i3
     )
   }
-)
 
-export const dropUntil: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = dual(
-  2,
-  function dropUntil<R, E, A, R2, E2>(
+  static make<R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Fx<R | R2, E | E2, A> {
-    return dropWhile(fx, (a) => Effect.map(predicate(a), (x) => !x))
-  }
-)
+    f: (a: A) => Fx<R2, E2, B>,
+    strategy: FlattenStrategy,
+    executionStrategy: ExecutionStrategy.ExecutionStrategy
+  ) {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else if (isProducer(fx)) {
+      if (fx.i0._tag === "Success") return f(fx.i0.source)
+      if (fx.i0._tag === "FromSync") {
+        const producer = fx.i0
+        return suspend(() => f(producer.source()))
+      }
 
-export const dropAfter: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = dual(
-  2,
-  function dropAfter<R, E, A, R2, E2>(
-    fx: Fx<R, E, A>,
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Fx<R | R2, E | E2, A> {
-    return fromSink((sink) =>
-      Effect.suspend(() => {
-        let isDropping = false
-
-        return run(
-          fx,
-          Sink.WithContext(sink.onFailure, (a) =>
-            isDropping ?
-              Effect.unit :
-              Effect.matchCauseEffect(predicate(a), {
-                onFailure: sink.onFailure,
-                onSuccess: (b) => {
-                  if (b) {
-                    isDropping = true
-                    return Effect.unit
-                  } else {
-                    return sink.onSuccess(a)
-                  }
-                }
-              }))
-        )
-      })
-    )
+      const arr = Array.isArray(fx.i0.source) ? fx.i0.source : Array.from(fx.i0.source)
+      if (arr.length === 0) return empty
+      if (arr.length === 1) return f(arr[0])
+
+      switch (strategy._tag) {
+        case "Switch":
+          return f(arr[arr.length - 1])
+        case "Exhaust":
+          return f(arr[0])
+        case "ExhaustLatest":
+          return arr.length > 1 ? continueWith(f(arr[0]), () => f(arr[arr.length - 1])) : f(arr[0])
+        default:
+          return new FlatMapWithStrategy(fx, f, strategy, executionStrategy)
+      }
+    } else if (isProducerEffect(fx) && fx.i0._tag === "FromEffect") {
+      return fromFxEffect(Effect.map(fx.i0.source, f))
+    } else if (isTransformer(fx) && fx.i1._tag === "Map") {
+      const { f: op } = fx.i1
+      return new FlatMapWithStrategy(fx.i0, (a) => f(op(a)), strategy, executionStrategy)
+    } else {
+      return new FlatMapWithStrategy(fx, f, strategy, executionStrategy)
+    }
   }
-)
+}
 
-export const continueWith: {
-  <R2, E2, B>(f: () => Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
-} = dual(
-  2,
-  function continueWith<R, E, R2, E2, A>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, A>): Fx<R | R2, E | E2, A> {
-    return fromSink((sink) => Effect.flatMap(run(fx, sink), () => run(f(), sink)))
-  }
-)
+export function fromFxEffect<R, E, R2, E2, B>(
+  effect: Effect.Effect<R, E, Fx<R2, E2, B>>
+): Fx<R | R2, E | E2, B> {
+  return new FromFxEffect(effect)
+}
 
-export const recoverWith: {
-  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, A>): Fx<R | R2, E2, A | B>
-} = dual(
-  2,
-  function recoverWith<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-  ): Fx<R | R2, E2, A | B> {
-    return fromSink((sink) => Effect.catchAllCause(observe(fx, sink.onSuccess), (cause) => run(from(f(cause)), sink)))
+class FromFxEffect<
+  R,
+  E,
+  R2,
+  E2,
+  B
+> extends FxBase<R | R2, E | E2, B> {
+  constructor(readonly i0: Effect.Effect<R, E, Fx<R2, E2, B>>) {
+    super()
   }
-)
 
-export const mapEffect: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = dual(
-  2,
-  function mapEffect<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, B>
-  ): Fx<R | R2, E | E2, B> {
-    return TransformerEffect.make(fx, MapEffect(f))
+  run<R3>(sink: Sink.Sink<R3, E | E2, B>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return Effect.matchCauseEffect(this.i0, {
+      onFailure: (cause) => sink.onFailure(cause),
+      onSuccess: (fx) => fx.run(sink)
+    })
   }
-)
+}
 
-export const tap: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, A>
-} = dual(
-  2,
-  function tap<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, B>
-  ): Fx<R | R2, E | E2, A> {
-    return TransformerEffect.make(fx, TapEffect(f))
-  }
-)
+export function gen<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+  f: (_: Effect.Adapter) => Generator<Y, FX, any>
+): Fx<
+  Effect.Effect.Context<Y["value"]> | Fx.Context<FX>,
+  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
+  Fx.Success<FX>
+> {
+  return fromFxEffect(Effect.gen(f))
+}
 
-export const filterEffect: {
-  <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>
-} = dual(2, function filterEffect<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  predicate: (a: A) => Effect.Effect<R2, E2, boolean>
-): Fx<R | R2, E | E2, A> {
-  return TransformerEffect.make(fx, FilterEffect(predicate))
-})
+export function genScoped<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+  f: (_: Effect.Adapter) => Generator<Y, FX, any>
+): Fx<
+  Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>,
+  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
+  Fx.Success<FX>
+> {
+  return scoped(fromFxEffect(Effect.gen(f)))
+}
 
-export const filterMapEffect: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<R | R2, E | E2, B>
-} = dual(2, function filterEffect<R, E, A, R2, E2, B>(
+export function continueWith<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
-): Fx<R | R2, E | E2, A> {
-  return TransformerEffect.make(fx, FilterMapEffect(f))
-})
-
-export const middleware: {
-  <R, E, A, R2>(
-    f: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-    g?: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>
-  ): (fx: Fx<R, E, A>) => Fx<R2, E, A>
+  f: () => Fx<R2, E2, B>
+): Fx<R | R2, E | E2, A | B> {
+  return ContinueWith.make(fx, f)
+}
 
-  <R, E, A, R2>(
-    fx: Fx<R, E, A>,
-    f: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-    g?: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>
-  ): Fx<R2, E, A>
-} = dual((args) => args.length === 3 || typeof args[0] !== "function", function middleware<R, E, A, R2>(
-  fx: Fx<R, E, A>,
-  f: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-  g?: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>
-): Fx<R2, E, A> {
-  return Middleware.make(fx, f, g ?? identity)
-})
-
-export const loop: {
-  <A, B, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, C>
-  <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<R, E, C>
-} = dual(3, function loop<R, E, A, B, C>(
-  fx: Fx<R, E, A>,
-  seed: B,
-  f: (acc: B, a: A) => readonly [C, B]
-): Fx<R, E, C> {
-  return Loop.make(fx, seed, f)
-})
-
-export const loopEffect: {
-  <B, A, R2, E2, C>(
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>
-
-  <R, E, A, B, R2, E2, C>(
-    fx: Fx<R, E, A>,
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-  ): Fx<R | R2, E | E2, C>
-} = dual(3, function loopEffect<R, E, A, B, R2, E2, C>(
-  fx: Fx<R, E, A>,
-  seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-): Fx<R | R2, E | E2, C> {
-  return LoopEffect.make(fx, f, seed)
-})
-
-export const startWith: {
-  <B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
-  <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B>
-} = dual(2, function startWith<R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B> {
-  return fromSink((sink) => Effect.flatMap(sink.onSuccess(value), () => run(fx, sink)))
-})
-
-export const endWith: {
-  <B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
-  <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B>
-} = dual(2, function endWith<R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B> {
-  return fromSink((sink) => Effect.flatMap(run(fx, sink), () => sink.onSuccess(value)))
-})
-
-export const scan: {
-  <A, B>(seed: B, f: (acc: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Fx<R, E, B>
-} = dual(3, function loop<R, E, A, B>(
-  fx: Fx<R, E, A>,
-  seed: B,
-  f: (acc: B, a: A) => B
-): Fx<R, E, B> {
-  return continueWith(
-    new Succeed(seed),
-    () =>
-      Loop.make(fx, seed, (b, a) => {
-        const b2 = f(b, a)
+class ContinueWith<
+  R,
+  E,
+  A,
+  R2,
+  E2,
+  B
+> extends FxBase<R | R2, E | E2, A | B> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: () => Fx<R2, E2, B>) {
+    super()
+  }
 
-        return [b2, b2]
-      })
-  )
-})
+  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return Effect.flatMap(this.i0.run(sink), () => this.i1().run(sink))
+  }
 
-export const scanEffect: {
-  <A, B, R2, E2>(
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<R2, E2, B>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-  <R, E, A, B, R2, E2>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, B>
-} = dual(3, function loopEffect<R, E, A, B, R2, E2>(
-  fx: Fx<R, E, A>,
-  seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R2, E2, B>
-): Fx<R | R2, E | E2, B> {
-  return continueWith(
-    new Succeed(seed),
-    () => LoopEffect.make(fx, (b, a) => Effect.map(f(b, a), (b2) => [b2, b2]), seed)
-  )
-})
-
-export const flatMapCauseWithStrategy: {
-  <E, R2, E2, B>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): Fx<R | R2, E2, A | B>
-} = dual(3, function flatMapCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-  strategy: FlattenStrategy
-): Fx<R | R2, E2, A | B> {
-  return new WithFlattenStrategy(
-    ({ fork, sink }) => run(fx, Sink.WithContext((cause) => fork(run(from(f(cause)), sink)), sink.onSuccess)),
-    strategy
-  )
-})
-
-export const flatMapErrorWithStrategy: {
-  <E, R2, E2, B>(
-    f: (error: E) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(
+  static make<R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>,
-    strategy: FlattenStrategy
-  ): Fx<R | R2, E2, A | B>
-} = dual(3, function flatMapCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => FxInput<R2, E2, B>,
-  strategy: FlattenStrategy
-): Fx<R | R2, E2, A | B> {
-  return new WithFlattenStrategy(
-    ({ fork, sink }) =>
-      run(
-        fx,
-        Sink.WithContext((cause) =>
-          fork(run(
-            from(cause.pipe(
-              Cause.failureOrCause,
-              Either.match({
-                onLeft: f,
-                onRight: failCause
-              })
-            )),
-            sink
-          )), sink.onSuccess)
-      ),
-    strategy
-  )
-})
+    f: () => Fx<R2, E2, B>
+  ): Fx<R | R2, E | E2, A | B> {
+    if (isEmpty(fx)) return f()
+    else if (isNever(fx)) return fx
+    else if (isProducer(fx)) {
+      return SyncProducer.matchSyncProducer(fx.i0, {
+        Success: (source) => prependAll(f(), [source]),
+        FromSync: (source) => suspend(() => prependAll(f(), [source()])),
+        FromArray: (source) => prependAll(f(), source),
+        FromIterable: (source) => prependAll(f(), source)
+      })
+    } else {
+      return new ContinueWith(fx, f)
+    }
+  }
+}
 
-export const flatMapCause: {
-  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function flatMapCause<R, E, A, R2, E2, B>(
+export function orElseCause<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>
 ): Fx<R | R2, E2, A | B> {
-  return flatMapCauseWithStrategy(fx, f, strategies.Unbounded)
-})
+  return OrElseCause.make(fx, f)
+}
 
-export const flatMapError: {
-  <E, R2, E2, B>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function flatMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => FxInput<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
-  return flatMapErrorWithStrategy(fx, f, strategies.Unbounded)
-})
-
-export const flatMapCauseConcurrently: {
-  <E, R2, E2, B>(
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): Fx<R | R2, E2, A | B>
-} = dual(3, function flatMapCauseConcurrently<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>,
-  concurrency: number
-): Fx<R | R2, E2, A | B> {
-  return flatMapCauseWithStrategy(fx, f, strategies.Bounded(concurrency))
-})
-
-export const flatMapErrorConcurrently: {
-  <E, R2, E2, B>(
-    f: (error: E) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => FxInput<R2, E2, B>,
-    concurrency: number
-  ): Fx<R | R2, E2, A | B>
-} = dual(3, function flatMapCauseConcurrently<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => FxInput<R2, E2, B>,
-  concurrency: number
-): Fx<R | R2, E2, A | B> {
-  return flatMapErrorWithStrategy(fx, f, strategies.Bounded(concurrency))
-})
+class OrElseCause<
+  R,
+  E,
+  A,
+  R2,
+  E2,
+  B
+> extends FxBase<R | R2, E2, A | B> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) {
+    super()
+  }
 
-export const switchMapCause: {
-  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function switchMapCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
-  return flatMapCauseWithStrategy(fx, f, strategies.Switch)
-})
+  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return Effect.catchAllCause(observe(this.i0, sink.onSuccess), (cause) => this.i1(cause).run(sink))
+  }
 
-export const switchMapError: {
-  <E, R2, E2, B>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function switchMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => FxInput<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
-  return flatMapErrorWithStrategy(fx, f, strategies.Switch)
-})
+  static make<R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>
+  ): Fx<R | R2, E2, A | B> {
+    if (isEmpty(fx)) return fx
+    else if (isNever(fx)) return fx
+    else {
+      return new OrElseCause(fx, f)
+    }
+  }
+}
 
-export const exhaustMapCause: {
-  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function exhaustMapCause<R, E, A, R2, E2, B>(
+export function orElse<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
+  f: (error: E) => Fx<R2, E2, B>
 ): Fx<R | R2, E2, A | B> {
-  return flatMapCauseWithStrategy(fx, f, strategies.Exhaust)
-})
+  return OrElse.make(fx, f)
+}
 
-export const exhaustMapError: {
-  <E, R2, E2, B>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function switchMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => FxInput<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
-  return flatMapErrorWithStrategy(fx, f, strategies.Exhaust)
-})
+class OrElse<
+  R,
+  E,
+  A,
+  R2,
+  E2,
+  B
+> extends FxBase<R | R2, E2, A | B> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: (error: E) => Fx<R2, E2, B>) {
+    super()
+  }
 
-export const exhaustMapLatestCause: {
-  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function exhaustMapLatestCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
-  return flatMapCauseWithStrategy(fx, f, strategies.ExhaustLatest)
-})
+  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return Effect.catchAll(
+      Effect.asyncEffect<never, E, void, R | R2 | R3, never, unknown>((resume) =>
+        Effect.zipRight(
+          this.i0.run(
+            Sink.make(
+              (cause) =>
+                Either.match(Cause.failureOrCause(cause), {
+                  onLeft: (e) => Effect.succeed(resume(Effect.fail(e))),
+                  onRight: (cause) => sink.onFailure(cause)
+                }),
+              sink.onSuccess
+            )
+          ),
+          Effect.sync(() => resume(Effect.unit))
+        )
+      ),
+      (error) => this.i1(error).run(sink)
+    )
+  }
 
-export const exhaustMapLatestError: {
-  <E, R2, E2, B>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>
-} = dual(2, function switchMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => FxInput<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
-  return flatMapErrorWithStrategy(fx, f, strategies.ExhaustLatest)
-})
-
-export const matchCauseWithStrategy: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
-    }
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B, R3, E3, C>(
+  static make<R, E, A, R2, E2, B>(
     fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
+    f: (error: E) => Fx<R2, E2, B>
+  ): Fx<R | R2, E2, A | B> {
+    if (isEmpty(fx)) return fx
+    else if (isNever(fx)) return fx
+    else {
+      return new OrElse(fx, f)
     }
-  ): Fx<R | R2, E2 | E3, B | C>
-} = dual(2, function flatMapCause<R, E, A, R2, E2, B, R3, E3, C>(
+  }
+}
+
+export function suspend<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> {
+  return new Suspend(f)
+}
+
+class Suspend<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: () => Fx<R, E, A>) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0().run(sink)
+  }
+}
+
+function isSuspend<R, E, A>(fx: Fx<R, E, A>): fx is Suspend<R, E, A> {
+  return fx.constructor === Suspend
+}
+
+class SuspendedTransformer<R, E, A, R2, E2, B> extends FxBase<R | R2, E2, B> {
+  constructor(readonly i0: () => Fx<R, E, A>, readonly i1: Op.Operator) {
+    super()
+  }
+
+  run<R3>(sink: Sink.Sink<R3, E2, B>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return this.i0().run(Op.compileOperatorSink(this.i1, sink))
+  }
+}
+
+function isSuspendedTransformer<R, E, A>(fx: Fx<R, E, A>): fx is SuspendedTransformer<R, E, A, any, any, any> {
+  return fx.constructor === SuspendedTransformer
+}
+
+export function mergeWithStrategy<const FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX,
+  stategy: MergeStrategy
+): Fx<
+  Fx.Context<FX[number]>,
+  Fx.Error<FX[number]>,
+  Fx.Success<FX[number]>
+> {
+  return MergeWithStrategy.make(fx, stategy)
+}
+
+export function merge<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    readonly strategy: FlattenStrategy
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return new WithFlattenStrategy(
-    ({ fork, sink }) =>
-      run(
-        fx,
-        Sink.WithContext((cause) => fork(run(from(options.onFailure(cause)), sink)), (a) =>
-          fork(run(from(options.onSuccess(a)), sink)))
-      ),
-    options.strategy
+  other: Fx<R2, E2, B>
+): Fx<R | R2, E | E2, A | B> {
+  return mergeWithStrategy([fx, other], Unordered(2))
+}
+
+export function mergeAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+  return mergeWithStrategy(fx, Unordered(Infinity))
+}
+
+export function mergeOrdered<FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+  return mergeOrderedConcurrently(fx, Infinity)
+}
+
+export function mergeOrderedConcurrently<FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX,
+  concurrency: number
+): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+  return mergeWithStrategy(fx, Ordered(concurrency))
+}
+
+export function mergeSwitch<FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+  return mergeWithStrategy(fx, Switch)
+}
+
+class MergeWithStrategy<
+  const FX extends ReadonlyArray<Fx<any, any, any>>
+> extends FxBase<
+  Fx.Context<FX[number]>,
+  Fx.Error<FX[number]>,
+  Fx.Success<FX[number]>
+> {
+  constructor(readonly i0: FX, readonly i1: MergeStrategy) {
+    super()
+  }
+
+  run<R2>(
+    sink: Sink.Sink<R2, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
+  ): Effect.Effect<Fx.Context<FX[number]> | R2, never, unknown> {
+    switch (this.i1._tag) {
+      case "Unordered":
+        return runUnordered(this.i0, sink, this.i1.concurrency === Infinity ? "unbounded" : this.i1.concurrency)
+      case "Ordered":
+        return runOrdered(this.i0, sink, this.i1.concurrency === Infinity ? "unbounded" : this.i1.concurrency)
+      case "Switch":
+        return runSwitch(this.i0, sink)
+    }
+  }
+
+  static make<const FX extends ReadonlyArray<Fx<any, any, any>>>(
+    fx: FX,
+    strategy: MergeStrategy
+  ): Fx<
+    Fx.Context<FX[number]>,
+    Fx.Error<FX[number]>,
+    Fx.Success<FX[number]>
+  > {
+    if (fx.length === 0) return empty
+    else if (fx.length === 1) return fx[0]
+    else return new MergeWithStrategy(fx.filter(Predicate.not(isEmpty)), strategy)
+  }
+}
+
+function runUnordered<
+  const FX extends ReadonlyArray<Fx<any, any, any>>,
+  R2
+>(
+  fx: FX,
+  sink: Sink.Sink<R2, any, any>,
+  concurrency: number | "unbounded"
+): Effect.Effect<R2 | Fx.Context<FX[number]>, never, unknown> {
+  return Effect.forEach(fx, (fx) => fx.run(sink), { concurrency, discard: true })
+}
+
+function runOrdered<
+  const FX extends ReadonlyArray<Fx<any, any, any>>,
+  R2
+>(
+  fx: FX,
+  sink: Sink.Sink<R2, any, any>,
+  concurrency: number | "unbounded"
+): Effect.Effect<R2 | Fx.Context<FX[number]>, never, unknown> {
+  return Effect.suspend(
+    () => {
+      const buffers = withBuffers(fx.length, sink)
+      return Effect.all(
+        fx.map((fx, i) =>
+          Effect.flatMap(
+            fx.run(
+              Sink.make(
+                (cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause),
+                (a) => buffers.onSuccess(i, a)
+              )
+            ),
+            () => buffers.onEnd(i)
+          )
+        ),
+        {
+          concurrency
+        }
+      )
+    }
   )
-})
-
-export const matchErrorWithStrategy: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
+}
+
+function runSwitch<
+  const FX extends ReadonlyArray<Fx<any, any, any>>,
+  R2
+>(
+  fx: FX,
+  sink: Sink.Sink<R2, any, any>
+): Effect.Effect<R2 | Fx.Context<FX[number]>, never, unknown> {
+  return Effect.forEach(fx, (fx) => fx.run(sink), { concurrency: 1, discard: true })
+}
+
+export function takeWhile<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: Predicate.Predicate<A>
+): Fx<R, E, A> {
+  return TakeWhile.make(fx, f)
+}
+
+export function takeUntil<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: Predicate.Predicate<A>
+): Fx<R, E, A> {
+  return TakeWhile.make(fx, Predicate.not(f))
+}
+
+class TakeWhile<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Predicate.Predicate<A>) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return Sink.takeWhile(sink, this.i1, (s) => this.i0.run(s))
+  }
+
+  static make<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Fx<R, E, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else {
+      return new TakeWhile(fx, predicate)
+    }
+  }
+}
+
+export function dropWhile<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: Predicate.Predicate<A>
+): Fx<R, E, A> {
+  return DropUntil.make(fx, f)
+}
+
+export function dropUntil<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: Predicate.Predicate<A>
+): Fx<R, E, A> {
+  return DropUntil.make(fx, Predicate.not(f))
+}
+
+class DropUntil<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Predicate.Predicate<A>) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0.run(Sink.dropWhile(sink, this.i1))
+  }
+
+  static make<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Fx<R, E, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else {
+      return new DropUntil(fx, predicate)
+    }
+  }
+}
+
+export function dropAfter<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: Predicate.Predicate<A>
+): Fx<R, E, A> {
+  return DropAfter.make(fx, f)
+}
+
+class DropAfter<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Predicate.Predicate<A>) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0.run(Sink.dropAfter(sink, this.i1))
+  }
+
+  static make<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Fx<R, E, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else {
+      return new DropAfter(fx, predicate)
+    }
+  }
+}
+
+export function takeWhileEffect<R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, boolean>
+): Fx<R | R2, E | E2, A> {
+  return TakeWhileEffect.make(fx, f)
+}
+
+export function takeUntilEffect<R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, boolean>
+): Fx<R | R2, E | E2, A> {
+  return TakeWhileEffect.make(fx, (a) => Effect.map(f(a), Boolean.not))
+}
+
+class TakeWhileEffect<R, E, A, R2, E2> extends FxBase<R | R2, E | E2, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: (a: A) => Effect.Effect<R2, E2, boolean>) {
+    super()
+  }
+
+  run<R3>(sink: Sink.Sink<R3, E | E2, A>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return Sink.takeWhileEffect(sink, this.i1, (s) => this.i0.run(s))
+  }
+
+  static make<R, E, A, R2, E2>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Effect.Effect<R2, E2, boolean>
+  ): Fx<R | R2, E | E2, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else {
+      return new TakeWhileEffect(fx, f)
     }
-  ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
-  <R, E, A, R2, E2, B, R3, E3, C>(
+  }
+}
+
+export function dropWhileEffect<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R, E, boolean>
+): Fx<R, E, A> {
+  return DropWhileEffect.make(fx, f)
+}
+
+export function dropUntilEffect<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R, E, boolean>
+): Fx<R, E, A> {
+  return DropWhileEffect.make(fx, (a) => Effect.map(f(a), Boolean.not))
+}
+
+class DropWhileEffect<R, E, A> extends FxBase<R, E, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: (a: A) => Effect.Effect<R, E, boolean>) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0.run(Sink.dropWhileEffect(sink, this.i1))
+  }
+
+  static make<R, E, A>(
     fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly strategy: FlattenStrategy
+    f: (a: A) => Effect.Effect<R, E, boolean>
+  ): Fx<R, E, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else {
+      return new DropWhileEffect(fx, f)
     }
-  ): Fx<R | R2, E2 | E3, B | C>
-} = dual(2, function flatMapCause<R, E, A, R2, E2, B, R3, E3, C>(
+  }
+}
+
+export function dropAfterEffect<R, E, A, R2, E2>(
   fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (error: E) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    readonly strategy: FlattenStrategy
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return new WithFlattenStrategy(
-    ({ fork, sink }) =>
-      run(
-        fx,
-        Sink.WithContext((cause) =>
-          fork(run(
-            from(cause.pipe(
-              Cause.failureOrCause,
-              Either.match({
-                onLeft: options.onFailure,
-                onRight: failCause
-              })
-            )),
-            sink
-          )), (a) => fork(run(from(options.onSuccess(a)), sink)))
-      ),
-    options.strategy
-  )
-})
+  f: (a: A) => Effect.Effect<R2, E2, boolean>
+): Fx<R | R2, E | E2, A> {
+  return DropAfterEffect.make(fx, f)
+}
+
+class DropAfterEffect<R, E, A, R2, E2> extends FxBase<R | R2, E | E2, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: (a: A) => Effect.Effect<R2, E2, boolean>) {
+    super()
+  }
+
+  run<R3>(sink: Sink.Sink<R3, E | E2, A>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return this.i0.run(Sink.dropAfterEffect(sink, this.i1))
+  }
+
+  static make<R, E, A, R2, E2>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Effect.Effect<R2, E2, boolean>
+  ): Fx<R | R2, E | E2, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else {
+      return new DropAfterEffect(fx, f)
+    }
+  }
+}
+
+export function during<R, E, A, R2, E2, R3, E3, B>(
+  fx: Fx<R, E, A>,
+  window: Fx<R2, E2, Fx<R3, E3, B>>
+): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A> {
+  return During.make(fx, window)
+}
+
+export function since<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  window: Fx<R2, E2, B>
+): Fx<R | R2 | Scope.Scope, E | E2, A> {
+  return During.make(fx, map(window, () => never))
+}
+
+export function until<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  window: Fx<R2, E2, B>
+): Fx<R | R2 | Scope.Scope, E | E2, A> {
+  return During.make(fx, succeed(window))
+}
+
+class During<R, E, A, R2, E2, R3, E3, B> extends FxBase<R | R2 | R3 | Scope.Scope, E | E2 | E3, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Fx<R2, E2, Fx<R3, E3, B>>) {
+    super()
+  }
+
+  run<R4>(sink: Sink.Sink<R4, E | E2 | E3, A>): Effect.Effect<R | R2 | R3 | R4 | Scope.Scope, never, unknown> {
+    return withScopedFork(
+      (fork) =>
+        Sink.withEarlyExit(sink, (s) => {
+          let taking = false
+
+          const onFailure = (cause: Cause.Cause<E | E2 | E3>) => s.onFailure(cause)
+
+          return Effect.flatMap(
+            fork(
+              take(this.i1, 1).run(
+                Sink.make(onFailure, (nested) => {
+                  taking = true
+                  return take(nested, 1).run(Sink.make(onFailure, () => s.earlyExit))
+                })
+              )
+            ),
+            () =>
+              Effect.zipRight(
+                // Allow fibers to start
+                adjustTime(1),
+                this.i0.run(
+                  Sink.make(
+                    onFailure,
+                    (a) => taking ? s.onSuccess(a) : Effect.unit
+                  )
+                )
+              )
+          )
+        }),
+      ExecutionStrategy.sequential
+    )
+  }
 
-export const matchCause: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
+  static make<R, E, A, R2, E2, R3, E3, B>(
+    fx: Fx<R, E, A>,
+    window: Fx<R2, E2, Fx<R3, E3, B>>
+  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else {
+      return new During(fx, window)
     }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+  }
+}
+
+export function middleware<R, E, A, R3>(
+  fx: Fx<R, E, A>,
+  effect: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R3, never, unknown>,
+  sink?: (sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>
+): Fx<R3, E, A> {
+  return new Middleware(fx, effect, sink)
+}
+
+export function onExit<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>
+): Fx<R | R2, E, A> {
+  return middleware(fx, Effect.onExit(f))
+}
+
+export function onInterrupt<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>
+): Fx<R | R2, E, A> {
+  return middleware(fx, Effect.onInterrupt(f))
+}
+
+export function onError<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>
+): Fx<R | R2, E, A> {
+  return middleware(fx, Effect.onError(f))
+}
+
+export const scoped = <R, E, A>(fx: Fx<R, E, A>): Fx<Exclude<R, Scope.Scope>, E, A> => middleware(fx, Effect.scoped)
+
+export function annotateLogs<R, E, A>(
+  fx: Fx<R, E, A>,
+  key: string | Record<string, unknown>,
+  value?: unknown
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.annotateLogs(effect, key as string, value as unknown))
+}
+
+export function annotateSpans<R, E, A>(
+  fx: Fx<R, E, A>,
+  key: string | Record<string, unknown>,
+  value?: unknown
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.annotateSpans(effect, key as string, value as unknown))
+}
+
+export const interruptible = <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => middleware(fx, Effect.interruptible)
+
+export const uninterruptible = <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => middleware(fx, Effect.uninterruptible)
+
+export function locally<R, E, B, A>(
+  use: Fx<R, E, B>,
+  self: FiberRef.FiberRef<A>,
+  value: A
+): Fx<R, E, B> {
+  return middleware(use, (effect) => Effect.locally(effect, self, value))
+}
+
+export function locallyWith<R, E, B, A>(
+  use: Fx<R, E, B>,
+  self: FiberRef.FiberRef<A>,
+  f: (a: A) => A
+): Fx<R, E, B> {
+  return middleware(use, (effect) => Effect.locallyWith(effect, self, f))
+}
+
+export function withTracerTiming<R, E, A>(
+  fx: Fx<R, E, A>,
+  enabled: boolean
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withTracerTiming(effect, enabled))
+}
+
+export function withConcurrency<R, E, A>(
+  fx: Fx<R, E, A>,
+  concurrency: number | "unbounded"
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withConcurrency(effect, concurrency))
+}
+
+export function withConfigProvider<R, E, A>(
+  fx: Fx<R, E, A>,
+  configProvider: ConfigProvider.ConfigProvider
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withConfigProvider(effect, configProvider))
+}
+
+export function withLogSpan<R, E, A>(
+  fx: Fx<R, E, A>,
+  span: string
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withLogSpan(effect, span))
+}
+
+export function withMaxOpsBeforeYield<R, E, A>(
+  fx: Fx<R, E, A>,
+  maxOps: number
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withMaxOpsBeforeYield(effect, maxOps))
+}
+
+export function withParentSpan<R, E, A>(
+  fx: Fx<R, E, A>,
+  parentSpan: Tracer.ParentSpan
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withParentSpan(effect, parentSpan))
+}
+
+export function withRequestBatching<R, E, A>(
+  fx: Fx<R, E, A>,
+  requestBatching: boolean
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withRequestBatching(effect, requestBatching))
+}
+
+export function withRequestCache<R, E, A>(
+  fx: Fx<R, E, A>,
+  cache: Request.Cache
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withRequestCache(effect, cache))
+}
+
+export function withRequestCaching<R, E, A>(
+  fx: Fx<R, E, A>,
+  requestCaching: boolean
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withRequestCaching(effect, requestCaching))
+}
+
+export function withScheduler<R, E, A>(
+  fx: Fx<R, E, A>,
+  scheduler: Scheduler.Scheduler
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withScheduler(effect, scheduler))
+}
+
+export function withTracer<R, E, A>(
+  fx: Fx<R, E, A>,
+  tracer: Tracer.Tracer
+): Fx<R, E, A> {
+  return middleware(fx, (effect) => Effect.withTracer(effect, tracer))
+}
+
+class Middleware<R, E, A, R2> extends FxBase<R2, E, A> {
+  constructor(
+    readonly i0: Fx<R, E, A>,
+    readonly i1: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
+    readonly i2?: (sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>
+  ) {
+    super()
+  }
+
+  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<R2 | R3, never, unknown> {
+    return Effect.contextWithEffect((ctx) => {
+      const s = Sink.provide(sink, ctx)
+
+      return this.i1(this.i0.run(this.i2 ? this.i2(s) : s))
+    })
+  }
+}
+
+export function acquireUseRelease<R, E, A, R2, E2, B, R3, E3, C>(
+  acquire: Effect.Effect<R, E, A>,
+  use: (a: A) => Fx<R2, E2, B>,
+  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>
+): Fx<R | R2 | R3, E | E2 | E3, B> {
+  return new AcquireUseRelease(acquire, use, release)
+}
+
+class AcquireUseRelease<R, E, A, R2, E2, B, R3, E3, C> extends FxBase<R | R2 | R3, E | E2 | E3, B> {
+  constructor(
+    readonly acquire: Effect.Effect<R, E, A>,
+    readonly use: (a: A) => Fx<R2, E2, B>,
+    readonly release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>
+  ) {
+    super()
+  }
+
+  run<R4>(sink: Sink.Sink<R4, E | E2 | E3, B>): Effect.Effect<R | R2 | R3 | R4, never, unknown> {
+    return Effect.catchAllCause(
+      Effect.acquireUseRelease(
+        this.acquire,
+        (a) => this.use(a).run(sink),
+        (a, exit) => Effect.catchAllCause(this.release(a, exit), (cause) => sink.onFailure(cause))
+      ),
+      (cause) => sink.onFailure(cause)
+    )
+  }
+}
+
+export function withSpan<R, E, A>(
+  self: Fx<R, E, A>,
+  name: string,
+  options: {
+    readonly attributes?: Record<string, unknown>
+    readonly links?: ReadonlyArray<Tracer.SpanLink>
+    readonly parent?: Tracer.ParentSpan
+    readonly root?: boolean
+    readonly context?: Context.Context<never>
+  } = {}
+): Fx<R, E, A> {
+  return acquireUseRelease(
+    Effect.flatMap(
+      Effect.optionFromOptional(Effect.currentSpan),
+      (parent) => Effect.makeSpan(name, { ...options, parent: options?.parent || Option.getOrUndefined(parent) } as any)
+    ),
+    (span) =>
+      middleware(
+        self,
+        (effect) => Effect.provideService(effect, Tracer.ParentSpan, span),
+        (s) => Sink.setSpan(s, span)
+      ),
+    (span, exit) => Effect.flatMap(Clock.currentTimeNanos, (time) => Effect.sync(() => span.end(time, exit)))
+  )
+}
+
+export function provideContext<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  context: Context.Context<R2>
+): Fx<Exclude<R, R2>, E, A> {
+  return ProvideFx.make(fx, Provide.ProvideContext(context))
+}
+
+export function provideLayer<R, E, A, R2, E2, S>(
+  fx: Fx<R, E, A>,
+  layer: Layer.Layer<R2, E2, S>
+): Fx<R2 | Exclude<R, S>, E | E2, A> {
+  return ProvideFx.make(fx, Provide.ProvideLayer(layer))
+}
+
+export function provideRuntime<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  runtime: Runtime.Runtime<R2>
+): Fx<Exclude<R, R2>, E, A> {
+  return ProvideFx.make(fx, Provide.ProvideRuntime(runtime))
+}
+
+export function provideService<R, E, A, I, S>(
+  fx: Fx<R, E, A>,
+  service: Context.Tag<I, S>,
+  instance: S
+): Fx<Exclude<R, I>, E, A> {
+  return ProvideFx.make(fx, Provide.ProvideService(service, instance))
+}
+
+export function provideServiceEffect<R, E, A, I, S, R2, E2>(
+  fx: Fx<R, E, A>,
+  service: Context.Tag<I, S>,
+  instance: Effect.Effect<R2, E2, S>
+): Fx<Exclude<R, I> | R2, E | E2, A> {
+  return ProvideFx.make(fx, Provide.ProvideServiceEffect(service, instance))
+}
+
+export function provide<R, E, A, R2 = never, E2 = never, S = never>(
+  fx: Fx<R, E, A>,
+  provide: Layer.Layer<R2, E2, S> | Context.Context<S> | Runtime.Runtime<S>
+): Fx<Exclude<R, S> | R2, E | E2, A> {
+  if (Layer.isLayer(provide)) return provideLayer(fx, provide as Layer.Layer<R2, E2, S>)
+  else if (Context.isContext(provide)) return provideContext(fx, provide as Context.Context<S>)
+  else return provideRuntime(fx, provide as Runtime.Runtime<S>)
+}
+
+class ProvideFx<R, E, A, R2, E2, S> extends FxBase<R2 | Exclude<R, S>, E | E2, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Provide.Provide<R2, E2, S>) {
+    super()
+  }
+
+  run<R3>(sink: Sink.Sink<R3, E | E2, A>): Effect.Effect<R2 | R3 | Exclude<R, S>, never, unknown> {
+    return Effect.acquireUseRelease(
+      Scope.make(),
+      (scope) =>
+        Effect.matchEffect(Provide.buildWithScope(this.i1, scope), {
+          onFailure: (error) => sink.onFailure(Cause.fail(error)),
+          onSuccess: (ctx) => Effect.provide(this.i0.run(sink), ctx)
+        }),
+      (scope, exit) => Scope.close(scope, exit)
+    )
+  }
+
+  static make<R, E, A, R2, E2, S>(
+    fx: Fx<R, E, A>,
+    provide: Provide.Provide<R2, E2, S>
+  ): Fx<Exclude<R, S> | R2, E | E2, A> {
+    if (isEmpty(fx) || isNever(fx)) return fx
+    else if (isProvideFx(fx)) {
+      return new ProvideFx(fx.i0, Provide.merge(fx.i1, provide))
+    } else {
+      return new ProvideFx(fx, provide)
+    }
+  }
+}
+
+function isProvideFx<R, E, A>(u: Fx<R, E, A>): u is ProvideFx<R, E, A, R, E, never> {
+  return u.constructor === ProvideFx
+}
+
+export function mapCause<R, E, A, E2>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Cause.Cause<E2>
+): Fx<R, E2, A> {
+  return new TransformerCause(fx, SyncOp.Map(f))
+}
+
+export function mapError<R, E, A, E2>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => E2
+): Fx<R, E2, A> {
+  return mapCause(fx, Cause.map(f))
+}
+
+export function filterCause<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => boolean
+): Fx<R, E, A> {
+  return new TransformerCause(fx, SyncOp.Filter(f))
+}
+
+export function filterError<R, E, A>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => boolean
+): Fx<R, E, A> {
+  return filterCause(fx, (cause) =>
+    Option.match(Cause.failureOption(cause), {
+      onNone: constTrue,
+      onSome: f
+    }))
+}
+
+export function filterMapCause<R, E, A, E2>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>
+): Fx<R, E2, A> {
+  return new TransformerCause(fx, SyncOp.FilterMap(f))
+}
+
+export function filterMapError<R, E, A, E2>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Option.Option<E2>
+): Fx<R, E2, A> {
+  return filterMapCause(fx, (cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: (e) => Option.map(f(e), Cause.fail),
+      onRight: Option.some
+    }))
+}
+
+export function mapCauseEffect<R, E, A, R2, E2, E3>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Cause.Cause<E3>>
+): Fx<R | R2, E2 | E3, A> {
+  return new TransformerCause(fx, EffectOp.MapEffect(f))
+}
+
+export function mapErrorEffect<R, E, A, R2, E2, E3>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Effect.Effect<R2, E2, E3>
+): Fx<R | R2, E2 | E3, A> {
+  return mapCauseEffect(fx, (cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: (e) => Effect.map(f(e), Cause.fail),
+      onRight: (cause) => Effect.succeed(cause)
+    }))
+}
+
+export function filterCauseEffect<R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, boolean>
+): Fx<R | R2, E2, A> {
+  return new TransformerCause(fx, EffectOp.FilterEffect(f))
+}
+
+export function filterErrorEffect<R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Effect.Effect<R2, E2, boolean>
+): Fx<R | R2, E2, A> {
+  return filterCauseEffect(fx, (cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: f,
+      onRight: () => Effect.succeed(true)
+    }))
+}
+
+export function filterMapCauseEffect<R, E, A, R2, E2, E3>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Option.Option<Cause.Cause<E3>>>
+): Fx<R | R2, E2 | E3, A> {
+  return new TransformerCause(fx, EffectOp.FilterMapEffect(f))
+}
+
+export function filterMapErrorEffect<R, E, A, R2, E2, E3>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Effect.Effect<R2, E2, Option.Option<E3>>
+): Fx<R | R2, E2 | E3, A> {
+  return filterMapCauseEffect(fx, (cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: (e) => Effect.map(f(e), Option.map(Cause.fail)),
+      onRight: (cause) => Effect.succeed(Option.some(cause))
+    }))
+}
+
+export function loopCause<R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]
+): Fx<R, C, A> {
+  return new TransformerCause(fx, SyncLoopOp.LoopOperator(seed, f))
+}
+
+export function loopError<R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, e: E) => readonly [C, B]
+): Fx<R, C, A> {
+  return loopCause(fx, seed, (b, cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: (e) => {
+        const [c, b2] = f(b, e)
+        return [Cause.fail(c), b2]
+      },
+      onRight: (cause) => [cause, b]
+    }))
+}
+
+export function loopCauseEffect<R, E, A, R2, E2, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Cause.Cause<C>, B]>
+): Fx<R | R2, E2 | C, A> {
+  return new TransformerCause(fx, EffectLoopOp.LoopEffectOperator(seed, f))
+}
+
+export function loopErrorEffect<R, E, A, R2, E2, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [C, B]>
+) {
+  return loopCauseEffect(fx, seed, (b, cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: (e) => Effect.map(f(b, e), ([c, b2]) => [Cause.fail(c), b2]),
+      onRight: (cause) => Effect.succeed([cause, b])
+    }))
+}
+
+export function filterMapLoopCause<R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, cause: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B]
+): Fx<R, C, A> {
+  return new TransformerCause(fx, SyncLoopOp.FilterMapLoopOperator(seed, f))
+}
+
+export function filterMapLoopError<R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, e: E) => readonly [Option.Option<C>, B]
+) {
+  return filterMapLoopCause(fx, seed, (b, cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: (e) => {
+        const [c, b2] = f(b, e)
+        return [Option.map(Cause.fail)(c), b2]
+      },
+      onRight: (cause) => [Option.some(cause), b]
+    }))
+}
+
+export function filterMapLoopCauseEffect<R, E, A, R2, E2, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>
+): Fx<R | R2, E2 | C, A> {
+  return new TransformerCause(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f))
+}
+
+export function filterMapLoopErrorEffect<R, E, A, R2, E2, B, C>(
+  fx: Fx<R, E, A>,
+  seed: B,
+  f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>
+) {
+  return filterMapLoopCauseEffect(fx, seed, (b, cause) =>
+    Either.match(Cause.failureOrCause(cause), {
+      onLeft: (e) => Effect.map(f(b, e), ([c, b2]) => [Option.map(c, Cause.fail), b2]),
+      onRight: (cause) => Effect.succeed([Option.some(cause), b])
+    }))
+}
+
+class TransformerCause<R, E, A, R2, E2> extends FxBase<R | R2, E2, A> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Op.Operator) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, E2, A>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0.run(Op.compileOperatorSinkCause(this.i1, sink))
+  }
+}
+
+export function flatMapCauseWithStrategy<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  flattenStrategy: FlattenStrategy,
+  executionStrategy: ExecutionStrategy.ExecutionStrategy = ExecutionStrategy.sequential
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return new FlatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy)
+}
+
+export function flatMapErrorWithStrategy<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+  flattenStrategy: FlattenStrategy,
+  executionStrategy: ExecutionStrategy.ExecutionStrategy = ExecutionStrategy.sequential
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapCauseWithStrategy(
+    fx,
+    (cause) =>
+      Either.match(Cause.failureOrCause(cause), {
+        onLeft: f,
+        onRight: (cause) => failCause(cause)
+      }),
+    flattenStrategy,
+    executionStrategy
+  )
+}
+
+export function switchMapCause<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapCauseWithStrategy(fx, f, Switch, executionStrategy)
+}
+
+export function switchMapError<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapErrorWithStrategy(fx, f, Switch, executionStrategy)
+}
+
+export function flatMapCause<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapCauseWithStrategy(fx, f, Unbounded, executionStrategy)
+}
+
+export function flatMapError<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapErrorWithStrategy(fx, f, Unbounded, executionStrategy)
+}
+
+export function flatMapCauseConcurrently<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  concurrency: number,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapCauseWithStrategy(fx, f, Bounded(concurrency), executionStrategy)
+}
+
+export function flatMapErrorConcurrently<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+  concurrency: number,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapErrorWithStrategy(fx, f, Bounded(concurrency), executionStrategy)
+}
+
+export function exhaustMapCause<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapCauseWithStrategy(fx, f, Exhaust, executionStrategy)
+}
+
+export function exhaustMapError<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapErrorWithStrategy(fx, f, Exhaust, executionStrategy)
+}
+
+export function exhaustMapLatestCause<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapCauseWithStrategy(fx, f, ExhaustLatest, executionStrategy)
+}
+
+export function exhaustMapLatestError<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+  executionStrategy?: ExecutionStrategy.ExecutionStrategy
+): Fx<R | R2 | Scope.Scope, E2, A | B> {
+  return flatMapErrorWithStrategy(fx, f, ExhaustLatest, executionStrategy)
+}
+
+class FlatMapCauseWithStrategy<
+  R,
+  E,
+  A,
+  R2,
+  E2,
+  B
+> extends FxBase<R | R2 | Scope.Scope, E2, A | B> {
+  private withFork: <R, E, A>(
+    f: (
+      fork: FxFork,
+      scope: Scope.Scope
+    ) => Effect.Effect<R, E, A>,
+    executionStrategy: ExecutionStrategy.ExecutionStrategy
+  ) => Effect.Effect<Scope.Scope | R, E, void>
+
+  constructor(
+    readonly i0: Fx<R, E, A>,
+    readonly i1: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    readonly i2: FlattenStrategy,
+    readonly i3: ExecutionStrategy.ExecutionStrategy
+  ) {
+    super()
+
+    this.withFork = withFlattenStrategy(this.i2)
+  }
+
+  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+    return this.withFork(
+      (fork) => this.i0.run(Sink.make((cause) => fork(this.i1(cause).run(sink)), (a) => sink.onSuccess(a))),
+      this.i3
+    )
+  }
+}
+
+class MatchWithStrategy<
+  R,
+  E,
+  A,
+  R2,
+  E2,
+  B,
+  R3,
+  E3,
+  C
+> extends FxBase<R | R2 | R3 | Scope.Scope, E2 | E3, B | C> {
+  private withFork: <R, E, A>(
+    f: (
+      fork: FxFork,
+      scope: Scope.Scope
+    ) => Effect.Effect<R, E, A>,
+    executionStrategy: ExecutionStrategy.ExecutionStrategy
+  ) => Effect.Effect<Scope.Scope | R, E, void>
+
+  constructor(
+    readonly i0: Fx<R, E, A>,
+    readonly i1: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    readonly i2: (a: A) => Fx<R3, E3, C>,
+    readonly i3: FlattenStrategy,
+    readonly i4: ExecutionStrategy.ExecutionStrategy
+  ) {
+    super()
+
+    this.withFork = withFlattenStrategy(this.i3)
+  }
+
+  run<R4>(sink: Sink.Sink<R4, E2 | E3, B | C>): Effect.Effect<R | R2 | R3 | R4 | Scope.Scope, never, unknown> {
+    return this.withFork(
+      (fork) =>
+        this.i0.run(Sink.make(
+          (cause) => fork(this.i1(cause).run(sink)),
+          (a) => fork(this.i2(a).run(sink))
+        )),
+      this.i4
+    )
+  }
+}
+
+export type MatchCauseOptions<E, A, R2, E2, B, R3, E3, C> = {
+  readonly onFailure: (cause: Cause.Cause<E>) => Fx<R2, E2, B>
+  readonly onSuccess: (a: A) => Fx<R3, E3, C>
+  readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+}
+
+export function matchCauseWithStrategy<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  flattenStrategy: FlattenStrategy,
+  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C> {
+  return new MatchWithStrategy(
+    fx,
+    opts.onFailure,
+    opts.onSuccess,
+    flattenStrategy,
+    opts.executionStrategy || ExecutionStrategy.sequential
+  )
+}
+
+export type MatchErrorOptions<E, A, R2, E2, B, R3, E3, C> = {
+  readonly onFailure: (e: E) => Fx<R2, E2, B>
+  readonly onSuccess: (a: A) => Fx<R3, E3, C>
+  readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
+}
+
+export function matchErrorWithStrategy<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  flattenStrategy: FlattenStrategy,
+  { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C> {
+  return new MatchWithStrategy(
+    fx,
+    (cause) =>
+      Either.match(Cause.failureOrCause(cause), {
+        onLeft: onFailure,
+        onRight: (cause) => failCause(cause)
+      }),
+    onSuccess,
+    flattenStrategy,
+    executionStrategy || ExecutionStrategy.sequential
+  )
+}
+
+export function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchCauseWithStrategy(fx, Unbounded, opts)
+}
+
+export function matchError<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchErrorWithStrategy(fx, Unbounded, opts)
+}
+
+export function matchCauseConcurrently<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  concurrency: number,
+  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchCauseWithStrategy(fx, Bounded(concurrency), opts)
+}
+
+export function matchErrorConcurrently<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  concurrency: number,
+  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchErrorWithStrategy(fx, Bounded(concurrency), opts)
+}
+
+export function switchMatchCause<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchCauseWithStrategy(fx, Switch, opts)
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
+export function switchMatchError<R, E, A, R2, E2, B, R3, E3, C>(
   fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Unbounded
-  })
-})
+  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchErrorWithStrategy(fx, Switch, opts)
+}
 
-export const match: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+export function exhaustMatchCause<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchCauseWithStrategy(fx, Exhaust, opts)
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
+export function exhaustMatchError<R, E, A, R2, E2, B, R3, E3, C>(
   fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (error: E) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchErrorWithStrategy(
-    fx,
-    { ...options, strategy: strategies.Unbounded }
-  )
-})
-
-export const matchCauseConcurrently: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchErrorWithStrategy(fx, Exhaust, opts)
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
+export function exhaustMatchLatestCause<R, E, A, R2, E2, B, R3, E3, C>(
   fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    readonly concurrency: number
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchCauseWithStrategy(fx, {
-    onFailure: options.onFailure,
-    onSuccess: options.onSuccess,
-    strategy: strategies.Bounded(options.concurrency)
-  })
-})
-
-export const matchErrorConcurrently: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchCauseWithStrategy(fx, ExhaustLatest, opts)
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-      readonly concurrency: number
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchErrorConcurrently<R, E, A, R2, E2, B, R3, E3, C>(
+export function exhaustMatchLatestError<R, E, A, R2, E2, B, R3, E3, C>(
   fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (error: E) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    readonly concurrency: number
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchErrorWithStrategy(
-    fx,
-    { ...options, strategy: strategies.Bounded(options.concurrency) }
-  )
-})
+  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+) {
+  return matchErrorWithStrategy(fx, ExhaustLatest, opts)
+}
 
-export const switchMatchCause: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+export function tuple<const FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+): Fx<
+  Fx.Context<FX[number]>,
+  Fx.Error<FX[number]>,
+  {
+    readonly [K in keyof FX]: Fx.Success<FX[K]>
+  }
+> {
+  return new Tuple(fx)
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
+class Tuple<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
+  Fx.Context<FX[number]>,
+  Fx.Error<FX[number]>,
+  {
+    readonly [K in keyof FX]: Fx.Success<FX[K]>
+  }
+> {
+  constructor(readonly i0: FX) {
+    super()
   }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Switch
-  })
-})
 
-export const switchMatch: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+  run<R2>(
+    sink: Sink.Sink<R2, Fx.Error<FX[number]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }>
+  ): Effect.Effect<Fx.Context<FX[number]> | R2, never, unknown> {
+    return tupleSink(
+      sink,
+      (onSuccess) =>
+        Effect.forEach(
+          this.i0,
+          (fx, i) =>
+            fx.run(
+              Sink.make(
+                sink.onFailure,
+                (a) => onSuccess(i, a)
+              )
+            ),
+          UNBOUNDED
+        ),
+      this.i0.length
+    )
+  }
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (error: E) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
+export function struct<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
+  fx: FX
+): Fx<
+  Fx.Context<FX[string]>,
+  Fx.Error<FX[string]>,
+  {
+    readonly [K in keyof FX]: Fx.Success<FX[K]>
   }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchErrorWithStrategy(
-    fx,
-    { ...options, strategy: strategies.Switch }
-  )
-})
+> {
+  const entries: ReadonlyArray<readonly [keyof FX, FX[keyof FX]]> = Object.entries(fx) as any
 
-export const exhaustMatchCause: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+  return map(tuple(entries.map(([key, fx]) => map(fx, (a) => [key, a] as const))), Object.fromEntries)
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Exhaust
-  })
-})
+export function all<const FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+): Fx<
+  Fx.Context<FX[number]>,
+  Fx.Error<FX[number]>,
+  { readonly [K in keyof FX]: Fx.Success<FX[K]> }
+>
 
-export const exhaustMatch: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+export function all<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
+  fx: FX
+): Fx<
+  Fx.Context<FX[string]>,
+  Fx.Error<FX[string]>,
+  { readonly [K in keyof FX]: Fx.Success<FX[K]> }
+>
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (error: E) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchErrorWithStrategy(
-    fx,
-    { ...options, strategy: strategies.Exhaust }
-  )
-})
+export function all<const FX extends ReadonlyArray<Fx<any, any, any> | Readonly<Record<string, Fx<any, any, any>>>>>(
+  fx: FX
+): Fx<
+  Fx.Context<FX[keyof FX]>,
+  Fx.Error<FX[keyof FX]>,
+  any
+> {
+  if (Array.isArray(fx)) return tuple(fx)
+  else return struct(fx as any) as any
+}
 
-export const exhaustLatestMatchCause: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+export function exit<R, E, A>(
+  fx: Fx<R, E, A>
+): Fx<R, never, Exit.Exit<E, A>> {
+  return new ExitFx(fx)
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
+class ExitFx<R, E, A> extends FxBase<R, never, Exit.Exit<E, A>> {
+  constructor(readonly i0: Fx<R, E, A>) {
+    super()
   }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.ExhaustLatest
-  })
-})
 
-export const exhaustLatestMatch: {
-  <E, R2, E2, B, A, R3, E3, C>(
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>
+  run<R2>(sink: Sink.Sink<R2, never, Exit.Exit<E, A>>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0.run(
+      Sink.make((cause) => sink.onSuccess(Exit.failCause(cause)), (a) => sink.onSuccess(Exit.succeed(a)))
+    )
+  }
+}
 
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    options: {
-      readonly onFailure: (error: E) => FxInput<R2, E2, B>
-      readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-    }
-  ): Fx<R | R2 | R3, E2 | E3, B | C>
-} = dual(2, function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
+export function toEnqueue<R, E, A, R2 = never>(
   fx: Fx<R, E, A>,
-  options: {
-    readonly onFailure: (error: E) => FxInput<R2, E2, B>
-    readonly onSuccess: (a: A) => FxInput<R3, E3, C>
-  }
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return matchErrorWithStrategy(
-    fx,
-    { ...options, strategy: strategies.ExhaustLatest }
-  )
-})
+  queue: Context.Enqueue<R2, A> | Queue.Enqueue<A>
+) {
+  return observe(fx, (a) => queue.offer(a))
+}
 
-export const withEarlyExit = <R, E, A>(
-  f: (params: WithEarlyExitParams<E, A>) => Effect.Effect<R, never, unknown>
-): Fx<R, E, A> => new WithEarlyExit(f)
+export function debounce<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A> {
+  return switchMapEffect(fx, (a) => Effect.as(Effect.sleep(delay), a))
+}
 
-export const withScopedFork = <R, E, A>(
-  f: (params: WithScopedForkParams<E, A>) => Effect.Effect<R, never, unknown>
-): Fx<R, E, A> => new WithScopedFork(f)
+export function throttle<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A> {
+  return exhaustMapEffect(fx, (a) => Effect.as(Effect.sleep(delay), a))
+}
 
-export const withFlattenStrategy = <R, E, A>(
-  f: (params: WithFlattenStrategyParams<E, A>) => Effect.Effect<R, never, unknown>,
-  strategy: FlattenStrategy
-): Fx<R, E, A> => new WithFlattenStrategy(f, strategy)
+export function throttleLatest<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A> {
+  return exhaustMapLatestEffect(fx, (a) => Effect.as(Effect.sleep(delay), a))
+}
 
-export const during: {
-  <R2, E2, R3, E3>(
-    window: Fx<R2, E2, Fx<R3, E3, unknown>>
-  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, A>
+export function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Fx<never, never, A> {
+  return new FromAsyncIterable(iterable)
+}
 
-  <R, E, A, R2, E2, R3, E3>(
-    fx: Fx<R, E, A>,
-    window: Fx<R2, E2, Fx<R3, E3, unknown>>
-  ): Fx<R | R2 | R3, E | E2 | E3, A>
-} = dual(2, function during<R, E, A, R2, E2, R3, E3>(
-  fx: Fx<R, E, A>,
-  window: Fx<R2, E2, Fx<R3, E3, unknown>>
-): Fx<R | R2 | R3, E | E2 | E3, A> {
-  return withEarlyExit(({ fork, sink }) =>
-    Effect.suspend(() => {
-      let taking = false
+class FromAsyncIterable<A> extends FxBase<never, never, A> {
+  constructor(readonly i0: AsyncIterable<A>) {
+    super()
+  }
+
+  run<R>(sink: Sink.Sink<R, never, A>): Effect.Effect<R, never, unknown> {
+    return Effect.asyncEffect((cb) => {
+      const iterator = this.i0[Symbol.asyncIterator]()
+      const loop = (result: IteratorResult<A>): Effect.Effect<R, never, unknown> =>
+        result.done
+          ? Effect.sync(() => cb(Effect.unit))
+          : Effect.zipRight(sink.onSuccess(result.value), Effect.flatMap(Effect.promise(() => iterator.next()), loop))
 
       return Effect.flatMap(
-        fork(run(
-          take(window, 1),
-          Sink.WithContext(sink.onFailure, (nested) => {
-            taking = true
-            return fork(run(take(nested, 1), Sink.WithContext(sink.onFailure, () => sink.earlyExit)))
-          })
-        )),
-        () =>
-          adjustTime(1).pipe(Effect.zipRight(run(
-            fx,
-            Sink.Sink(
-              sink.onFailure,
-              (a) => taking ? sink.onSuccess(a) : Effect.unit
-            )
-          )))
+        Effect.promise(() => iterator.next()),
+        loop
       )
     })
+  }
+}
+
+export function findFirst<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Effect.Effect<R, E, A> {
+  return Effect.asyncEffect((cb) =>
+    observe(fx, (a) => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.unit)
   )
-})
+}
 
-export const since: {
-  <R2, E2>(window: Fx<R2, E2, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, window: Fx<R2, E2, unknown>): Fx<R | R2, E | E2, A>
-} = dual(2, function since<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  window: Fx<R2, E2, unknown>
-): Fx<R | R2, E | E2, A> {
-  return during(fx, map(window, () => never))
-})
+export function first<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, A> {
+  return findFirst(fx, constTrue)
+}
+
+export function either<R, E, A>(fx: Fx<R, E, A>): Fx<R, never, Either.Either<E, A>> {
+  return new EitherFx(fx)
+}
 
-export const until: {
-  <R2, E2>(window: Fx<R2, E2, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, window: Fx<R2, E2, unknown>): Fx<R | R2, E | E2, A>
-} = dual(2, function until<R, E, A, R2, E2>(
+class EitherFx<R, E, A> extends FxBase<R, never, Either.Either<E, A>> {
+  constructor(readonly i0: Fx<R, E, A>) {
+    super()
+  }
+
+  run<R2>(sink: Sink.Sink<R2, never, Either.Either<E, A>>): Effect.Effect<R | R2, never, unknown> {
+    return this.i0.run(
+      Sink.make(
+        (cause) =>
+          Either.match(Cause.failureOrCause(cause), {
+            onLeft: (e) => sink.onSuccess(Either.left(e)),
+            onRight: (cause) => sink.onFailure(cause)
+          }),
+        (a) => sink.onSuccess(Either.right(a))
+      )
+    )
+  }
+}
+
+export function mergeFirst<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
-  window: Fx<R2, E2, unknown>
+  that: Fx<R2, E2, B>
 ): Fx<R | R2, E | E2, A> {
-  return during(fx, succeed(window))
-})
-
-export const fromScheduled: {
-  <R2>(scheduled: Schedule.Schedule<R2, unknown, unknown>): <R, E, A>(fx: Effect.Effect<R, E, A>) => Fx<R | R2, E, A>
-  <R, E, A, R2>(fx: Effect.Effect<R, E, A>, scheduled: Schedule.Schedule<R2, unknown, unknown>): Fx<R | R2, E, A>
-} = dual(2, function fromScheduled<R, E, A, R2>(
-  fx: Effect.Effect<R, E, A>,
-  scheduled: Schedule.Schedule<R2, unknown, unknown>
-): Fx<R | R2, E, A> {
-  return fromSink((sink) =>
-    Effect.catchAllCause(Effect.repeat(Effect.matchCauseEffect(fx, sink), scheduled), sink.onFailure)
-  )
-})
-
-export const periodic: {
-  (duration: DurationInput): <R, E, A>(fx: Effect.Effect<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Effect.Effect<R, E, A>, duration: DurationInput): Fx<R, E, A>
-} = dual(2, function periodic<R, E, A>(
-  fx: Effect.Effect<R, E, A>,
-  duration: DurationInput
-): Fx<R, E, A> {
-  return fromScheduled(fx, Schedule.spaced(duration))
-})
-
-export const provide: {
-  <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E | E2, A>
-  <R2>(runtime: Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
-  <R2>(context: Context<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>
-  <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, S>): Fx<Exclude<R, S> | R2, E | E2, A>
-  <R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime<R2>): Fx<Exclude<R, R2>, E, A>
-  <R, E, A, R2>(fx: Fx<R, E, A>, context: Context<R2>): Fx<Exclude<R, R2>, E, A>
-} = dual(2, function provideContext<R, E, A, R2, E2, S>(
-  fx: Fx<R, E, A>,
-  context: Context<S> | Layer.Layer<R2, E2, S> | Runtime<S>
-): Fx<R2 | Exclude<R, S>, E, A> {
-  if (Layer.isLayer(context)) {
-    return FxProvide.make(fx, Provide.ProvideLayer(context)) as any
-  } else if (isContext(context)) {
-    return FxProvide.make(fx, Provide.ProvideContext(context as Context<S>))
-  } else {
-    return FxProvide.make(fx, Provide.ProvideRuntime(context as Runtime<S>))
-  }
-})
-
-export const provideService: {
-  <I, S>(tag: Tag<I, S>, service: S): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, I>, E, A>
-  <R, E, A, I, S>(fx: Fx<R, E, A>, tag: Tag<I, S>, service: S): Fx<Exclude<R, I>, E, A>
-} = dual(3, function provideService<R, E, A, I, S>(
-  fx: Fx<R, E, A>,
-  tag: Tag<I, S>,
-  service: S
-): Fx<Exclude<R, I>, E, A> {
-  return FxProvide.make(fx, Provide.ProvideService(tag, service))
-})
-
-export const provideServiceEffect: {
-  <I, S, R2, E2>(
-    tag: Tag<I, S>,
-    service: Effect.Effect<R2, E2, S>
-  ): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, I>, E, A>
-  <R, E, A, I, S, R2, E2>(
-    fx: Fx<R, E, A>,
-    tag: Tag<I, S>,
-    service: Effect.Effect<R2, E2, S>
-  ): Fx<R2 | Exclude<R, I>, E, A>
-} = dual(3, function provideService<R, E, A, I, S, R2, E2>(
-  fx: Fx<R, E, A>,
-  tag: Tag<I, S>,
-  service: Effect.Effect<R2, E2, S>
-): Fx<Exclude<R, I> | R2, E | E2, A> {
-  return FxProvide.make(fx, Provide.ProvideServiceEffect(tag, service))
-})
+  return merge(fx, filter(that, constFalse) as Fx<R2, E2, never>)
+}
 
-export const skipRepeatsWith: {
-  <A>(eq: Equivalence<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): Fx<R, E, A>
-} = dual(2, function skipRepeatsWith<R, E, A>(
+export function mergeRace<R, E, A, R2, E2, B>(
   fx: Fx<R, E, A>,
-  eq: Equivalence<A>
-): Fx<R, E, A> {
-  return FilterMapLoop.make(fx, Option.none<A>(), (previous, a) =>
-    Option.match(previous, {
-      onNone: () => Option.some([a, Option.some(a)]),
-      onSome: (prev) => eq(a, prev) ? Option.none() : Option.some([a, Option.some(a)])
-    }))
-})
-
-export const skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = (fx) => skipRepeatsWith(fx, Equal.equals)
+  that: Fx<R2, E2, B>
+): Fx<R | R2, E | E2, A | B> {
+  return new MergeRace(fx, that)
+}
 
-class Reduce<R, E, A, B> extends Effectable.Class<R, E, B> {
-  constructor(readonly fx: Fx<R, E, A>, readonly seed: B, readonly f: (acc: B, a: A) => B) {
+class MergeRace<R, E, A, R2, E2, B> extends FxBase<R | R2, E | E2, A | B> {
+  constructor(readonly i0: Fx<R, E, A>, readonly i1: Fx<R2, E2, B>) {
     super()
   }
 
-  static make<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B> {
-    if (fx instanceof Transformer) {
-      return FilterMapReduce.make<R, E, A, B>(fx.i0 as Fx<R, E, any>, seed, compileSyncReducer(fx.i1, f))
-    }
+  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return Effect.gen(this, function*(_) {
+      const fiber1 = yield* _(Effect.fork(this.i0.run(Sink.make(
+        sink.onFailure,
+        (a) => Effect.flatMap(sink.onSuccess(a), () => Fiber.interrupt(fiber2))
+      ))))
+      const fiber2 = yield* _(Effect.fork(this.i1.run(sink)))
 
-    return new Reduce(fx, seed, f)
+      return yield* _(Fiber.joinAll([fiber1, fiber2]))
+    })
   }
+}
 
-  private cached: Effect.Effect<R, E, B> | null = null
-
-  commit() {
-    return (this.cached ||= Effect.suspend(() => {
-      let acc = this.seed
+export function raceAll<const FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: FX
+): Fx<
+  Fx.Context<FX[number]>,
+  Fx.Error<FX[number]>,
+  Fx.Success<FX[number]>
+> {
+  return new RaceAll(fx)
+}
 
-      return Effect.map(observe(this.fx, (a) => Effect.sync(() => acc = this.f(acc, a))), () => acc)
-    }))
-  }
+export function race<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  that: Fx<R2, E2, B>
+): Fx<R | R2, E | E2, A | B> {
+  return raceAll([fx, that])
 }
 
-class FilterMapReduce<R, E, A, B> extends Effectable.Class<R, E, B> {
-  constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: B,
-    readonly i2: (b: B, a: A) => Option.Option<B>
-  ) {
+class RaceAll<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
+  Fx.Context<FX[number]>,
+  Fx.Error<FX[number]>,
+  Fx.Success<FX[number]>
+> {
+  constructor(readonly i0: FX) {
     super()
   }
 
-  static make<R, E, A, B>(
-    fx: Fx<R, E, A>,
-    seed: B,
-    f: (b: B, a: A) => Option.Option<B>
-  ): Effect.Effect<R, E, B> {
-    if (fx instanceof FromIterable) {
-      if (Array.isArray(fx.i0)) {
-        return new OnceEffect(Effect.sync(() => reduceFilterArray(fx.i0 as Array<A>, seed, f)))
-      } else {
-        return Effect.sync(() => reduceFilterIterable(fx.i0, seed, f))
-      }
-    }
+  run<R2>(
+    sink: Sink.Sink<R2, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
+  ): Effect.Effect<Fx.Context<FX[number]> | R2, never, unknown> {
+    return Effect.gen(this, function*(_) {
+      const winner = yield* _(Deferred.make<never, Fiber.RuntimeFiber<never, unknown>>())
+      const fibers: Array<Fiber.RuntimeFiber<never, unknown>> = []
 
-    return new FilterMapReduce(fx, seed, f)
-  }
+      for (const fx of this.i0) {
+        const fiber: Fiber.RuntimeFiber<never, unknown> = yield* _(Effect.fork(fx.run(Sink.make(
+          sink.onFailure,
+          (a) => Effect.flatMap(Deferred.succeed(winner, fiber), () => sink.onSuccess(a))
+        ))))
+        fibers.push(fiber)
+      }
 
-  private cached: Effect.Effect<R, E, B> | null = null
+      const winningFiber = yield* _(Deferred.await(winner))
 
-  commit(): Effect.Effect<R, E, B> {
-    return this.cached ||= Effect.suspend(() => {
-      let acc = this.i1
+      yield* _(Fiber.interruptAll(fibers.filter((x) => x !== winningFiber)))
 
-      return Effect.map(
-        observe(this.i0, (a) =>
-          Option.match(this.i2(acc, a), {
-            onNone: () => Effect.unit,
-            onSome: (b) => Effect.succeed(acc = b)
-          })),
-        () => acc
-      )
+      return yield* _(Fiber.join(winningFiber))
     })
   }
 }
 
-function reduceFilterIterable<A, B>(
-  iterable: Iterable<A>,
-  seed: B,
-  f: (acc: B, a: A) => Option.Option<B>
-): B {
-  const iterator = iterable[Symbol.iterator]()
-  let acc = seed
-  let result = iterator.next()
-  let option: Option.Option<B> = Option.none()
-
-  while (!result.done) {
-    option = f(acc, result.value)
-    if (Option.isSome(option)) {
-      acc = option.value
-    }
-    result = iterator.next()
-  }
-
-  return acc
+export function snapshot<R, E, A, R2, E2, B, C>(
+  fx: Fx<R, E, A>,
+  sampled: Fx<R2, E2, B>,
+  f: (a: A, b: B) => C
+): Fx<R | R2, E | E2, C> {
+  return new Snapshot(fx, sampled, f)
 }
 
-function reduceFilterArray<A, B>(
-  iterable: Array<A>,
-  seed: B,
-  f: (acc: B, a: A) => Option.Option<B>
-): B {
-  const length = iterable.length
-  let acc = seed
-  let option: Option.Option<B> = Option.none()
-
-  for (let i = 0; i < length; i++) {
-    option = f(acc, iterable[i])
-    if (Option.isSome(option)) {
-      acc = option.value
-    }
-  }
-
-  return acc
+export function sample<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  sampled: Fx<R2, E2, B>
+): Fx<R | R2, E | E2, B> {
+  return snapshot(fx, sampled, (_, b) => b)
 }
 
-export const reduce: {
-  <A, B>(seed: B, f: (acc: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B>
-  <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B>
-} = dual(3, function reduce<R, E, A, B>(
-  fx: Fx<R, E, A>,
-  seed: B,
-  f: (acc: B, a: A) => B
-): Effect.Effect<R, E, B> {
-  return Reduce.make(fx, seed, f)
-})
+class Snapshot<R, E, A, R2, E2, B, C> extends FxBase<R | R2, E | E2, C> {
+  constructor(
+    readonly i0: Fx<R, E, A>,
+    readonly i1: Fx<R2, E2, B>,
+    readonly i2: (a: A, b: B) => C
+  ) {
+    super()
+  }
 
-export function toChunk<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, Chunk.Chunk<A>> {
-  return reduce(fx, Chunk.empty<A>(), Chunk.append<A, A>)
+  run<R3>(sink: Sink.Sink<R3, E | E2, C>): Effect.Effect<R | R2 | R3, never, unknown> {
+    return Effect.flatMap(
+      Ref.make(Option.none<B>()),
+      (ref) =>
+        Effect.all([
+          this.i1.run(Sink.make(
+            sink.onFailure,
+            (b) => Ref.set(ref, Option.some(b))
+          )),
+          this.i0.run(Sink.make(
+            sink.onFailure,
+            (a) =>
+              Effect.flatMap(
+                Ref.get(ref),
+                Option.match({
+                  onNone: () => Effect.unit,
+                  onSome: (b) => sink.onSuccess(this.i2(a, b))
+                })
+              )
+          ))
+        ], UNBOUNDED)
+    )
+  }
 }
 
-export const snapshot: {
-  <R2, E2, B, A, R3, E3, C>(
-    sampled: FxInput<R2, E2, B>,
-    f: (a: A, b: B) => Effect.Effect<R3, E3, C>
-  ): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    fx: Fx<R, E, A>,
-    sampled: FxInput<R2, E2, B>,
-    f: (a: A, b: B) => Effect.Effect<R3, E3, C>
-  ): Fx<R | R2 | R3, E | E2 | E3, C>
-} = dual(3, function snapshot<R, E, A, R2, E2, B, R3, E3, C>(
+export function snapshotEffect<R, E, A, R2, E2, B, R3, E3, C>(
   fx: Fx<R, E, A>,
   sampled: Fx<R2, E2, B>,
   f: (a: A, b: B) => Effect.Effect<R3, E3, C>
 ): Fx<R | R2 | R3, E | E2 | E3, C> {
-  return new Snapshot(fx, sampled, f)
-})
-
-export function fromEmitter<R, E, A>(
-  f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R | Scope.Scope, never, unknown>
-): Fx<Exclude<R, Scope.Scope>, E, A> {
-  return withEarlyExit(({ scope, sink }) =>
-    Effect.zipRight(Effect.provideService(Effect.flatMap(Emitter.make(sink), f), Scope.Scope, scope), Effect.never)
-  )
+  return new SnapshotEffect(fx, sampled, f)
 }
 
-export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
-  return matchEffectPrimitive<Fx<R, E, A>>(effect as InternalEffect, {
-    Success: (e) => succeed(e.i0 as A),
-    Failure: (e) => failCause(e.i0 as Cause.Cause<E>),
-    Left: (e) => fail(e.left as E),
-    Right: (e) => succeed(e.right as A),
-    None: () => fail(new Cause.NoSuchElementException() as E),
-    Some: (e) => succeed(e.value),
-    Sync: (e) => sync(e.i0 as () => A),
-    Otherwise: () => fromSink((sink) => Effect.matchCauseEffect(effect, sink))
-  })
-}
+class SnapshotEffect<R, E, A, R2, E2, B, R3, E3, C> extends FxBase<R | R2 | R3, E | E2 | E3, C> {
+  constructor(
+    readonly i0: Fx<R, E, A>,
+    readonly i1: Fx<R2, E2, B>,
+    readonly i2: (a: A, b: B) => Effect.Effect<R3, E3, C>
+  ) {
+    super()
+  }
 
-export function fromStream<R, E, A>(stream: Stream.Stream<R, E, A>, options?: { priority?: number }): Fx<R, E, A> {
-  return fromSink<R, E, A>((sink) =>
-    Effect.acquireUseRelease<never, never, Scope.CloseableScope, R, never, unknown, never, unknown>(
-      Scope.make(),
-      (scope) =>
-        Effect.gen(function*(_) {
-          const pull = Effect.either(yield* _(Stream.toPull(stream), Effect.provideService(Scope.Scope, scope)))
-
-          while (true) {
-            const either = yield* _(pull)
-
-            if (Either.isRight(either)) {
-              yield* _(Effect.forEach(either.right, sink.onSuccess))
-            } else if (Option.isNone(either.left)) {
-              return
-            } else {
-              yield* _(sink.onFailure(Cause.fail(either.left.value)))
-            }
-
-            // Schedule subsequent pulls using the current scheduler.
-            yield* _(Effect.yieldNow(options))
-          }
-        }),
-      Scope.close
+  run<R4>(sink: Sink.Sink<R4, E | E2 | E3, C>): Effect.Effect<R | R2 | R3 | R4, never, unknown> {
+    return Effect.flatMap(
+      Ref.make(Option.none<B>()),
+      (ref) =>
+        Effect.flatMap(
+          Effect.tap(
+            Effect.fork(
+              this.i1.run(Sink.make(
+                sink.onFailure,
+                (b) => Ref.set(ref, Option.some(b))
+              ))
+            ),
+            () =>
+              this.i0.run(Sink.make(sink.onFailure, (a) =>
+                Effect.flatMap(
+                  Ref.get(ref),
+                  Option.match({
+                    onNone: () => Effect.unit,
+                    onSome: (b) => Effect.matchCauseEffect(this.i2(a, b), sink)
+                  })
+                )))
+          ),
+          Fiber.interrupt
+        )
     )
-  )
+  }
+}
+
+function if_<R, E, R2, E2, B, R3, E3, C>(
+  bool: Fx<R, E, boolean>,
+  options: {
+    readonly onTrue: Fx<R2, E2, B>
+    readonly onFalse: Fx<R3, E3, C>
+  }
+): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C> {
+  return switchMap(bool, (b): Fx<R2 | R3, E2 | E3, B | C> => b ? options.onTrue : options.onFalse)
 }
 
-const matchers = {
-  RefSubject: identity,
-  Fx: identity,
-  Effect: fromEffect,
-  Cause: failCause,
-  Iterable: fromIterable,
-  Otherwise: succeed
+export { if_ as if }
+
+export function when<R, E, B, C>(
+  bool: Fx<R, E, boolean>,
+  options: {
+    readonly onTrue: B
+    readonly onFalse: C
+  }
+): Fx<R | Scope.Scope, E, B | C> {
+  return if_(bool, {
+    onTrue: succeed(options.onTrue),
+    onFalse: succeed(options.onFalse)
+  })
 }
 
-export function from<A>(input: Iterable<A>): Fx<never, never, A>
-export function from<E>(input: Cause.Cause<E>): Fx<never, E, never>
-export function from<R, E, A>(input: FxInput<R, E, A>): Fx<R, E, A>
-export function from<A>(input: A): Fx<never, never, A>
-export function from<R, E, A>(input: FxInput<R, E, A>): Fx<R, E, A> {
-  return matchFxInput(input, matchers as any)
+export function mapBoth<R, E, A, B, C>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => B,
+  g: (a: A) => C
+): Fx<R, B, C> {
+  return map(mapError(fx, f), g)
 }