@typed/fx 1.18.4 → 1.20.0

package/dist/esm/internal/core.js

@@ -1,841 +1,1561 @@
-import { Cause, Chunk, Deferred, Effect, Effectable, Either, Equal, Fiber, Layer, Option, Ref, Scope, Stream, SynchronizedRef } from "effect";
-import { dual, identity } from "effect/Function";
-import { isContext } from "@typed/context";
-import * as Schedule from "effect/Schedule";
-import { compileEffectLoop, FilterEffect, FilterMapEffect, liftSyncOperator, MapEffect, TapEffect } from "./effect-operator.js";
-import * as helpers from "./helpers.js";
-import * as Provide from "./provide.js";
-import * as strategies from "./strategies.js";
-import { compileSyncReducer, Filter, FilterMap, Map } from "./sync-operator.js";
-import * as Emitter from "../Emitter.js";
+import * as Context from "@typed/context";
+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 * as Sink from "../Sink.js";
-import { boundsFrom, mergeBounds } from "./bounds.js";
-import { 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";
-const constUnit = () => Effect.unit;
-class Merge extends ToFx {
+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 { 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 { 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 };
+const UNBOUNDED = { concurrency: "unbounded" };
+export function make(run) {
+    return new Make(run);
+}
+class Make extends FxBase {
+    _run;
+    constructor(_run) {
+        super();
+        this._run = _run;
+    }
+    run(sink) {
+        return Effect.contextWithEffect((ctx) => this._run(Sink.provide(sink, ctx)));
+    }
+}
+class Producer extends FxBase {
     i0;
-    i1;
-    constructor(i0, i1) {
-        super(i0, i1);
+    constructor(i0) {
+        super();
         this.i0 = i0;
-        this.i1 = i1;
     }
-    static make(fx, strategy) {
-        // TODO: Flatten nested Merges
-        if (fx.length === 0)
-            return empty;
-        const nonEmptyFx = fx.filter((fx) => !(fx instanceof Empty));
-        if (nonEmptyFx.length === 0)
-            return empty;
-        if (nonEmptyFx.length === 1)
-            return nonEmptyFx[0];
-        const neverIndex = nonEmptyFx.findIndex((fx) => fx instanceof Never);
-        if (neverIndex === -1)
-            return new Merge(nonEmptyFx, strategy);
-        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);
-        }
+    run(sink) {
+        return SyncProducer.runSink(this.i0, sink);
     }
-    toFx() {
-        const { i0, i1 } = this;
-        switch (i1._tag) {
-            case "Ordered": {
-                const concurrency = i1.concurrency === Infinity ? "unbounded" : i1.concurrency;
-                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
-                }));
-        }
+}
+/**
+ * @internal
+ */
+export function isProducer(fx) {
+    return fx.constructor === Producer;
+}
+export const succeed = (value) => new Producer(SyncProducer.Success(value));
+export const fromSync = (f) => new Producer(SyncProducer.FromSync(f));
+export const fromArray = (array) => new Producer(SyncProducer.FromArray(array));
+export const fromIterable = (iterable) => new Producer(SyncProducer.FromIterable(iterable));
+class ProducerEffect extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        return EffectProducer.runSink(this.i0, sink);
     }
 }
-class Slice extends ToFx {
+/**
+ * @internal
+ */
+export function isProducerEffect(fx) {
+    return fx.constructor === ProducerEffect;
+}
+export const fromEffect = (effect) => matchEffectPrimitive(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 = (input, schedule) => new ProducerEffect(EffectProducer.FromScheduled(input, schedule));
+export const schedule = (input, schedule) => new ProducerEffect(EffectProducer.Scheduled(input, schedule));
+class FailCause extends FxBase {
     i0;
-    i1;
-    constructor(i0, i1) {
-        super(i0, i1);
+    constructor(i0) {
+        super();
         this.i0 = i0;
-        this.i1 = i1;
     }
-    static make(fx, bounds) {
-        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);
-        }
-        else {
-            return new Slice(fx, bounds);
-        }
+    run(sink) {
+        return sink.onFailure(this.i0);
     }
-    toFx() {
-        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;
-                }
-            })));
-        }));
-    }
-}
-class Loop extends ToFx {
+}
+/**
+ * @internal
+ */
+export function isFailCause(fx) {
+    return fx.constructor === FailCause;
+}
+export const failCause = (cause) => new FailCause(cause);
+export const fail = (error) => failCause(Cause.fail(error));
+export const die = (error) => failCause(Cause.die(error));
+class Transformer extends FxBase {
     i0;
     i1;
-    i2;
-    constructor(i0, i1, i2) {
-        super(i0, i1, i2);
+    constructor(i0, i1) {
+        super();
         this.i0 = i0;
         this.i1 = i1;
-        this.i2 = i2;
     }
-    static make(fx, b, f) {
-        if (fx instanceof Transformer) {
-            return FilterMapLoop.make(fx.i0, b, compileSyncReducer(fx.i1, f));
+    run(sink) {
+        return this.i0.run(Op.compileOperatorSink(this.i1, sink));
+    }
+    static make(fx, operator) {
+        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 (fx instanceof TransformerEffect) {
-            return new FilterMapLoopEffect(fx.i0, b, compileEffectLoop(fx.i1, (b, a) => Effect.sync(() => f(b, a))));
+        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 Loop(fx, f, b);
+            return new Transformer(fx, operator);
         }
     }
-    toFx() {
-        return fromSink((sink) => Effect.suspend(() => {
-            let acc = this.i2;
-            return run(this.i0, Sink.WithContext(sink.onFailure, (a) => Effect.suspend(() => {
-                const [c, b] = this.i1(acc, a);
-                acc = b;
-                return sink.onSuccess(c);
-            })));
-        }));
-    }
 }
-class FilterMapLoop extends ToFx {
+/**
+ * @internal
+ */
+export function isTransformer(fx) {
+    return fx.constructor === Transformer;
+}
+class ProducerSyncTransformer extends FxBase {
     i0;
     i1;
-    i2;
-    constructor(i0, i1, i2) {
-        super(i0, i1, i2);
+    constructor(i0, i1) {
+        super();
         this.i0 = i0;
         this.i1 = i1;
-        this.i2 = i2;
     }
-    static make(fx, b, f) {
-        return new FilterMapLoop(fx, b, f);
-    }
-    toFx() {
-        return fromSink((sink) => Effect.suspend(() => {
-            let acc = this.i1;
-            return run(this.i0, Sink.WithContext(sink.onFailure, (a) => Effect.suspend(() => {
-                const optionCB = this.i2(acc, a);
-                if (Option.isNone(optionCB))
-                    return Effect.unit;
-                const [c, b] = optionCB.value;
-                acc = b;
-                return sink.onSuccess(c);
-            })));
-        }));
+    run(sink) {
+        return SyncProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink));
     }
 }
-class LoopEffect extends ToFx {
+/**
+ * @internal
+ */
+export function isProducerSyncTransformer(fx) {
+    return fx.constructor === ProducerSyncTransformer;
+}
+export const map = (fx, f) => Transformer.make(fx, SyncOp.Map(f));
+export const filter = (fx, f) => Transformer.make(fx, SyncOp.Filter(f));
+export const filterMap = (fx, f) => Transformer.make(fx, SyncOp.FilterMap(f));
+export const mapEffect = (fx, f) => Transformer.make(fx, EffectOp.MapEffect(f));
+export const filterMapEffect = (fx, f) => Transformer.make(fx, EffectOp.FilterMapEffect(f));
+export const filterEffect = (fx, f) => Transformer.make(fx, EffectOp.FilterEffect(f));
+export const tapEffect = (fx, f) => Transformer.make(fx, EffectOp.TapEffect(f));
+export const loop = (fx, seed, f) => Transformer.make(fx, SyncLoopOp.LoopOperator(seed, f));
+export const withPrevious = (fx) => loop(fx, Option.none(), (acc, a) => [[acc, a], Option.some(a)]);
+export const filterMapLoop = (fx, seed, f) => Transformer.make(fx, SyncLoopOp.FilterMapLoopOperator(seed, f));
+export const loopEffect = (fx, seed, f) => Transformer.make(fx, EffectLoopOp.LoopEffectOperator(seed, f));
+export const filterMapLoopEffect = (fx, seed, f) => Transformer.make(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f));
+export const observe = (fx, f) => Observe.make(fx, f);
+const constUnit = () => Effect.unit;
+export const drain = (fx) => Observe.make(fx, constUnit);
+class Observe extends EffectBase {
     i0;
     i1;
-    i2;
-    constructor(i0, i1, i2) {
-        super(i0, i1, i2);
+    constructor(i0, i1) {
+        super();
         this.i0 = i0;
         this.i1 = i1;
-        this.i2 = i2;
     }
-    static make(fx, f, b) {
-        if (fx instanceof TransformerEffect) {
-            return new FilterMapLoopEffect(fx.i0, b, compileEffectLoop(fx.i1, f));
+    toEffect() {
+        return Effect.asyncEffect((resume) => {
+            const { i0: fx, i1: f } = this;
+            const onFailure = (cause) => Effect.sync(() => resume(Effect.failCause(cause)));
+            return Effect.zipRight(fx.run(Sink.make(onFailure, (a) => Effect.catchAllCause(f(a), onFailure))), Effect.sync(() => resume(Effect.unit)));
+        });
+    }
+    static make(fx, f) {
+        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) => SyncOp.matchSyncOperator(op, {
+                    Map: (op) => 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) => 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) => SyncOp.matchSyncOperator(op, {
+                    Map: (op) => 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) => 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 (fx instanceof Transformer) {
-            return new FilterMapLoopEffect(fx.i0, b, compileEffectLoop(liftSyncOperator(fx.i1), f));
+        else if (isFailCause(fx)) {
+            return Effect.failCause(fx.i0);
         }
         else {
-            return new LoopEffect(fx, f, b);
+            return new Observe(fx, f);
         }
     }
-    toFx() {
-        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]) => Effect.as(sink.onSuccess(c), b2)
-        }))))));
-    }
 }
-class FilterMapLoopEffect extends ToFx {
+export const reduce = (fx, seed, f) => Reduce.make(fx, seed, f);
+class Reduce extends EffectBase {
     i0;
     i1;
     i2;
     constructor(i0, i1, i2) {
-        super(i0, i1, i2);
+        super();
         this.i0 = i0;
         this.i1 = i1;
         this.i2 = i2;
     }
-    toFx() {
-        return fromSink((sink) => Effect.suspend(() => {
+    toEffect() {
+        return 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);
+            return Effect.map(observe(this.i0, (a) => Effect.sync(() => acc = this.i2(acc, a))), () => acc);
+        });
+    }
+    static make(fx, seed, f) {
+        // 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], ([opAcc, acc], a) => {
+                        const [c, b] = op.f(opAcc, a);
+                        const newAcc = f(acc, c);
+                        return [b, newAcc];
+                    }), (x) => x[1]),
+                    FilterMapLoop: (op) => Effect.map(SyncProducer.runReduce(fx.i0, [op.seed, seed], ([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];
+                    }), (x) => x[1])
+                }),
+                EffectLoopOperator: (op) => EffectLoopOp.matchEffectLoopOperator(op, {
+                    LoopEffect: (op) => Effect.map(SyncProducer.runReduceEffect(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
+                        return Effect.flatMap(op.f(opAcc, a), ([c, b]) => {
+                            const newAcc = f(acc, c);
+                            return Effect.succeed([b, newAcc]);
+                        });
+                    }), (x) => x[1]),
+                    FilterMapLoopEffect: (op) => Effect.map(SyncProducer.runReduceEffect(fx.i0, [op.seed, seed], ([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];
+                        });
+                    }), (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 FxProvide extends ToFx {
+export const toReadonlyArray = (fx) => Effect.suspend(() => {
+    const init = [];
+    return Reduce.make(fx, init, (acc, a) => {
+        acc.push(a);
+        return acc;
+    });
+});
+export const slice = (fx, drop, take) => Slice.make(fx, boundsFrom(drop, take));
+export const take = (fx, n) => slice(fx, 0, n);
+export const drop = (fx, n) => slice(fx, n, Infinity);
+class Slice extends FxBase {
     i0;
     i1;
     constructor(i0, i1) {
-        super(i0, i1);
+        super();
         this.i0 = i0;
         this.i1 = i1;
     }
-    static make(fx, provide) {
-        if (fx instanceof FxProvide) {
-            return new FxProvide(fx.i0, Provide.merge(fx.i1, provide));
+    run(sink) {
+        return Sink.slice(sink, this.i1, (s) => this.i0.run(s));
+    }
+    static make(fx, bounds) {
+        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 FxProvide(fx, provide);
+            return new Slice(fx, bounds);
         }
     }
-    toFx() {
-        return fromSink((sink) => Effect.catchAllCause(Provide.provideToEffect(run(this.i0, sink), this.i1), sink.onFailure));
-    }
 }
-class Snapshot extends ToFx {
+/**
+ * @internal
+ */
+export function isSlice(fx) {
+    return fx.constructor === Slice;
+}
+export function skipRepeatsWith(fx, eq) {
+    return filterMapLoop(fx, Option.none(), (previous, a) => {
+        if (Option.isSome(previous) && eq(a, previous.value)) {
+            return [Option.none(), Option.some(a)];
+        }
+        else {
+            return [Option.some(a), Option.some(a)];
+        }
+    });
+}
+export function skipRepeats(fx) {
+    return skipRepeatsWith(fx, Equal.equals);
+}
+class ProducerEffectTransformer extends FxBase {
     i0;
     i1;
-    i2;
-    constructor(i0, i1, i2) {
-        super(i0, i1, i2);
+    constructor(i0, i1) {
+        super();
         this.i0 = i0;
         this.i1 = i1;
-        this.i2 = i2;
     }
-    toFx() {
-        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))
-        });
+    run(sink) {
+        return EffectProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink));
+    }
+}
+/**
+ * @internal
+ */
+export function isProducerEffectTransformer(fx) {
+    return fx.constructor === ProducerEffectTransformer;
+}
+class Empty extends FxBase {
+    run() {
+        return Effect.unit;
     }
-    runScoped(fx, fx2, f) {
-        return withScopedFork(({ fork, sink }) => Effect.flatMap(Ref.make(Option.none()), (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) => Effect.flatten(Ref.get(ref)).pipe(Effect.flatMap((b) => Effect.matchCauseEffect(f(a, b), sink)), Effect.optionFromOptional, Effect.asUnit))))))));
+}
+/**
+ * @internal
+ */
+export function isEmpty(fx) {
+    return fx.constructor === Empty;
+}
+export const empty = new Empty();
+class Never extends FxBase {
+    run() {
+        return Effect.never;
     }
 }
-class Middleware extends ToFx {
+/**
+ * @internal
+ */
+export function isNever(fx) {
+    return fx.constructor === Never;
+}
+export const never = new Never();
+export function padWith(fx, start, end) {
+    return new PadWith(fx, start, end);
+}
+export function prependAll(fx, start) {
+    return new PadWith(fx, start, []);
+}
+export function appendAll(fx, end) {
+    return new PadWith(fx, [], end);
+}
+export function prepend(fx, start) {
+    return new PadWith(fx, [start], []);
+}
+export function append(fx, end) {
+    return new PadWith(fx, [], [end]);
+}
+export function scan(fx, seed, f) {
+    return prepend(loop(fx, seed, (b, a) => {
+        const b2 = f(b, a);
+        return [b2, b2];
+    }), seed);
+}
+class PadWith extends FxBase {
     i0;
     i1;
     i2;
     constructor(i0, i1, i2) {
-        super(i0, i1);
+        super();
         this.i0 = i0;
         this.i1 = i1;
         this.i2 = i2;
     }
-    static make(fx, middleware, mapSink) {
-        if (fx instanceof Middleware) {
-            return new Middleware(fx.i0, (effect) => middleware(fx.i1(effect)), (s) => fx.i2(mapSink(s)));
+    run(sink) {
+        const onSuccess = (a) => sink.onSuccess(a);
+        return Effect.forEach(this.i1, onSuccess, DISCARD).pipe(Effect.zipRight(this.i0.run(sink)), Effect.zipRight(Effect.forEach(this.i2, onSuccess, DISCARD)));
+    }
+    static make(fx, start, end) {
+        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 Middleware(fx, middleware, mapSink);
+            return new PadWith(fx, start, end);
         }
     }
-    toFx() {
-        return fromSink((sink) => this.i1(run(this.i0, this.i2(sink))));
-    }
 }
-export function succeed(value) {
-    return new Succeed(value);
+function concat(a, b) {
+    return {
+        *[Symbol.iterator]() {
+            yield* a;
+            yield* b;
+        }
+    };
 }
-export function fromIterable(iterable) {
-    return new FromIterable(iterable);
+/**
+ * @internal
+ */
+export function isPadWith(fx) {
+    return fx.constructor === PadWith;
 }
-export const map = dual(2, function map(fx, f) {
-    return Transformer.make(fx, Map(f));
-});
-export const mapBoth = dual(2, function mapBoth(fx, options) {
-    return map(mapError(fx, options.onFailure), options.onSuccess);
-});
-export const filter = dual(2, function map(fx, f) {
-    return Transformer.make(fx, Filter(f));
-});
-export const filterMap = dual(2, function map(fx, f) {
-    return Transformer.make(fx, FilterMap(f));
-});
-export const compact = (fx) => filterMap(fx, identity);
-export const mapErrorCause = dual(2, function map(fx, f) {
-    return TransformerCause.make(fx, Map(f));
-});
-export const mapError = dual(2, function map(fx, f) {
-    return TransformerCause.make(fx, Map(Cause.map(f)));
-});
-export const filterCause = dual(2, function map(fx, f) {
-    return TransformerCause.make(fx, Filter(f));
-});
-export const filterMapCause = dual(2, function map(fx, f) {
-    return TransformerCause.make(fx, FilterMap(f));
-});
-export const filterError = dual(2, function map(fx, f) {
-    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 = dual(2, function map(fx, f) {
-    return filterMapCause(fx, (cause) => Cause.failureOrCause(cause).pipe(Either.match({
-        onLeft: (e) => Option.map(f(e), Cause.fail),
-        onRight: Option.some
-    })));
-});
-export const filterMapErrorEffect = dual(2, (fx, f) => {
-    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(fx, onSuccees) {
-    return helpers.withScopedFork((fork) => Effect.flatMap(Deferred.make(), (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)))));
+export function flatMapWithStrategy(fx, f, strategy, executionStrategy = ExecutionStrategy.sequential) {
+    return FlatMapWithStrategy.make(fx, f, strategy, executionStrategy);
 }
-export function drain(fx) {
-    return observe(fx, constUnit);
+export function switchMap(fx, f, executionStrategy) {
+    return flatMapWithStrategy(fx, f, Switch, executionStrategy);
 }
-export function toArray(fx) {
-    return Effect.suspend(() => {
-        const array = [];
-        return Effect.as(observe(fx, (a) => Effect.sync(() => array.push(a))), array);
-    });
+export function switchMapEffect(fx, f, executionStrategy) {
+    return switchMap(fx, (a) => fromEffect(f(a)), executionStrategy);
 }
-export function toReadonlyArray(fx) {
-    return toArray(fx);
+export function exhaustMap(fx, f, executionStrategy) {
+    return flatMapWithStrategy(fx, f, Exhaust, executionStrategy);
 }
-export const flatMapWithStrategy = dual(3, function flatMapWithStrategy(fx, f, strategy) {
-    return new WithFlattenStrategy(({ fork, sink }) => run(fx, Sink.WithContext(sink.onFailure, (a) => fork(run(from(f(a)), sink)))), strategy);
-});
-export const switchMap = dual(2, function switchMap(fx, f) {
-    return flatMapWithStrategy(fx, f, strategies.Switch);
-});
-export const exhaustMap = dual(2, function exhaustmap(fx, f) {
-    return flatMapWithStrategy(fx, f, strategies.Exhaust);
-});
-export const exhaust = (fx) => exhaustMap(fx, identity);
-export const exhaustMapLatest = dual(2, function exhaustMapLatest(fx, f) {
-    return flatMapWithStrategy(fx, f, strategies.ExhaustLatest);
-});
-export const exhaustLatest = (fx) => exhaustMapLatest(fx, identity);
-export const flatMap = dual(2, function flatMap(fx, f) {
-    return flatMapWithStrategy(fx, f, strategies.Unbounded);
-});
-export const flatten = (fx) => flatMap(fx, identity);
-export const flatMapConcurrently = dual(3, function flatMapConcurrently(fx, f, concurrency) {
-    return flatMapWithStrategy(fx, f, strategies.Bounded(concurrency));
-});
-export const concatMap = dual(2, function concatMap(fx, f) {
-    return flatMapConcurrently(fx, f, 1);
-});
-export const acquireUseRelease = dual(3, function acquireUseRelease(acquire, use, release) {
-    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 combine(fxs) {
-    return fromSink((sink) => Effect.suspend(() => {
-        const total = fxs.length;
-        if (total === 0)
-            return Effect.unit;
-        const values = new globalThis.Map();
-        const sample = () => Array.from({ length: total }, (_, i) => values.get(i));
-        const emitIfReady = (value, index) => Effect.suspend(() => {
-            values.set(index, value);
-            if (values.size === total) {
-                return sink.onSuccess(sample());
-            }
-            else {
-                return Effect.unit;
-            }
-        });
-        return Effect.all(fxs.map((fx, index) => run(fx, Sink.WithContext(sink.onFailure, (a) => emitIfReady(a, index)))), { concurrency: "unbounded" });
-    }));
+export function exhaustMapEffect(fx, f, executionStrategy) {
+    return exhaustMap(fx, (a) => fromEffect(f(a)), executionStrategy);
 }
-export function struct(fxs) {
-    return map(combine(Reflect.ownKeys(fxs).map((k) => map(fxs[k], (a) => [k, a]))), Object.fromEntries);
+export function exhaustMapLatest(fx, f, executionStrategy) {
+    return flatMapWithStrategy(fx, f, ExhaustLatest, executionStrategy);
 }
-export function merge(fxs) {
-    return Merge.make(fxs, strategies.Unordered(Infinity));
+export function exhaustMapLatestEffect(fx, f, executionStrategy) {
+    return exhaustMapLatest(fx, (a) => fromEffect(f(a)), executionStrategy);
 }
-export const mergeConcurrently = dual(2, function mergeConcurrently(fxs, concurrency) {
-    return Merge.make(fxs, strategies.Unordered(concurrency));
-});
-export function mergeBuffer(fxs) {
-    return Merge.make(fxs, strategies.Ordered(Infinity));
+export function exhaustFilterMapLatestEffect(fx, f, executionStrategy) {
+    return exhaustMapLatest(fx, (a) => fromFxEffect(Effect.map(f(a), Option.match({
+        onNone: () => empty,
+        onSome: succeed
+    }))), executionStrategy);
 }
-export const mergeBufferConcurrently = dual(2, function mergeConcurrently(fxs, concurrency) {
-    return Merge.make(fxs, strategies.Ordered(concurrency));
-});
-export const mergeSwitch = (fxs) => Merge.make(fxs, strategies.Switch);
-export function race(fxs) {
-    if (fxs.length === 0)
-        return empty;
-    if (fxs.length === 1)
-        return fxs[0];
-    return withScopedFork(({ fork, sink }) => Effect.asyncEffect((resume) => Effect.gen(function* (_) {
-        let winningIndex = -1;
-        const fibers = 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))))));
-        function pickWinner(i) {
-            if (winningIndex === -1) {
-                winningIndex = i;
-                resume(Effect.succeed([i, fibers]));
-            }
-            return winningIndex === i;
-        }
-    })).pipe(Effect.flatMap(([winningIndex, fibers]) => Effect.suspend(() => {
-        const [winner] = fibers.splice(winningIndex, 1);
-        return Effect.flatMap(Fiber.interruptAll(fibers), () => Fiber.join(winner));
-    }))));
+export function flatMapConcurrently(fx, f, capacity, executionStrategy) {
+    return flatMapWithStrategy(fx, f, Bounded(capacity), executionStrategy);
 }
-export const empty = new Empty();
-export const never = new Never();
-export const failCause = (cause) => new Fail(cause);
-export const fail = (e) => failCause(Cause.fail(e));
-export const fromSink = (f) => new FromSink((sink) => Effect.catchAllCause(f(sink), sink.onFailure));
-export const suspend = (f) => new Suspend(f);
-export const sync = (f) => new Sync(f);
-export const slice = dual(3, function slice(fx, skip, take) {
-    return Slice.make(fx, boundsFrom(skip, take));
-});
-export const take = dual(2, function take(fx, n) {
-    return slice(fx, 0, n);
-});
-export const drop = dual(2, function drop(fx, n) {
-    return slice(fx, n, Infinity);
-});
-export const takeWhile = dual(2, function takeWhile(fx, predicate) {
-    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 const takeUntil = dual(2, function takeUntil(fx, predicate) {
-    return takeWhile(fx, (a) => Effect.map(predicate(a), (x) => !x));
-});
-export const dropWhile = dual(2, function dropWhile(fx, predicate) {
-    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)));
-    }));
-});
-export const dropUntil = dual(2, function dropUntil(fx, predicate) {
-    return dropWhile(fx, (a) => Effect.map(predicate(a), (x) => !x));
-});
-export const dropAfter = dual(2, function dropAfter(fx, predicate) {
-    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);
-                    }
-                }
-            })));
-    }));
-});
-export const continueWith = dual(2, function continueWith(fx, f) {
-    return fromSink((sink) => Effect.flatMap(run(fx, sink), () => run(f(), sink)));
-});
-export const recoverWith = dual(2, function recoverWith(fx, f) {
-    return fromSink((sink) => Effect.catchAllCause(observe(fx, sink.onSuccess), (cause) => run(from(f(cause)), sink)));
-});
-export const mapEffect = dual(2, function mapEffect(fx, f) {
-    return TransformerEffect.make(fx, MapEffect(f));
-});
-export const tap = dual(2, function tap(fx, f) {
-    return TransformerEffect.make(fx, TapEffect(f));
-});
-export const filterEffect = dual(2, function filterEffect(fx, predicate) {
-    return TransformerEffect.make(fx, FilterEffect(predicate));
-});
-export const filterMapEffect = dual(2, function filterEffect(fx, f) {
-    return TransformerEffect.make(fx, FilterMapEffect(f));
-});
-export const middleware = dual((args) => args.length === 3 || typeof args[0] !== "function", function middleware(fx, f, g) {
-    return Middleware.make(fx, f, g ?? identity);
-});
-export const loop = dual(3, function loop(fx, seed, f) {
-    return Loop.make(fx, seed, f);
-});
-export const loopEffect = dual(3, function loopEffect(fx, seed, f) {
-    return LoopEffect.make(fx, f, seed);
-});
-export const startWith = dual(2, function startWith(fx, value) {
-    return fromSink((sink) => Effect.flatMap(sink.onSuccess(value), () => run(fx, sink)));
-});
-export const endWith = dual(2, function endWith(fx, value) {
-    return fromSink((sink) => Effect.flatMap(run(fx, sink), () => sink.onSuccess(value)));
-});
-export const scan = dual(3, function loop(fx, seed, f) {
-    return continueWith(new Succeed(seed), () => Loop.make(fx, seed, (b, a) => {
-        const b2 = f(b, a);
-        return [b2, b2];
-    }));
-});
-export const scanEffect = dual(3, function loopEffect(fx, seed, f) {
-    return continueWith(new Succeed(seed), () => LoopEffect.make(fx, (b, a) => Effect.map(f(b, a), (b2) => [b2, b2]), seed));
-});
-export const flatMapCauseWithStrategy = dual(3, function flatMapCause(fx, f, strategy) {
-    return new WithFlattenStrategy(({ fork, sink }) => run(fx, Sink.WithContext((cause) => fork(run(from(f(cause)), sink)), sink.onSuccess)), strategy);
-});
-export const flatMapErrorWithStrategy = dual(3, function flatMapCause(fx, f, strategy) {
-    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);
-});
-export const flatMapCause = dual(2, function flatMapCause(fx, f) {
-    return flatMapCauseWithStrategy(fx, f, strategies.Unbounded);
-});
-export const flatMapError = dual(2, function flatMapError(fx, f) {
-    return flatMapErrorWithStrategy(fx, f, strategies.Unbounded);
-});
-export const flatMapCauseConcurrently = dual(3, function flatMapCauseConcurrently(fx, f, concurrency) {
-    return flatMapCauseWithStrategy(fx, f, strategies.Bounded(concurrency));
-});
-export const flatMapErrorConcurrently = dual(3, function flatMapCauseConcurrently(fx, f, concurrency) {
-    return flatMapErrorWithStrategy(fx, f, strategies.Bounded(concurrency));
-});
-export const switchMapCause = dual(2, function switchMapCause(fx, f) {
-    return flatMapCauseWithStrategy(fx, f, strategies.Switch);
-});
-export const switchMapError = dual(2, function switchMapError(fx, f) {
-    return flatMapErrorWithStrategy(fx, f, strategies.Switch);
-});
-export const exhaustMapCause = dual(2, function exhaustMapCause(fx, f) {
-    return flatMapCauseWithStrategy(fx, f, strategies.Exhaust);
-});
-export const exhaustMapError = dual(2, function switchMapError(fx, f) {
-    return flatMapErrorWithStrategy(fx, f, strategies.Exhaust);
-});
-export const exhaustMapLatestCause = dual(2, function exhaustMapLatestCause(fx, f) {
-    return flatMapCauseWithStrategy(fx, f, strategies.ExhaustLatest);
-});
-export const exhaustMapLatestError = dual(2, function switchMapError(fx, f) {
-    return flatMapErrorWithStrategy(fx, f, strategies.ExhaustLatest);
-});
-export const matchCauseWithStrategy = dual(2, function flatMapCause(fx, options) {
-    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);
-});
-export const matchErrorWithStrategy = dual(2, function flatMapCause(fx, options) {
-    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);
-});
-export const matchCause = dual(2, function matchCause(fx, options) {
-    return matchCauseWithStrategy(fx, {
-        ...options,
-        strategy: strategies.Unbounded
-    });
-});
-export const match = dual(2, function matchCause(fx, options) {
-    return matchErrorWithStrategy(fx, { ...options, strategy: strategies.Unbounded });
-});
-export const matchCauseConcurrently = dual(2, function matchCause(fx, options) {
-    return matchCauseWithStrategy(fx, {
-        onFailure: options.onFailure,
-        onSuccess: options.onSuccess,
-        strategy: strategies.Bounded(options.concurrency)
-    });
-});
-export const matchErrorConcurrently = dual(2, function matchErrorConcurrently(fx, options) {
-    return matchErrorWithStrategy(fx, { ...options, strategy: strategies.Bounded(options.concurrency) });
-});
-export const switchMatchCause = dual(2, function matchCause(fx, options) {
-    return matchCauseWithStrategy(fx, {
-        ...options,
-        strategy: strategies.Switch
-    });
-});
-export const switchMatch = dual(2, function matchCause(fx, options) {
-    return matchErrorWithStrategy(fx, { ...options, strategy: strategies.Switch });
-});
-export const exhaustMatchCause = dual(2, function matchCause(fx, options) {
-    return matchCauseWithStrategy(fx, {
-        ...options,
-        strategy: strategies.Exhaust
-    });
-});
-export const exhaustMatch = dual(2, function matchCause(fx, options) {
-    return matchErrorWithStrategy(fx, { ...options, strategy: strategies.Exhaust });
-});
-export const exhaustLatestMatchCause = dual(2, function matchCause(fx, options) {
-    return matchCauseWithStrategy(fx, {
-        ...options,
-        strategy: strategies.ExhaustLatest
-    });
-});
-export const exhaustLatestMatch = dual(2, function matchCause(fx, options) {
-    return matchErrorWithStrategy(fx, { ...options, strategy: strategies.ExhaustLatest });
-});
-export const withEarlyExit = (f) => new WithEarlyExit(f);
-export const withScopedFork = (f) => new WithScopedFork(f);
-export const withFlattenStrategy = (f, strategy) => new WithFlattenStrategy(f, strategy);
-export const during = dual(2, function during(fx, window) {
-    return withEarlyExit(({ fork, sink }) => Effect.suspend(() => {
-        let taking = false;
-        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)))));
-    }));
-});
-export const since = dual(2, function since(fx, window) {
-    return during(fx, map(window, () => never));
-});
-export const until = dual(2, function until(fx, window) {
-    return during(fx, succeed(window));
-});
-export const fromScheduled = dual(2, function fromScheduled(fx, scheduled) {
-    return fromSink((sink) => Effect.catchAllCause(Effect.repeat(Effect.matchCauseEffect(fx, sink), scheduled), sink.onFailure));
-});
-export const periodic = dual(2, function periodic(fx, duration) {
-    return fromScheduled(fx, Schedule.spaced(duration));
-});
-export const provide = dual(2, function provideContext(fx, context) {
-    if (Layer.isLayer(context)) {
-        return FxProvide.make(fx, Provide.ProvideLayer(context));
-    }
-    else if (isContext(context)) {
-        return FxProvide.make(fx, Provide.ProvideContext(context));
-    }
-    else {
-        return FxProvide.make(fx, Provide.ProvideRuntime(context));
-    }
-});
-export const provideService = dual(3, function provideService(fx, tag, service) {
-    return FxProvide.make(fx, Provide.ProvideService(tag, service));
-});
-export const provideServiceEffect = dual(3, function provideService(fx, tag, service) {
-    return FxProvide.make(fx, Provide.ProvideServiceEffect(tag, service));
-});
-export const skipRepeatsWith = dual(2, function skipRepeatsWith(fx, eq) {
-    return FilterMapLoop.make(fx, Option.none(), (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 = (fx) => skipRepeatsWith(fx, Equal.equals);
-class Reduce extends Effectable.Class {
-    fx;
-    seed;
-    f;
-    constructor(fx, seed, f) {
-        super();
-        this.fx = fx;
-        this.seed = seed;
-        this.f = f;
-    }
-    static make(fx, seed, f) {
-        if (fx instanceof Transformer) {
-            return FilterMapReduce.make(fx.i0, seed, compileSyncReducer(fx.i1, f));
-        }
-        return new Reduce(fx, seed, f);
-    }
-    cached = null;
-    commit() {
-        return (this.cached ||= Effect.suspend(() => {
-            let acc = this.seed;
-            return Effect.map(observe(this.fx, (a) => Effect.sync(() => acc = this.f(acc, a))), () => acc);
-        }));
-    }
+export function concatMap(fx, f, executionStrategy) {
+    return flatMapConcurrently(fx, f, 1, executionStrategy);
+}
+export function flatMapConcurrentlyEffect(fx, f, capacity, executionStrategy) {
+    return flatMapConcurrently(fx, (a) => fromEffect(f(a)), capacity, executionStrategy);
 }
-class FilterMapReduce extends Effectable.Class {
+export function flatMap(fx, f, executionStrategy) {
+    return flatMapWithStrategy(fx, f, Unbounded, executionStrategy);
+}
+export function flatMapEffect(fx, f, executionStrategy) {
+    return flatMap(fx, (a) => fromEffect(f(a)), executionStrategy);
+}
+class FlatMapWithStrategy extends FxBase {
     i0;
     i1;
     i2;
-    constructor(i0, i1, i2) {
+    i3;
+    withFork;
+    constructor(i0, i1, i2, i3) {
         super();
         this.i0 = i0;
         this.i1 = i1;
         this.i2 = i2;
+        this.i3 = i3;
+        this.withFork = withFlattenStrategy(i2);
     }
-    static make(fx, seed, f) {
-        if (fx instanceof FromIterable) {
-            if (Array.isArray(fx.i0)) {
-                return new OnceEffect(Effect.sync(() => reduceFilterArray(fx.i0, seed, f)));
+    run(sink) {
+        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);
+    }
+    static make(fx, f, strategy, 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()));
             }
-            else {
-                return Effect.sync(() => reduceFilterIterable(fx.i0, seed, f));
+            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);
             }
         }
-        return new FilterMapReduce(fx, seed, f);
-    }
-    cached = null;
-    commit() {
-        return this.cached ||= Effect.suspend(() => {
-            let acc = this.i1;
-            return Effect.map(observe(this.i0, (a) => Option.match(this.i2(acc, a), {
-                onNone: () => Effect.unit,
-                onSome: (b) => Effect.succeed(acc = b)
-            })), () => acc);
+        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 function fromFxEffect(effect) {
+    return new FromFxEffect(effect);
+}
+class FromFxEffect extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        return Effect.matchCauseEffect(this.i0, {
+            onFailure: (cause) => sink.onFailure(cause),
+            onSuccess: (fx) => fx.run(sink)
         });
     }
 }
-function reduceFilterIterable(iterable, seed, f) {
-    const iterator = iterable[Symbol.iterator]();
-    let acc = seed;
-    let result = iterator.next();
-    let option = Option.none();
-    while (!result.done) {
-        option = f(acc, result.value);
-        if (Option.isSome(option)) {
-            acc = option.value;
+export function gen(f) {
+    return fromFxEffect(Effect.gen(f));
+}
+export function genScoped(f) {
+    return scoped(fromFxEffect(Effect.gen(f)));
+}
+export function continueWith(fx, f) {
+    return ContinueWith.make(fx, f);
+}
+class ContinueWith extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return Effect.flatMap(this.i0.run(sink), () => this.i1().run(sink));
+    }
+    static make(fx, f) {
+        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 function orElseCause(fx, f) {
+    return OrElseCause.make(fx, f);
+}
+class OrElseCause extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return Effect.catchAllCause(observe(this.i0, sink.onSuccess), (cause) => this.i1(cause).run(sink));
+    }
+    static make(fx, f) {
+        if (isEmpty(fx))
+            return fx;
+        else if (isNever(fx))
+            return fx;
+        else {
+            return new OrElseCause(fx, f);
         }
-        result = iterator.next();
     }
-    return acc;
 }
-function reduceFilterArray(iterable, seed, f) {
-    const length = iterable.length;
-    let acc = seed;
-    let option = Option.none();
-    for (let i = 0; i < length; i++) {
-        option = f(acc, iterable[i]);
-        if (Option.isSome(option)) {
-            acc = option.value;
+export function orElse(fx, f) {
+    return OrElse.make(fx, f);
+}
+class OrElse extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return Effect.catchAll(Effect.asyncEffect((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));
+    }
+    static make(fx, f) {
+        if (isEmpty(fx))
+            return fx;
+        else if (isNever(fx))
+            return fx;
+        else {
+            return new OrElse(fx, f);
         }
     }
-    return acc;
 }
-export const reduce = dual(3, function reduce(fx, seed, f) {
-    return Reduce.make(fx, seed, f);
-});
-export function toChunk(fx) {
-    return reduce(fx, Chunk.empty(), (Chunk.append));
+export function suspend(f) {
+    return new Suspend(f);
 }
-export const snapshot = dual(3, function snapshot(fx, sampled, f) {
-    return new Snapshot(fx, sampled, f);
-});
-export function fromEmitter(f) {
-    return withEarlyExit(({ scope, sink }) => Effect.zipRight(Effect.provideService(Effect.flatMap(Emitter.make(sink), f), Scope.Scope, scope), Effect.never));
-}
-export function fromEffect(effect) {
-    return matchEffectPrimitive(effect, {
-        Success: (e) => succeed(e.i0),
-        Failure: (e) => failCause(e.i0),
-        Left: (e) => fail(e.left),
-        Right: (e) => succeed(e.right),
-        None: () => fail(new Cause.NoSuchElementException()),
-        Some: (e) => succeed(e.value),
-        Sync: (e) => sync(e.i0),
-        Otherwise: () => fromSink((sink) => Effect.matchCauseEffect(effect, sink))
+class Suspend extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        return this.i0().run(sink);
+    }
+}
+function isSuspend(fx) {
+    return fx.constructor === Suspend;
+}
+class SuspendedTransformer extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return this.i0().run(Op.compileOperatorSink(this.i1, sink));
+    }
+}
+function isSuspendedTransformer(fx) {
+    return fx.constructor === SuspendedTransformer;
+}
+export function mergeWithStrategy(fx, stategy) {
+    return MergeWithStrategy.make(fx, stategy);
+}
+export function merge(fx, other) {
+    return mergeWithStrategy([fx, other], Unordered(2));
+}
+export function mergeAll(fx) {
+    return mergeWithStrategy(fx, Unordered(Infinity));
+}
+export function mergeOrdered(fx) {
+    return mergeOrderedConcurrently(fx, Infinity);
+}
+export function mergeOrderedConcurrently(fx, concurrency) {
+    return mergeWithStrategy(fx, Ordered(concurrency));
+}
+export function mergeSwitch(fx) {
+    return mergeWithStrategy(fx, Switch);
+}
+class MergeWithStrategy extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        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(fx, strategy) {
+        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(fx, sink, concurrency) {
+    return Effect.forEach(fx, (fx) => fx.run(sink), { concurrency, discard: true });
+}
+function runOrdered(fx, sink, concurrency) {
+    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 function fromStream(stream, options) {
-    return fromSink((sink) => Effect.acquireUseRelease(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)));
+function runSwitch(fx, sink) {
+    return Effect.forEach(fx, (fx) => fx.run(sink), { concurrency: 1, discard: true });
+}
+export function takeWhile(fx, f) {
+    return TakeWhile.make(fx, f);
+}
+export function takeUntil(fx, f) {
+    return TakeWhile.make(fx, Predicate.not(f));
+}
+class TakeWhile extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return Sink.takeWhile(sink, this.i1, (s) => this.i0.run(s));
+    }
+    static make(fx, predicate) {
+        if (isEmpty(fx) || isNever(fx))
+            return fx;
+        else {
+            return new TakeWhile(fx, predicate);
+        }
+    }
+}
+export function dropWhile(fx, f) {
+    return DropUntil.make(fx, f);
+}
+export function dropUntil(fx, f) {
+    return DropUntil.make(fx, Predicate.not(f));
+}
+class DropUntil extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return this.i0.run(Sink.dropWhile(sink, this.i1));
+    }
+    static make(fx, predicate) {
+        if (isEmpty(fx) || isNever(fx))
+            return fx;
+        else {
+            return new DropUntil(fx, predicate);
+        }
+    }
+}
+export function dropAfter(fx, f) {
+    return DropAfter.make(fx, f);
+}
+class DropAfter extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return this.i0.run(Sink.dropAfter(sink, this.i1));
+    }
+    static make(fx, predicate) {
+        if (isEmpty(fx) || isNever(fx))
+            return fx;
+        else {
+            return new DropAfter(fx, predicate);
+        }
+    }
+}
+export function takeWhileEffect(fx, f) {
+    return TakeWhileEffect.make(fx, f);
+}
+export function takeUntilEffect(fx, f) {
+    return TakeWhileEffect.make(fx, (a) => Effect.map(f(a), Boolean.not));
+}
+class TakeWhileEffect extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return Sink.takeWhileEffect(sink, this.i1, (s) => this.i0.run(s));
+    }
+    static make(fx, f) {
+        if (isEmpty(fx) || isNever(fx))
+            return fx;
+        else {
+            return new TakeWhileEffect(fx, f);
+        }
+    }
+}
+export function dropWhileEffect(fx, f) {
+    return DropWhileEffect.make(fx, f);
+}
+export function dropUntilEffect(fx, f) {
+    return DropWhileEffect.make(fx, (a) => Effect.map(f(a), Boolean.not));
+}
+class DropWhileEffect extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return this.i0.run(Sink.dropWhileEffect(sink, this.i1));
+    }
+    static make(fx, f) {
+        if (isEmpty(fx) || isNever(fx))
+            return fx;
+        else {
+            return new DropWhileEffect(fx, f);
+        }
+    }
+}
+export function dropAfterEffect(fx, f) {
+    return DropAfterEffect.make(fx, f);
+}
+class DropAfterEffect extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return this.i0.run(Sink.dropAfterEffect(sink, this.i1));
+    }
+    static make(fx, f) {
+        if (isEmpty(fx) || isNever(fx))
+            return fx;
+        else {
+            return new DropAfterEffect(fx, f);
+        }
+    }
+}
+export function during(fx, window) {
+    return During.make(fx, window);
+}
+export function since(fx, window) {
+    return During.make(fx, map(window, () => never));
+}
+export function until(fx, window) {
+    return During.make(fx, succeed(window));
+}
+class During extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return withScopedFork((fork) => Sink.withEarlyExit(sink, (s) => {
+            let taking = false;
+            const onFailure = (cause) => 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);
+    }
+    static make(fx, window) {
+        if (isEmpty(fx) || isNever(fx))
+            return fx;
+        else {
+            return new During(fx, window);
+        }
+    }
+}
+export function middleware(fx, effect, sink) {
+    return new Middleware(fx, effect, sink);
+}
+export function onExit(fx, f) {
+    return middleware(fx, Effect.onExit(f));
+}
+export function onInterrupt(fx, f) {
+    return middleware(fx, Effect.onInterrupt(f));
+}
+export function onError(fx, f) {
+    return middleware(fx, Effect.onError(f));
+}
+export const scoped = (fx) => middleware(fx, Effect.scoped);
+export function annotateLogs(fx, key, value) {
+    return middleware(fx, (effect) => Effect.annotateLogs(effect, key, value));
+}
+export function annotateSpans(fx, key, value) {
+    return middleware(fx, (effect) => Effect.annotateSpans(effect, key, value));
+}
+export const interruptible = (fx) => middleware(fx, Effect.interruptible);
+export const uninterruptible = (fx) => middleware(fx, Effect.uninterruptible);
+export function locally(use, self, value) {
+    return middleware(use, (effect) => Effect.locally(effect, self, value));
+}
+export function locallyWith(use, self, f) {
+    return middleware(use, (effect) => Effect.locallyWith(effect, self, f));
+}
+export function withTracerTiming(fx, enabled) {
+    return middleware(fx, (effect) => Effect.withTracerTiming(effect, enabled));
+}
+export function withConcurrency(fx, concurrency) {
+    return middleware(fx, (effect) => Effect.withConcurrency(effect, concurrency));
+}
+export function withConfigProvider(fx, configProvider) {
+    return middleware(fx, (effect) => Effect.withConfigProvider(effect, configProvider));
+}
+export function withLogSpan(fx, span) {
+    return middleware(fx, (effect) => Effect.withLogSpan(effect, span));
+}
+export function withMaxOpsBeforeYield(fx, maxOps) {
+    return middleware(fx, (effect) => Effect.withMaxOpsBeforeYield(effect, maxOps));
+}
+export function withParentSpan(fx, parentSpan) {
+    return middleware(fx, (effect) => Effect.withParentSpan(effect, parentSpan));
+}
+export function withRequestBatching(fx, requestBatching) {
+    return middleware(fx, (effect) => Effect.withRequestBatching(effect, requestBatching));
+}
+export function withRequestCache(fx, cache) {
+    return middleware(fx, (effect) => Effect.withRequestCache(effect, cache));
+}
+export function withRequestCaching(fx, requestCaching) {
+    return middleware(fx, (effect) => Effect.withRequestCaching(effect, requestCaching));
+}
+export function withScheduler(fx, scheduler) {
+    return middleware(fx, (effect) => Effect.withScheduler(effect, scheduler));
+}
+export function withTracer(fx, tracer) {
+    return middleware(fx, (effect) => Effect.withTracer(effect, tracer));
+}
+class Middleware extends FxBase {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+        this.i2 = i2;
+    }
+    run(sink) {
+        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(acquire, use, release) {
+    return new AcquireUseRelease(acquire, use, release);
+}
+class AcquireUseRelease extends FxBase {
+    acquire;
+    use;
+    release;
+    constructor(acquire, use, release) {
+        super();
+        this.acquire = acquire;
+        this.use = use;
+        this.release = release;
+    }
+    run(sink) {
+        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(self, name, options = {}) {
+    return acquireUseRelease(Effect.flatMap(Effect.optionFromOptional(Effect.currentSpan), (parent) => Effect.makeSpan(name, { ...options, parent: options?.parent || Option.getOrUndefined(parent) })), (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(fx, context) {
+    return ProvideFx.make(fx, Provide.ProvideContext(context));
+}
+export function provideLayer(fx, layer) {
+    return ProvideFx.make(fx, Provide.ProvideLayer(layer));
+}
+export function provideRuntime(fx, runtime) {
+    return ProvideFx.make(fx, Provide.ProvideRuntime(runtime));
+}
+export function provideService(fx, service, instance) {
+    return ProvideFx.make(fx, Provide.ProvideService(service, instance));
+}
+export function provideServiceEffect(fx, service, instance) {
+    return ProvideFx.make(fx, Provide.ProvideServiceEffect(service, instance));
+}
+export function provide(fx, provide) {
+    if (Layer.isLayer(provide))
+        return provideLayer(fx, provide);
+    else if (Context.isContext(provide))
+        return provideContext(fx, provide);
+    else
+        return provideRuntime(fx, provide);
+}
+class ProvideFx extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        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(fx, provide) {
+        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(u) {
+    return u.constructor === ProvideFx;
+}
+export function mapCause(fx, f) {
+    return new TransformerCause(fx, SyncOp.Map(f));
+}
+export function mapError(fx, f) {
+    return mapCause(fx, Cause.map(f));
+}
+export function filterCause(fx, f) {
+    return new TransformerCause(fx, SyncOp.Filter(f));
+}
+export function filterError(fx, f) {
+    return filterCause(fx, (cause) => Option.match(Cause.failureOption(cause), {
+        onNone: constTrue,
+        onSome: f
+    }));
+}
+export function filterMapCause(fx, f) {
+    return new TransformerCause(fx, SyncOp.FilterMap(f));
+}
+export function filterMapError(fx, f) {
+    return filterMapCause(fx, (cause) => Either.match(Cause.failureOrCause(cause), {
+        onLeft: (e) => Option.map(f(e), Cause.fail),
+        onRight: Option.some
+    }));
+}
+export function mapCauseEffect(fx, f) {
+    return new TransformerCause(fx, EffectOp.MapEffect(f));
+}
+export function mapErrorEffect(fx, f) {
+    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(fx, f) {
+    return new TransformerCause(fx, EffectOp.FilterEffect(f));
+}
+export function filterErrorEffect(fx, f) {
+    return filterCauseEffect(fx, (cause) => Either.match(Cause.failureOrCause(cause), {
+        onLeft: f,
+        onRight: () => Effect.succeed(true)
+    }));
+}
+export function filterMapCauseEffect(fx, f) {
+    return new TransformerCause(fx, EffectOp.FilterMapEffect(f));
+}
+export function filterMapErrorEffect(fx, f) {
+    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(fx, seed, f) {
+    return new TransformerCause(fx, SyncLoopOp.LoopOperator(seed, f));
+}
+export function loopError(fx, seed, f) {
+    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(fx, seed, f) {
+    return new TransformerCause(fx, EffectLoopOp.LoopEffectOperator(seed, f));
+}
+export function loopErrorEffect(fx, seed, f) {
+    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(fx, seed, f) {
+    return new TransformerCause(fx, SyncLoopOp.FilterMapLoopOperator(seed, f));
+}
+export function filterMapLoopError(fx, seed, f) {
+    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(fx, seed, f) {
+    return new TransformerCause(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f));
+}
+export function filterMapLoopErrorEffect(fx, seed, f) {
+    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 extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        return this.i0.run(Op.compileOperatorSinkCause(this.i1, sink));
+    }
+}
+export function flatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy = ExecutionStrategy.sequential) {
+    return new FlatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy);
+}
+export function flatMapErrorWithStrategy(fx, f, flattenStrategy, executionStrategy = ExecutionStrategy.sequential) {
+    return flatMapCauseWithStrategy(fx, (cause) => Either.match(Cause.failureOrCause(cause), {
+        onLeft: f,
+        onRight: (cause) => failCause(cause)
+    }), flattenStrategy, executionStrategy);
+}
+export function switchMapCause(fx, f, executionStrategy) {
+    return flatMapCauseWithStrategy(fx, f, Switch, executionStrategy);
+}
+export function switchMapError(fx, f, executionStrategy) {
+    return flatMapErrorWithStrategy(fx, f, Switch, executionStrategy);
+}
+export function flatMapCause(fx, f, executionStrategy) {
+    return flatMapCauseWithStrategy(fx, f, Unbounded, executionStrategy);
+}
+export function flatMapError(fx, f, executionStrategy) {
+    return flatMapErrorWithStrategy(fx, f, Unbounded, executionStrategy);
+}
+export function flatMapCauseConcurrently(fx, f, concurrency, executionStrategy) {
+    return flatMapCauseWithStrategy(fx, f, Bounded(concurrency), executionStrategy);
+}
+export function flatMapErrorConcurrently(fx, f, concurrency, executionStrategy) {
+    return flatMapErrorWithStrategy(fx, f, Bounded(concurrency), executionStrategy);
+}
+export function exhaustMapCause(fx, f, executionStrategy) {
+    return flatMapCauseWithStrategy(fx, f, Exhaust, executionStrategy);
+}
+export function exhaustMapError(fx, f, executionStrategy) {
+    return flatMapErrorWithStrategy(fx, f, Exhaust, executionStrategy);
+}
+export function exhaustMapLatestCause(fx, f, executionStrategy) {
+    return flatMapCauseWithStrategy(fx, f, ExhaustLatest, executionStrategy);
+}
+export function exhaustMapLatestError(fx, f, executionStrategy) {
+    return flatMapErrorWithStrategy(fx, f, ExhaustLatest, executionStrategy);
+}
+class FlatMapCauseWithStrategy extends FxBase {
+    i0;
+    i1;
+    i2;
+    i3;
+    withFork;
+    constructor(i0, i1, i2, i3) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+        this.i2 = i2;
+        this.i3 = i3;
+        this.withFork = withFlattenStrategy(this.i2);
+    }
+    run(sink) {
+        return this.withFork((fork) => this.i0.run(Sink.make((cause) => fork(this.i1(cause).run(sink)), (a) => sink.onSuccess(a))), this.i3);
+    }
+}
+class MatchWithStrategy extends FxBase {
+    i0;
+    i1;
+    i2;
+    i3;
+    i4;
+    withFork;
+    constructor(i0, i1, i2, i3, i4) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+        this.i2 = i2;
+        this.i3 = i3;
+        this.i4 = i4;
+        this.withFork = withFlattenStrategy(this.i3);
+    }
+    run(sink) {
+        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 function matchCauseWithStrategy(fx, flattenStrategy, opts) {
+    return new MatchWithStrategy(fx, opts.onFailure, opts.onSuccess, flattenStrategy, opts.executionStrategy || ExecutionStrategy.sequential);
+}
+export function matchErrorWithStrategy(fx, flattenStrategy, { executionStrategy, onFailure, onSuccess }) {
+    return new MatchWithStrategy(fx, (cause) => Either.match(Cause.failureOrCause(cause), {
+        onLeft: onFailure,
+        onRight: (cause) => failCause(cause)
+    }), onSuccess, flattenStrategy, executionStrategy || ExecutionStrategy.sequential);
+}
+export function matchCause(fx, opts) {
+    return matchCauseWithStrategy(fx, Unbounded, opts);
+}
+export function matchError(fx, opts) {
+    return matchErrorWithStrategy(fx, Unbounded, opts);
+}
+export function matchCauseConcurrently(fx, concurrency, opts) {
+    return matchCauseWithStrategy(fx, Bounded(concurrency), opts);
+}
+export function matchErrorConcurrently(fx, concurrency, opts) {
+    return matchErrorWithStrategy(fx, Bounded(concurrency), opts);
+}
+export function switchMatchCause(fx, opts) {
+    return matchCauseWithStrategy(fx, Switch, opts);
+}
+export function switchMatchError(fx, opts) {
+    return matchErrorWithStrategy(fx, Switch, opts);
+}
+export function exhaustMatchCause(fx, opts) {
+    return matchCauseWithStrategy(fx, Exhaust, opts);
+}
+export function exhaustMatchError(fx, opts) {
+    return matchErrorWithStrategy(fx, Exhaust, opts);
+}
+export function exhaustMatchLatestCause(fx, opts) {
+    return matchCauseWithStrategy(fx, ExhaustLatest, opts);
+}
+export function exhaustMatchLatestError(fx, opts) {
+    return matchErrorWithStrategy(fx, ExhaustLatest, opts);
+}
+export function tuple(fx) {
+    return new Tuple(fx);
+}
+class Tuple extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        return tupleSink(sink, (onSuccess) => Effect.forEach(this.i0, (fx, i) => fx.run(Sink.make(sink.onFailure, (a) => onSuccess(i, a))), UNBOUNDED), this.i0.length);
+    }
+}
+export function struct(fx) {
+    const entries = Object.entries(fx);
+    return map(tuple(entries.map(([key, fx]) => map(fx, (a) => [key, a]))), Object.fromEntries);
+}
+export function all(fx) {
+    if (Array.isArray(fx))
+        return tuple(fx);
+    else
+        return struct(fx);
+}
+export function exit(fx) {
+    return new ExitFx(fx);
+}
+class ExitFx extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        return this.i0.run(Sink.make((cause) => sink.onSuccess(Exit.failCause(cause)), (a) => sink.onSuccess(Exit.succeed(a))));
+    }
+}
+export function toEnqueue(fx, queue) {
+    return observe(fx, (a) => queue.offer(a));
+}
+export function debounce(fx, delay) {
+    return switchMapEffect(fx, (a) => Effect.as(Effect.sleep(delay), a));
+}
+export function throttle(fx, delay) {
+    return exhaustMapEffect(fx, (a) => Effect.as(Effect.sleep(delay), a));
+}
+export function throttleLatest(fx, delay) {
+    return exhaustMapLatestEffect(fx, (a) => Effect.as(Effect.sleep(delay), a));
+}
+export function fromAsyncIterable(iterable) {
+    return new FromAsyncIterable(iterable);
+}
+class FromAsyncIterable extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        return Effect.asyncEffect((cb) => {
+            const iterator = this.i0[Symbol.asyncIterator]();
+            const loop = (result) => result.done
+                ? Effect.sync(() => cb(Effect.unit))
+                : Effect.zipRight(sink.onSuccess(result.value), Effect.flatMap(Effect.promise(() => iterator.next()), loop));
+            return Effect.flatMap(Effect.promise(() => iterator.next()), loop);
+        });
+    }
+}
+export function findFirst(fx, predicate) {
+    return Effect.asyncEffect((cb) => observe(fx, (a) => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.unit));
+}
+export function first(fx) {
+    return findFirst(fx, constTrue);
+}
+export function either(fx) {
+    return new EitherFx(fx);
+}
+class EitherFx extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        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(fx, that) {
+    return merge(fx, filter(that, constFalse));
+}
+export function mergeRace(fx, that) {
+    return new MergeRace(fx, that);
+}
+class MergeRace extends FxBase {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    run(sink) {
+        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 yield* _(Fiber.joinAll([fiber1, fiber2]));
+        });
+    }
+}
+export function raceAll(fx) {
+    return new RaceAll(fx);
+}
+export function race(fx, that) {
+    return raceAll([fx, that]);
+}
+class RaceAll extends FxBase {
+    i0;
+    constructor(i0) {
+        super();
+        this.i0 = i0;
+    }
+    run(sink) {
+        return Effect.gen(this, function* (_) {
+            const winner = yield* _(Deferred.make());
+            const fibers = [];
+            for (const fx of this.i0) {
+                const fiber = yield* _(Effect.fork(fx.run(Sink.make(sink.onFailure, (a) => Effect.flatMap(Deferred.succeed(winner, fiber), () => sink.onSuccess(a))))));
+                fibers.push(fiber);
             }
-            // Schedule subsequent pulls using the current scheduler.
-            yield* _(Effect.yieldNow(options));
-        }
-    }), Scope.close));
-}
-const matchers = {
-    RefSubject: identity,
-    Fx: identity,
-    Effect: fromEffect,
-    Cause: failCause,
-    Iterable: fromIterable,
-    Otherwise: succeed
-};
-export function from(input) {
-    return matchFxInput(input, matchers);
+            const winningFiber = yield* _(Deferred.await(winner));
+            yield* _(Fiber.interruptAll(fibers.filter((x) => x !== winningFiber)));
+            return yield* _(Fiber.join(winningFiber));
+        });
+    }
+}
+export function snapshot(fx, sampled, f) {
+    return new Snapshot(fx, sampled, f);
+}
+export function sample(fx, sampled) {
+    return snapshot(fx, sampled, (_, b) => b);
+}
+class Snapshot extends FxBase {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+        this.i2 = i2;
+    }
+    run(sink) {
+        return Effect.flatMap(Ref.make(Option.none()), (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 function snapshotEffect(fx, sampled, f) {
+    return new SnapshotEffect(fx, sampled, f);
+}
+class SnapshotEffect extends FxBase {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+        this.i2 = i2;
+    }
+    run(sink) {
+        return Effect.flatMap(Ref.make(Option.none()), (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_(bool, options) {
+    return switchMap(bool, (b) => b ? options.onTrue : options.onFalse);
+}
+export { if_ as if };
+export function when(bool, options) {
+    return if_(bool, {
+        onTrue: succeed(options.onTrue),
+        onFalse: succeed(options.onFalse)
+    });
+}
+export function mapBoth(fx, f, g) {
+    return map(mapError(fx, f), g);
 }
 //# sourceMappingURL=core.js.map