@typed/fx 0.0.9 → 0.0.12

package/esm/reduce.d.ts

@@ -1,7 +0,0 @@
-import * as Effect from '@effect/core/io/Effect';
-import * as Maybe from '@tsplus/stdlib/data/Maybe';
-import { Fx } from './Fx.js';
-export declare function reduceFilterMap<R, E, A, E1, B>(seed: B, f: (b: B, a: A) => Maybe.Maybe<B>): (fx: Fx<R, E, A, E1>) => Effect.Effect<R, E1 | E, B>;
-export declare function reduce<B, A>(seed: B, f: (b: B, a: A) => B): <R, E, E1>(fx: Fx<R, E, A, E1>) => Effect.Effect<R, E | E1, B>;
-export declare function collectAll<R, E, A, E1>(fx: Fx<R, E, A, E1>): Effect.Effect<R, E | E1, readonly A[]>;
-//# sourceMappingURL=reduce.d.ts.map

package/esm/reduce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reduce.d.ts","sourceRoot":"","sources":["../src/reduce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,wBAAwB,CAAA;AAGhD,OAAO,KAAK,KAAK,MAAM,2BAA2B,CAAA;AAElD,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAI5B,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,QAC5E,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAG,aAAa,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAG1D;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,kEAwBzD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EACpC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GAClB,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,CAExC"}

package/esm/reduce.js

@@ -1,35 +0,0 @@
-import * as Effect from '@effect/core/io/Effect';
-import { makeRef } from '@effect/core/io/Ref';
-import { pipe } from '@fp-ts/data/Function';
-import * as Maybe from '@tsplus/stdlib/data/Maybe';
-import { Sink } from './Sink.js';
-import { FilterMapFx, MapFx } from './map.js';
-export function reduceFilterMap(seed, f) {
-    return (fx) => {
-        return reduceFilterMap_(fx, seed, f);
-    };
-}
-export function reduce(seed, f) {
-    return (fx) => {
-        if (fx instanceof FilterMapFx) {
-            return pipe(fx.fx, reduceFilterMap(seed, (b, a) => pipe(a, fx.f, Maybe.map((a2) => f(b, a2)))));
-        }
-        if (fx instanceof MapFx) {
-            return pipe(fx.fx, reduce(seed, (b, a) => f(b, fx.f(a))));
-        }
-        return reduce_(fx, seed, f);
-    };
-}
-export function collectAll(fx) {
-    return reduce_(fx, [], (b, a) => b.concat([a]));
-}
-function reduce_(fx, seed, f) {
-    return pipe(makeRef(() => seed), Effect.flatMap((ref) => fx.run(Sink((a) => ref.update((b) => f(b, a)), Effect.failCause, ref.get))));
-}
-function reduceFilterMap_(fx, seed, f) {
-    return pipe(makeRef(() => seed), Effect.flatMap((ref) => fx.run(Sink((a) => ref.modify((b) => [
-        null,
-        pipe(f(b, a), Maybe.getOrElse(() => b)),
-    ]), Effect.failCause, ref.get))));
-}
-//# sourceMappingURL=reduce.js.map

package/esm/reduce.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reduce.js","sourceRoot":"","sources":["../src/reduce.ts"],"names":[],"mappings":"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"}

package/esm/takeUntil.d.ts

@@ -1,4 +0,0 @@
-import { Predicate } from '@fp-ts/data/Predicate';
-import { Fx } from './Fx.js';
-export declare function takeUntil<A>(predicate: Predicate<A>): <R, E, E1>(fx: Fx<R, E, A, E1>) => Fx<R, E, A, E1>;
-//# sourceMappingURL=takeUntil.d.ts.map

package/esm/takeUntil.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"takeUntil.d.ts","sourceRoot":"","sources":["../src/takeUntil.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEjD,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAI5B,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,sDAmBnD"}

package/esm/takeUntil.js

@@ -1,19 +0,0 @@
-import * as Effect from '@effect/core/io/Effect';
-import * as Exit from '@effect/core/io/Exit';
-import { pipe } from '@fp-ts/data/Function';
-import { Fx } from './Fx.js';
-import { deferredCallback } from './_internal.js';
-export function takeUntil(predicate) {
-    return (fx) => Fx((sink) => deferredCallback((cb) => {
-        return fx.run({
-            ...sink,
-            event: (a) => {
-                if (!predicate(a)) {
-                    return sink.event(a);
-                }
-                return pipe(sink.end, Effect.tap((b) => cb(Exit.succeed(b))));
-            },
-        });
-    }));
-}
-//# sourceMappingURL=takeUntil.js.map

package/esm/takeUntil.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"takeUntil.js","sourceRoot":"","sources":["../src/takeUntil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,wBAAwB,CAAA;AAChD,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAG3C,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEjD,MAAM,UAAU,SAAS,CAAI,SAAuB;IAClD,OAAO,CAAW,EAAmB,EAAmB,EAAE,CACxD,EAAE,CAAC,CAAY,IAA2B,EAAE,EAAE,CAC5C,gBAAgB,CAA8B,CAAC,EAAE,EAAE,EAAE;QACnD,OAAO,EAAE,CAAC,GAAG,CAAC;YACZ,GAAG,IAAI;YACP,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE;gBACX,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;oBACjB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;iBACrB;gBAED,OAAO,IAAI,CACT,IAAI,CAAC,GAAG,EACR,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CACvC,CAAA;YACH,CAAC;SACF,CAAC,CAAA;IACJ,CAAC,CAAC,CACH,CAAA;AACL,CAAC"}

package/esm/tap.d.ts

@@ -1,9 +0,0 @@
-import * as Cause from '@effect/core/io/Cause';
-import * as Effect from '@effect/core/io/Effect';
-import { Fx } from './Fx.js';
-export declare function tap<A, B>(f: (a: A) => B): <R, E, E1>(fx: Fx<R, E, A, E1>) => Fx<R, E, A, E1>;
-export declare function tapEffect<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E, E1>(fx: Fx<R, E, A, E1>) => Fx<R2 | R, E2 | E, A, E2 | E1>;
-export declare function tapCauseEffect<E, R2, E2, B>(f: (e: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): <R, A, E1>(fx: Fx<R, E, A, E1>) => Fx<R2 | R, E | E2, A, E2 | E1>;
-export declare function tapErrorEffect<E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, B>): <R, A, E1>(fx: Fx<R, E, A, E1>) => Fx<R2 | R, E | E2, A, E2 | E1>;
-export declare function tapEndEffect<R2, E2, B>(effect: Effect.Effect<R2, E2, B>): <R, E, A, E1>(fx: Fx<R, E, A, E1>) => Fx<R2 | R, E2 | E, A, E2 | E1>;
-//# sourceMappingURL=tap.d.ts.map

package/esm/tap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../src/tap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,KAAK,MAAM,MAAM,wBAAwB,CAAA;AAIhD,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAI5B,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,sDAEvC;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,qEAK5E;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,qEAK9F;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,qEAejF;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,wEAGvE"}

package/esm/tap.js

@@ -1,23 +0,0 @@
-import * as Cause from '@effect/core/io/Cause';
-import * as Effect from '@effect/core/io/Effect';
-import { flow, pipe } from '@fp-ts/data/Function';
-import * as Either from '@tsplus/stdlib/data/Either';
-import { Fx } from './Fx.js';
-import { Sink } from './Sink.js';
-import { map } from './map.js';
-export function tap(f) {
-    return map((a) => (f(a), a));
-}
-export function tapEffect(f) {
-    return (fx) => Fx((sink) => fx.run(Sink((a) => pipe(a, f, Effect.zipRight(sink.event(a))), sink.error, sink.end)));
-}
-export function tapCauseEffect(f) {
-    return (fx) => Fx((sink) => fx.run(Sink(sink.event, (e) => pipe(e, f, Effect.zipRight(sink.error(e))), sink.end)));
-}
-export function tapErrorEffect(f) {
-    return (fx) => Fx((sink) => fx.run(Sink(sink.event, (e) => pipe(Cause.failureOrCause(e), Either.fold(flow(f, Effect.zipRight(sink.error(e))), sink.error)), sink.end)));
-}
-export function tapEndEffect(effect) {
-    return (fx) => Fx((sink) => fx.run(Sink(sink.event, sink.error, Effect.zipRight(sink.end)(effect))));
-}
-//# sourceMappingURL=tap.js.map

package/esm/tap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap.js","sourceRoot":"","sources":["../src/tap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,KAAK,MAAM,MAAM,wBAAwB,CAAA;AAChD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,KAAK,MAAM,MAAM,4BAA4B,CAAA;AAEpD,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAE9B,MAAM,UAAU,GAAG,CAAO,CAAc;IACtC,OAAO,GAAG,CAAC,CAAC,CAAI,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AACjC,CAAC;AAED,MAAM,UAAU,SAAS,CAAe,CAAqC;IAC3E,OAAO,CAAW,EAAmB,EAAkC,EAAE,CACvE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CACV,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CACtF,CAAA;AACL,CAAC;AAED,MAAM,UAAU,cAAc,CAAe,CAAkD;IAC7F,OAAO,CAAW,EAAmB,EAAkC,EAAE,CACvE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CACV,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CACtF,CAAA;AACL,CAAC;AAED,MAAM,UAAU,cAAc,CAAe,CAAqC;IAChF,OAAO,CAAW,EAAmB,EAAkC,EAAE,CACvE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CACV,EAAE,CAAC,GAAG,CACJ,IAAI,CACF,IAAI,CAAC,KAAK,EACV,CAAC,CAAC,EAAE,EAAE,CACJ,IAAI,CACF,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,EACvB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CACjE,EACH,IAAI,CAAC,GAAG,CACT,CACF,CACF,CAAA;AACL,CAAC;AAED,MAAM,UAAU,YAAY,CAAY,MAAgC;IACtE,OAAO,CAAc,EAAmB,EAAkC,EAAE,CAC1E,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;AACzF,CAAC"}

package/esm/zipItems.d.ts

@@ -1,4 +0,0 @@
-import { Fx } from './Fx.js';
-export declare function zipItems<A, B, C>(array: ReadonlyArray<A>, f: (a: A, b: B) => C): <R, E, E1>(fx: Fx<R, E, B, E1>) => Fx<R, E, C, E1>;
-export declare function withItems<A>(array: ReadonlyArray<A>): <R, E, B, E1>(fx: Fx<R, E, B, E1>) => Fx<R, E, A, E1>;
-//# sourceMappingURL=zipItems.d.ts.map

package/esm/zipItems.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zipItems.d.ts","sourceRoot":"","sources":["../src/zipItems.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAI5B,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,sDA2B9E;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,yDAEnD"}

package/esm/zipItems.js

@@ -1,23 +0,0 @@
-import * as Effect from '@effect/core/io/Effect';
-import * as Exit from '@effect/core/io/Exit';
-import { flow, pipe } from '@fp-ts/data/Function';
-import { identity } from '@tsplus/stdlib/data/Function';
-import { Fx } from './Fx.js';
-import { Sink } from './Sink.js';
-import { deferredCallback } from './_internal.js';
-export function zipItems(array, f) {
-    return (fx) => Fx((sink) => deferredCallback((cb) => {
-        let i = 0;
-        return fx.run(Sink((b) => {
-            const a = array[i++];
-            const c = f(a, b);
-            return pipe(sink.event(c), Effect.flatMap((x) => i === array.length
-                ? pipe(sink.end, Effect.flatMap(flow(Exit.succeed, cb)))
-                : Effect.succeed(x)));
-        }, sink.error, sink.end));
-    }));
-}
-export function withItems(array) {
-    return (fx) => pipe(fx, zipItems(array, identity));
-}
-//# sourceMappingURL=zipItems.js.map

package/esm/zipItems.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"zipItems.js","sourceRoot":"","sources":["../src/zipItems.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,wBAAwB,CAAA;AAChD,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAEvD,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEjD,MAAM,UAAU,QAAQ,CAAU,KAAuB,EAAE,CAAoB;IAC7E,OAAO,CAAW,EAAmB,EAAmB,EAAE,CACxD,EAAE,CAAC,CAAY,IAA2B,EAAE,EAAE,CAC5C,gBAAgB,CAA8B,CAAC,EAAE,EAAE,EAAE;QACnD,IAAI,CAAC,GAAG,CAAC,CAAA;QAET,OAAO,EAAE,CAAC,GAAG,CACX,IAAI,CACF,CAAC,CAAC,EAAE,EAAE;YACJ,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAA;YACpB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;YAEjB,OAAO,IAAI,CACT,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EACb,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CACnB,CAAC,KAAK,KAAK,CAAC,MAAM;gBAChB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;gBACxD,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CACtB,CACF,CAAA;QACH,CAAC,EACD,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,GAAG,CACT,CACF,CAAA;IACH,CAAC,CAAC,CACH,CAAA;AACL,CAAC;AAED,MAAM,UAAU,SAAS,CAAI,KAAuB;IAClD,OAAO,CAAc,EAAmB,EAAmB,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAA;AACnG,CAAC"}

package/perf/filter-map-reduce.ts

@@ -1,49 +0,0 @@
-import * as EffectStream from '@effect/core/Stream/Stream'
-import { pipe } from '@fp-ts/data/Function'
-import * as M from '@most/core'
-import * as Chunk from '@tsplus/stdlib/collections/Chunk'
-import * as rxjs from 'rxjs'
-
-import {
-  array,
-  effectTsStreamTest,
-  fxEffectTest,
-  iterations,
-  mostStreamTest,
-  runPerformanceTest,
-  rxjsObservableTest,
-} from './_internal.js'
-
-import * as Stream from '@/index.js'
-
-const filterEvens = (x: number) => x % 2 === 0
-const addOne = (x: number) => x + 1
-const add = (x: number, y: number): number => x + y
-
-runPerformanceTest({
-  name: 'filter -> map -> reduce ' + iterations + ' integers',
-  cases: [
-    fxEffectTest(() =>
-      pipe(
-        Stream.from(array),
-        Stream.filter(filterEvens),
-        Stream.map(addOne),
-        Stream.reduce(0, add),
-      ),
-    ),
-    mostStreamTest(() =>
-      pipe(M.periodic(0), M.withItems(array), M.filter(filterEvens), M.map(addOne), M.scan(add, 0)),
-    ),
-    rxjsObservableTest(() =>
-      pipe(rxjs.from(array), rxjs.filter(filterEvens), rxjs.map(addOne), rxjs.scan(add, 0)),
-    ),
-    effectTsStreamTest(() =>
-      pipe(
-        EffectStream.fromChunk(Chunk.from(array)),
-        EffectStream.filter(filterEvens),
-        EffectStream.map(addOne),
-        EffectStream.scan(0, add),
-      ),
-    ),
-  ],
-})

package/perf/flatMap.ts

@@ -1,48 +0,0 @@
-import * as EffectStream from '@effect/core/Stream/Stream'
-import { pipe } from '@fp-ts/data/Function'
-import * as M from '@most/core'
-import * as Chunk from '@tsplus/stdlib/collections/Chunk'
-import * as rxjs from 'rxjs'
-
-import {
-  array,
-  effectTsStreamTest,
-  fxEffectTest,
-  iterations,
-  mostStreamTest,
-  runPerformanceTest,
-  rxjsObservableTest,
-} from './_internal.js'
-
-import * as Stream from '@/index.js'
-
-const nestedArray = array.map((x) => Array.from({ length: x }, (_, i) => x * 1000 + i))
-
-const add = (x: number, y: number): number => x + y
-
-runPerformanceTest({
-  name: 'flatMap ' + iterations + ' integers',
-  cases: [
-    fxEffectTest(() =>
-      pipe(Stream.from(nestedArray), Stream.flatMap(Stream.from), Stream.reduce(0, add)),
-    ),
-    mostStreamTest(() =>
-      pipe(
-        M.periodic(0),
-        M.withItems(nestedArray),
-        M.chain((ns) => pipe(M.periodic(0), M.withItems(ns))),
-        M.scan(add, 0),
-      ),
-    ),
-    rxjsObservableTest(() =>
-      pipe(rxjs.from(nestedArray), rxjs.flatMap(rxjs.from), rxjs.scan(add, 0)),
-    ),
-    effectTsStreamTest(() =>
-      pipe(
-        EffectStream.fromChunk(Chunk.from(nestedArray)),
-        EffectStream.flatMap((ns) => EffectStream.fromChunk(Chunk.from(ns))),
-        EffectStream.scan(0, add),
-      ),
-    ),
-  ],
-})

package/perf/switchMap.ts

@@ -1,40 +0,0 @@
-import { pipe } from '@fp-ts/data/Function'
-import * as M from '@most/core'
-import * as rxjs from 'rxjs'
-
-import {
-  array,
-  fxEffectTest,
-  iterations,
-  mostStreamTest,
-  runPerformanceTest,
-  rxjsObservableTest,
-} from './_internal.js'
-
-import * as Stream from '@/index.js'
-
-const nestedArray = array.map((x) => Array.from({ length: x }, (_, i) => x * 1000 + i))
-
-const add = (x: number, y: number): number => x + y
-
-runPerformanceTest({
-  name: 'switchMap ' + iterations + ' integers',
-  cases: [
-    fxEffectTest(() =>
-      pipe(Stream.from(nestedArray), Stream.switchMap(Stream.from), Stream.reduce(0, add)),
-    ),
-    mostStreamTest(() =>
-      pipe(
-        M.periodic(0),
-        M.withItems(nestedArray),
-        M.map((ns) => pipe(M.periodic(0), M.withItems(ns))),
-        M.switchLatest,
-        M.scan(add, 0),
-      ),
-    ),
-    rxjsObservableTest(() =>
-      pipe(rxjs.from(nestedArray), rxjs.switchMap(rxjs.from), rxjs.scan(add, 0)),
-    ),
-    // Effect Stream is pull-based and does not offer switchMap
-  ],
-})

package/src/Sink.ts

@@ -1,84 +0,0 @@
-import { Cause } from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import { flow, pipe } from '@fp-ts/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-export interface Sink<E, A, R2, E2, B> {
-  readonly event: (value: A) => Effect.Effect<R2, E2, unknown>
-  readonly error: (cause: Cause<E>) => Effect.Effect<R2, E2, B>
-  readonly end: Effect.Effect<R2, E2, B>
-}
-
-export function Sink<E, A, R2 = never, E2 = E, B = void>(
-  event: Sink<E, A, R2, E2, B>['event'],
-  error: Sink<E, A, R2, E2, B>['error'] = Effect.failCause as any,
-  end: Sink<E, A, R2, E2, B>['end'] = Effect.unit as any,
-): Sink<E, A, R2, E2, B> {
-  return { event, error, end }
-}
-
-export namespace Sink {
-  export type InputErrorsOf<T> = T extends Sink<infer R, any, any, any, any> ? R : never
-  export type EventOf<T> = T extends Sink<any, infer R, any, any, any> ? R : never
-  export type ResourcesOf<T> = T extends Sink<any, any, infer R, any, any> ? R : never
-  export type OutputErrorsOf<T> = T extends Sink<any, any, any, infer R, any> ? R : never
-  export type OutputOf<T> = T extends Sink<any, any, any, any, infer R> ? R : never
-}
-
-export function mapInputEvent<A, B>(
-  f: (a: A) => B,
-): <E, R2, E2, C>(sink: Sink<E, B, R2, E2, C>) => Sink<E, A, R2, E2, C> {
-  return (sink) => Sink(flow(f, sink.event), sink.error, sink.end)
-}
-
-export function mapInputEventEffect<A, R3, E3, B>(
-  f: (a: A) => Effect.Effect<R3, E3, B>,
-): <E, R2, E2, C>(sink: Sink<E, B, R2, E2, C>) => Sink<E, A, R2 | R3, E2 | E3, C> {
-  return (sink) => Sink(flow(f, Effect.flatMap(sink.event)), sink.error, sink.end)
-}
-
-export function mapInputCause<E, E2>(
-  f: (e: Cause<E>) => Cause<E2>,
-): <A, R2, E3, B>(sink: Sink<E2, A, R2, E3, B>) => Sink<E, A, R2, E3, B> {
-  return (sink) => Sink(sink.event, flow(f, sink.error), sink.end)
-}
-
-export function mapInputCauseEffect<E, R3, E3, E2>(
-  f: (e: Cause<E>) => Effect.Effect<R3, E3, Cause<E2>>,
-): <A, R2, E4, B>(sink: Sink<E2, A, R2, E4, B>) => Sink<E, A, R2 | R3, E3 | E4, B> {
-  return (sink) => Sink(sink.event, flow(f, Effect.flatMap(sink.error)), sink.end)
-}
-
-export function mapOutput<B, C>(
-  f: (b: B) => C,
-): <E, A, R2, E2>(sink: Sink<E, A, R2, E2, B>) => Sink<E, A, R2, E2, C> {
-  return (sink) => Sink(sink.event, flow(sink.error, Effect.map(f)), pipe(sink.end, Effect.map(f)))
-}
-
-export function mapOutputEffect<B, R3, E3, C>(
-  f: (b: B) => Effect.Effect<R3, E3, C>,
-): <E, A, R2, E2>(sink: Sink<E, A, R2, E2, B>) => Sink<E, A, R2 | R3, E2 | E3, C> {
-  return (sink) =>
-    Sink(sink.event, flow(sink.error, Effect.flatMap(f)), pipe(sink.end, Effect.flatMap(f)))
-}
-
-export function mapOutputCause<E2, E3>(f: (e: Cause<E2>) => Cause<E3>) {
-  return <E, A, R2, B>(sink: Sink<E, A, R2, E2, B>): Sink<E, A, R2, E3, B> =>
-    Sink(
-      flow(sink.event, Effect.mapErrorCause(f)),
-      flow(sink.error, Effect.mapErrorCause(f)),
-      pipe(sink.end, Effect.mapErrorCause(f)),
-    )
-}
-
-export function filterMap<A, B>(f: (a: A) => Maybe.Maybe<B>) {
-  return <E, R2, E2, C>(sink: Sink<E, B, R2, E2, C>): Sink<E, A, R2, E2, C> =>
-    Sink(
-      flow(
-        f,
-        Maybe.fold(() => Effect.unit, sink.event),
-      ),
-      sink.error,
-      sink.end,
-    )
-}

package/src/TSemaphore.ts

@@ -1,8 +0,0 @@
-import * as TSemaphore from '@effect/core/stm/TSemaphore'
-
-import { transform } from './transform.js'
-
-export const withPermit = (self: TSemaphore.TSemaphore) => transform(TSemaphore.withPermit(self))
-
-export const withPermits = (permits: number) => (self: TSemaphore.TSemaphore) =>
-  transform(TSemaphore.withPermits(permits)(self))

package/src/drain.ts

@@ -1,21 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { Fiber } from '@effect/core/io/Fiber'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-
-export function drainNow<R, E, A, E1>(fx: Fx<R, E, A, E1>): Effect.Effect<R, E | E1, void> {
-  return fx.run(Sink(Effect.succeed, Effect.failCause, Effect.unit))
-}
-
-export function drain<R, E, A, E1>(
-  fx: Fx<R, E, A, E1>,
-): Effect.Effect<R, never, Fiber.Runtime<E | E1, void>> {
-  return Effect.fork(drainNow(fx))
-}
-
-export function drainDaemon<R, E, A, E1>(
-  fx: Fx<R, E, A, E1>,
-): Effect.Effect<R, never, Fiber.Runtime<E | E1, void>> {
-  return Effect.forkDaemon(drainNow(fx))
-}

package/src/empty.ts

@@ -1,5 +0,0 @@
-import { Fx } from './Fx.js'
-
-export function empty<A>(): Fx<unknown, never, A, never> {
-  return Fx((sink) => sink.end)
-}

package/src/from.test.ts

@@ -1,18 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { unsafeRunPromise } from '@effect/core/io/Effect'
-
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
-
-describe(import.meta.url, () => {
-  describe('from', () => {
-    it('converts a collection into a fx', async () => {
-      const values = [1, 2, 3]
-      const test = collectAll(from(values))
-      const events = await unsafeRunPromise(test)
-
-      deepStrictEqual(events, values)
-    })
-  })
-})

package/src/from.ts

@@ -1,18 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-import { Collection } from '@tsplus/stdlib/collections/Collection'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-
-export function from<A>(collection: Collection<A>): Fx<never, never, A> {
-  return new FromCollectionFx(collection)
-}
-
-export class FromCollectionFx<A> implements Fx<never, never, A> {
-  constructor(readonly collection: Collection<A>) {}
-
-  run<R2, E2, B>(sink: Sink<never, A, R2, E2, B>): Effect.Effect<R2, E2, B> {
-    return pipe(Effect.forEachDiscard(this.collection, sink.event), Effect.zipRight(sink.end))
-  }
-}

package/src/fromCallback.ts

@@ -1,40 +0,0 @@
-import { Cause } from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import * as Exit from '@effect/core/io/Exit'
-import { unsafeForkUnstarted } from '@effect/core/io/Fiber/_internal/runtime'
-import { flow } from '@fp-ts/data/Function'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-
-export function make<R, E, A>(
-  f: (sink: {
-    readonly event: (a: A) => void
-    readonly error: (cause: Cause<E>) => void
-    readonly end: () => void
-  }) => Effect.Canceler<R>,
-): Fx<R, E, A> {
-  return Fx<R, E, A>(<R2, E2, B>(sink: Sink<E, A, R2, E2, B>) =>
-    Effect.withFiberRuntime<R | R2, E2, B>((fiber, status) => {
-      const unsafeRun = <R, E, A>(
-        eff: Effect.Effect<R, E, A>,
-        observer: (exit: Exit.Exit<E, A>) => void,
-      ) => {
-        const f = unsafeForkUnstarted(eff, fiber, status.runtimeFlags)
-        f.addObserver(observer)
-        f.start(eff)
-      }
-
-      return Effect.asyncEffect((cb) =>
-        f({
-          event: (a) =>
-            unsafeRun(sink.event(a), (exit) =>
-              Exit.isFailure(exit) ? cb(Effect.failCause(exit.cause)) : undefined,
-            ),
-          error: (e) => unsafeRun(sink.error(e), flow(Effect.done, cb)),
-          end: () => unsafeRun(sink.end, flow(Effect.done, cb)),
-        }),
-      )
-    }),
-  )
-}

package/src/loop.ts

@@ -1,37 +0,0 @@
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-
-export function loop<A, B, C>(seed: A, f: (a: A, b: B) => readonly [C, A]) {
-  return <R, E, E1>(fx: Fx<R, E, B, E1>): Fx<R, E, C, E1> => new LoopFx(fx, seed, f)
-}
-
-export function scan<A, B>(seed: A, f: (a: A, b: B) => A) {
-  return loop(seed, (a, b: B) => {
-    const x = f(a, b)
-    return [x, x]
-  })
-}
-
-class LoopFx<R, E, E1, A, B, C> implements Fx<R, E, C, E1> {
-  constructor(
-    readonly fx: Fx<R, E, B, E1>,
-    readonly seed: A,
-    readonly f: (a: A, b: B) => readonly [C, A],
-  ) {}
-
-  readonly run: Fx<R, E, C, E1>['run'] = (sink) => {
-    let acc = this.seed
-
-    return this.fx.run(
-      Sink(
-        (b) => {
-          const [c, a] = this.f(acc, b)
-          acc = a
-          return sink.event(c)
-        },
-        sink.error,
-        sink.end,
-      ),
-    )
-  }
-}

package/src/map.ts

@@ -1,83 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { flow, identity, pipe } from '@fp-ts/data/Function'
-import { Predicate } from '@fp-ts/data/Predicate'
-import { Refinement } from '@fp-ts/data/Refinement'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Fx } from './Fx.js'
-import * as Sink from './Sink.js'
-import { FromEffectFx } from './fromEffect.js'
-
-export function map<A, B>(f: (a: A) => B) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, B, E1> => MapFx.make(fx, f)
-}
-
-export function as<B>(b: B) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, B, E1> => map(() => b)(fx)
-}
-
-export function asUnit<R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, void, E1> {
-  return as<void>(undefined)(fx)
-}
-
-export class MapFx<R, E, A, B, E1> implements Fx<R, E, B, E1> {
-  constructor(readonly fx: Fx<R, E, A, E1>, readonly f: (a: A) => B) {}
-
-  run<R2, E2, C>(sink: Sink.Sink<E, B, R2, E2, C>): Effect.Effect<R | R2, E1 | E2, C> {
-    return this.fx.run(Sink.mapInputEvent(this.f)(sink))
-  }
-
-  static make = <R, E, A, B, E1>(fx: Fx<R, E, A, E1>, f: (a: A) => B): Fx<R, E, B, E1> => {
-    if (fx instanceof MapFx) {
-      return new MapFx(fx.fx, flow(fx.f, f))
-    }
-
-    if (fx instanceof FromEffectFx) {
-      return new FromEffectFx(pipe(fx.effect, Effect.map(f)))
-    }
-
-    if (fx instanceof FilterMapFx) {
-      return FilterMapFx.make(fx.fx, flow(fx.f, Maybe.map(f)))
-    }
-
-    return new MapFx(fx, f)
-  }
-}
-
-export function filterMap<A, B>(f: (a: A) => Maybe.Maybe<B>) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, B, E1> => FilterMapFx.make(fx, f)
-}
-
-export function filter<A, B extends A>(
-  predicate: Refinement<A, B>,
-): <R, E, E1>(fx: Fx<R, E, A, E1>) => Fx<R, E, B, E1>
-export function filter<A>(
-  predicate: Predicate<A>,
-): <R, E, E1>(fx: Fx<R, E, A, E1>) => Fx<R, E, A, E1>
-
-export function filter<A>(predicate: Predicate<A>) {
-  return filterMap((a: A) => Maybe.fromPredicate(a, predicate))
-}
-
-export function compact<R, E, A, E1>(fx: Fx<R, E, Maybe.Maybe<A>, E1>): Fx<R, E, A, E1> {
-  return pipe(fx, filterMap(identity))
-}
-
-export class FilterMapFx<R, E, A, E1, B> implements Fx<R, E, B, E1> {
-  constructor(readonly fx: Fx<R, E, A, E1>, readonly f: (a: A) => Maybe.Maybe<B>) {}
-
-  run<R2, E2, C>(sink: Sink.Sink<E, B, R2, E2, C>): Effect.Effect<R | R2, E1 | E2, C> {
-    return this.fx.run(pipe(sink, Sink.filterMap(this.f)))
-  }
-
-  static make = <R, E, A, E1, B>(
-    fx: Fx<R, E, A, E1>,
-    f: (a: A) => Maybe.Maybe<B>,
-  ): Fx<R, E, B, E1> => {
-    if (fx instanceof FilterMapFx) {
-      return new FilterMapFx(fx.fx, flow(fx.f, Maybe.flatMap(f)))
-    }
-
-    return new FilterMapFx(fx, f)
-  }
-}

package/src/never.ts

@@ -1,5 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-
-import { fromEffect } from './fromEffect.js'
-
-export const never = fromEffect(Effect.never)