@typed/fx 1.17.3 → 1.18.0

package/dist/esm/internal/core.js

@@ -0,0 +1,841 @@
+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";
+import * as helpers from "./helpers";
+import * as Provide from "./provide";
+import * as strategies from "./strategies";
+import { compileSyncReducer, Filter, FilterMap, Map } from "./sync-operator";
+import * as Emitter from "../Emitter";
+import * as Sink from "../Sink";
+import { boundsFrom, mergeBounds } from "./bounds";
+import { matchEffectPrimitive } from "./effect-primitive";
+import { Empty, Fail, FromIterable, FromSink, Never, Succeed, Suspend, Sync, ToFx, Transformer, TransformerCause, TransformerEffect, WithEarlyExit, WithFlattenStrategy, WithScopedFork } from "./fx-primitive";
+import { adjustTime } from "./helpers";
+import { matchFxInput } from "./matchers";
+import { OnceEffect } from "./protos";
+import { run } from "./run";
+const constUnit = () => Effect.unit;
+class Merge extends ToFx {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super(i0, i1);
+        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);
+        }
+    }
+    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
+                }));
+        }
+    }
+}
+class Slice extends ToFx {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super(i0, i1);
+        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);
+        }
+    }
+    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 {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super(i0, i1, i2);
+        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));
+        }
+        else if (fx instanceof TransformerEffect) {
+            return new FilterMapLoopEffect(fx.i0, b, compileEffectLoop(fx.i1, (b, a) => Effect.sync(() => f(b, a))));
+        }
+        else {
+            return new Loop(fx, f, b);
+        }
+    }
+    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 {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super(i0, i1, i2);
+        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);
+            })));
+        }));
+    }
+}
+class LoopEffect extends ToFx {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super(i0, i1, i2);
+        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));
+        }
+        else if (fx instanceof Transformer) {
+            return new FilterMapLoopEffect(fx.i0, b, compileEffectLoop(liftSyncOperator(fx.i1), f));
+        }
+        else {
+            return new LoopEffect(fx, f, b);
+        }
+    }
+    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 {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super(i0, i1, i2);
+        this.i0 = i0;
+        this.i1 = i1;
+        this.i2 = i2;
+    }
+    toFx() {
+        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);
+                })
+            }))));
+        }));
+    }
+}
+class FxProvide extends ToFx {
+    i0;
+    i1;
+    constructor(i0, i1) {
+        super(i0, i1);
+        this.i0 = i0;
+        this.i1 = i1;
+    }
+    static make(fx, provide) {
+        if (fx instanceof FxProvide) {
+            return new FxProvide(fx.i0, Provide.merge(fx.i1, provide));
+        }
+        else {
+            return new FxProvide(fx, provide);
+        }
+    }
+    toFx() {
+        return fromSink((sink) => Effect.catchAllCause(Provide.provideToEffect(run(this.i0, sink), this.i1), sink.onFailure));
+    }
+}
+class Snapshot extends ToFx {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super(i0, i1, i2);
+        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))
+        });
+    }
+    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))))))));
+    }
+}
+class Middleware extends ToFx {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super(i0, i1);
+        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)));
+        }
+        else {
+            return new Middleware(fx, middleware, mapSink);
+        }
+    }
+    toFx() {
+        return fromSink((sink) => this.i1(run(this.i0, this.i2(sink))));
+    }
+}
+export function succeed(value) {
+    return new Succeed(value);
+}
+export function fromIterable(iterable) {
+    return new FromIterable(iterable);
+}
+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 drain(fx) {
+    return observe(fx, constUnit);
+}
+export function toArray(fx) {
+    return Effect.suspend(() => {
+        const array = [];
+        return Effect.as(observe(fx, (a) => Effect.sync(() => array.push(a))), array);
+    });
+}
+export function toReadonlyArray(fx) {
+    return toArray(fx);
+}
+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 struct(fxs) {
+    return map(combine(Reflect.ownKeys(fxs).map((k) => map(fxs[k], (a) => [k, a]))), Object.fromEntries);
+}
+export function merge(fxs) {
+    return Merge.make(fxs, strategies.Unordered(Infinity));
+}
+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 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 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);
+        }));
+    }
+}
+class FilterMapReduce extends Effectable.Class {
+    i0;
+    i1;
+    i2;
+    constructor(i0, i1, i2) {
+        super();
+        this.i0 = i0;
+        this.i1 = i1;
+        this.i2 = 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)));
+            }
+            else {
+                return Effect.sync(() => reduceFilterIterable(fx.i0, seed, f));
+            }
+        }
+        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);
+        });
+    }
+}
+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;
+        }
+        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;
+        }
+    }
+    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 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))
+    });
+}
+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)));
+            }
+            // 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);
+}
+//# sourceMappingURL=core.js.map