@typed/fx 2.0.0-beta.1 → 2.0.0-beta.11

package/src/Fx/combinators/genScoped.ts

@@ -1,24 +0,0 @@
-import * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
-import type { Fx } from "../Fx.js";
-import { unwrapScoped } from "./unwrapScoped.js";
-
-/** Extract error type from Yieldable (Effect v4) */
-type _YE<Y> = Y extends Effect.Yieldable<any, any, infer E, any> ? E : never;
-/** Extract services type from Yieldable (Effect v4) */
-type _YS<Y> = Y extends Effect.Yieldable<any, any, any, infer R> ? R : never;
-
-/**
- * Creates a scoped Fx using a generator function.
- *
- * Similar to `gen`, but also handles resource management via Scope.
- *
- * @param f - The generator function.
- * @returns An `Fx` representing the result of the generator.
- * @since 1.0.0
- * @category combinators
- */
-export const genScoped = <Yield extends Effect.Yieldable<any, any, any, any>, A, E, R>(
-  f: () => Generator<Yield, Fx<A, E, R>, any>,
-): Fx<A, E | _YE<Yield>, Exclude<R | _YS<Yield>, Scope.Scope>> =>
-  unwrapScoped(Effect.gen(f)) as any;

package/src/Fx/combinators/index.ts

@@ -1,61 +0,0 @@
-export * from "./catch.js";
-export * from "./changesWithEffect.js";
-export * from "./causes.js";
-export * from "./compact.js";
-export * from "./continueWith.js";
-export * from "./dropUntil.js";
-export * from "./additive.js";
-export * from "./ensuring.js";
-export * from "./exhaustLatestMap.js";
-export * from "./exhaustLatestMapEffect.js";
-export * from "./exhaustMap.js";
-export * from "./exhaustMapEffect.js";
-export * from "./exit.js";
-export * from "./filter.js";
-export * from "./filterEffect.js";
-export * from "./filterMap.js";
-export * from "./filterMapEffect.js";
-export * from "./filterMapLoop.js";
-export * from "./filterMapLoopCause.js";
-export * from "./filterMapLoopCauseEffect.js";
-export * from "./filterMapLoopEffect.js";
-export * from "./flatMap.js";
-export * from "./flatMapConcurrently.js";
-export * from "./flatMapConcurrentlyEffect.js";
-export * from "./flatMapEffect.js";
-export * from "./flip.js";
-export * from "./gen.js";
-export * from "./genScoped.js";
-export * from "./keyed.js";
-export * from "./loop.js";
-export * from "./loopCause.js";
-export * from "./loopCauseEffect.js";
-export * from "./loopEffect.js";
-export * from "./map.js";
-export * from "./mapBoth.js";
-export * from "./mapEffect.js";
-export * from "./mapError.js";
-export * from "./mergeAll.js";
-export * from "./mergeOrdered.js";
-export * from "./onError.js";
-export * from "./onExit.js";
-export * from "./onInterrupt.js";
-export * from "./provide.js";
-export * from "./result.js";
-export * from "./scan.js";
-export * from "./skip.js";
-export * from "./skipRepeats.js";
-export * from "./skipWhile.js";
-export * from "./skipRepeatsWith.js";
-export * from "./slice.js";
-export * from "./switchMap.js";
-export * from "./switchMapEffect.js";
-export * from "./take.js";
-export * from "./takeUntil.js";
-export * from "./takeWhile.js";
-export * from "./tapEffect.js";
-export * from "./tuple.js";
-export * from "./unwrap.js";
-export * from "./unwrapScoped.js";
-export * from "./when.js";
-export * from "./zip.js";

package/src/Fx/combinators/keyed.ts

@@ -1,369 +0,0 @@
-import * as Clock from "effect/Clock";
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
-import { dual, identity } from "effect/Function";
-import * as Option from "effect/Option";
-import { pipeArguments } from "effect/Pipeable";
-import { MaxOpsBeforeYield } from "effect/Scheduler";
-import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
-import * as SynchronizedRef from "effect/SynchronizedRef";
-import type * as TestClock from "effect/testing/TestClock";
-import * as RefSubject from "../../RefSubject/RefSubject.js";
-import * as Sink from "../../Sink/Sink.js";
-import type { Fx } from "../Fx.js";
-import type { Add, Moved, Remove, Update } from "../internal/diff.js";
-import { diff, getKeyMap } from "../internal/diff.js";
-import { withScopedFork } from "../internal/scope.js";
-import { FxTypeId } from "../TypeId.js";
-
-/**
- * Configuration options for the `keyed` combinator.
- * @since 1.0.0
- * @category models
- */
-export interface KeyedOptions<A, B, C, E2, R2> {
-  /**
-   * Function to extract a unique key from an element.
-   */
-  readonly getKey: (a: A) => B;
-  /**
-   * Function to transform a value into an Fx, receiving a RefSubject of the value.
-   * This allows the transformation to react to updates of the same item (same key).
-   */
-  readonly onValue: (ref: RefSubject.RefSubject<A>, key: B) => Fx<C, E2, R2 | Scope.Scope>;
-  /**
-   * Optional debounce duration for emission.
-   */
-  readonly debounce?: Duration.Input;
-}
-
-/**
- * Efficiently transforms a list of values into a list of Fx streams, using keys to track identity.
- *
- * This is crucial for performance when rendering lists or managing collections of stateful entities.
- * When the input list changes:
- * - New keys cause `onValue` to be called.
- * - Existing keys have their `RefSubject` updated with the new value.
- * - Removed keys have their corresponding Fx and scope cleaned up.
- *
- * @param fx - An `Fx` emitting an array of values.
- * @param options - Configuration options.
- * @returns An `Fx` emitting an array of results.
- * @since 1.0.0
- * @category combinators
- */
-export const keyed: {
-  <A, B extends PropertyKey, C, E2, R2>(
-    options: KeyedOptions<A, B, C, E2, R2>,
-  ): <E, R>(fx: Fx<ReadonlyArray<A>, E, R>) => Fx<ReadonlyArray<C>, E | E2, R | R2 | Scope.Scope>;
-  <A, E, R, B extends PropertyKey, C, E2, R2>(
-    fx: Fx<ReadonlyArray<A>, E, R>,
-    options: KeyedOptions<A, B, C, E2, R2>,
-  ): Fx<ReadonlyArray<C>, E | E2, R | R2 | Scope.Scope>;
-} = dual(2, function keyed<
-  A,
-  E,
-  R,
-  B extends PropertyKey,
-  C,
-  E2,
-  R2,
->(fx: Fx<ReadonlyArray<A>, E, R>, options: KeyedOptions<A, B, C, E2, R2>): Fx<
-  ReadonlyArray<C>,
-  E | E2,
-  R | R2 | Scope.Scope
-> {
-  return new Keyed(fx, options);
-});
-
-type StateContext<A, C> = {
-  entry: KeyedEntry<A, C>;
-  output: C;
-};
-
-const StateContext = ServiceMap.Service<StateContext<any, any>>("@services/StateContext");
-
-const VARIANCE: Fx.Variance<any, any, any> = {
-  _A: identity,
-  _E: identity,
-  _R: identity,
-};
-
-class Keyed<A, E, R, B extends PropertyKey, C, E2, R2> implements Fx<
-  ReadonlyArray<C>,
-  E | E2,
-  R | R2 | Scope.Scope
-> {
-  readonly [FxTypeId]: Fx.Variance<ReadonlyArray<C>, E | E2, R | R2 | Scope.Scope> = VARIANCE;
-  readonly fx: Fx<ReadonlyArray<A>, E, R>;
-  readonly options: KeyedOptions<A, B, C, E2, R2>;
-
-  constructor(fx: Fx<ReadonlyArray<A>, E, R>, options: KeyedOptions<A, B, C, E2, R2>) {
-    this.fx = fx;
-    this.options = options;
-  }
-
-  run<R3>(sink: Sink.Sink<ReadonlyArray<C>, E | E2, R3>) {
-    return Effect.withFiber((fiber) => runKeyed(this.fx, this.options, sink, fiber.id)).pipe(
-      Effect.provideService(MaxOpsBeforeYield, Infinity),
-    );
-  }
-
-  pipe(this: Keyed<A, E, R, B, C, E2, R2>) {
-    return pipeArguments(this, arguments);
-  }
-}
-
-interface KeyedState<A, B extends PropertyKey, C> {
-  readonly entries: Map<B, KeyedEntry<A, C>>;
-  readonly indices: Map<number, B>;
-  previousValues: ReadonlyArray<A>;
-}
-
-function emptyKeyedState<A, B extends PropertyKey, C>(): KeyedState<A, B, C> {
-  return {
-    entries: new Map(),
-    indices: new Map(),
-    previousValues: [],
-  };
-}
-
-function runKeyed<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
-  fx: Fx<ReadonlyArray<A>, E, R>,
-  options: KeyedOptions<A, B, C, E2, R2>,
-  sink: Sink.Sink<ReadonlyArray<C>, E | E2, R3>,
-  id: number,
-): Effect.Effect<unknown, never, Scope.Scope | R | R2 | R3> {
-  return withDebounceFork((debounceFork, parentScope) => {
-    const state = emptyKeyedState<A, B, C>();
-    const emit = Effect.suspend(() => sink.onSuccess(getReadyIndices(state)));
-    const scheduleNextEmit = debounceFork(emit);
-
-    let first = true;
-    let previousKeyMap: Map<PropertyKey, number> = new Map();
-
-    return fx.run(
-      Sink.make(
-        sink.onFailure,
-        Effect.fn(function* (values: ReadonlyArray<A>) {
-          const previous = state.previousValues;
-          const keyMap = getKeyMap(values, options.getKey);
-
-          let changed = first;
-          first = false;
-
-          for (const patch of diff<A, B>(previous, values, {
-            getKey: options.getKey,
-            previousKeyMap,
-            keyMap,
-          })) {
-            if (patch._tag === "Remove") {
-              changed = true;
-              yield* removeValue(state, patch, state.entries.get(patch.key)!);
-            } else if (patch._tag === "Add") {
-              changed = true;
-              yield* addValue({
-                state,
-                values,
-                patch,
-                id,
-                parentScope,
-                keyedOptions: options,
-                sink,
-                scheduleNextEmit,
-              });
-            } else {
-              yield* updateValue(state, values, patch);
-            }
-          }
-
-          state.previousValues = values;
-          previousKeyMap = keyMap;
-
-          if (changed) {
-            yield* scheduleNextEmit;
-          } else {
-            yield* adjustTime();
-          }
-        }),
-      ),
-    );
-  }, options.debounce || 1);
-}
-
-class KeyedEntry<A, C> {
-  public value: A;
-  public index: number;
-  public output: Option.Option<C>;
-  public readonly ref: RefSubject.RefSubject<A>;
-  public readonly interrupt: Effect.Effect<void>;
-
-  constructor(
-    value: A,
-    index: number,
-    output: Option.Option<C>,
-    ref: RefSubject.RefSubject<A>,
-    interrupt: Effect.Effect<void>,
-  ) {
-    this.value = value;
-    this.index = index;
-    this.output = output;
-    this.ref = ref;
-    this.interrupt = interrupt;
-  }
-}
-
-function getReadyIndices<A, B extends PropertyKey, C>({
-  entries,
-  indices,
-  previousValues,
-}: KeyedState<A, B, C>): ReadonlyArray<C> {
-  const output: Array<C> = [];
-
-  for (let i = 0; i < previousValues.length; ++i) {
-    const key = indices.get(i);
-
-    if (key === undefined) break;
-
-    const entry = entries.get(key)!;
-    if (Option.isSome(entry.output)) {
-      output.push(entry.output.value);
-    } else {
-      break;
-    }
-  }
-
-  return output;
-}
-
-function* addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(options: {
-  state: KeyedState<A, B, C>;
-  values: ReadonlyArray<A>;
-  patch: Add<A, B>;
-  id: number;
-  parentScope: Scope.Scope;
-  keyedOptions: KeyedOptions<A, B, C, E2, R2>;
-  sink: Sink.Sink<ReadonlyArray<C>, E | E2, R2 | R3>;
-  scheduleNextEmit: Effect.Effect<D, never, R3>;
-}) {
-  const { id, keyedOptions, parentScope, patch, scheduleNextEmit, sink, state, values } = options;
-  const { entries, indices } = state;
-  const value = values[patch.index];
-  const childScope = yield* Scope.fork(parentScope, "sequential");
-  const ref = yield* RefSubject.make(Effect.sync<A>(() => entry.value)).pipe(
-    Effect.provideService(Scope.Scope, childScope),
-  );
-
-  const entry: KeyedEntry<A, C> = new KeyedEntry<A, C>(
-    value,
-    patch.index,
-    Option.none(),
-    ref,
-    Scope.close(childScope, Exit.interrupt(id)),
-  );
-
-  entries.set(patch.key, entry);
-  indices.set(patch.index, patch.key);
-
-  yield* Effect.forkIn(
-    keyedOptions
-      .onValue(ref, patch.key)
-      .run(
-        Sink.make(
-          (cause) => sink.onFailure(cause),
-          (output) => {
-            entry.output = Option.some(output);
-
-            return scheduleNextEmit;
-          },
-        ),
-      )
-      .pipe(Effect.provideService(Scope.Scope, childScope)),
-    parentScope,
-  );
-}
-
-function removeValue<A, B extends PropertyKey, C>(
-  { entries, indices }: KeyedState<A, B, C>,
-  patch: Remove<A, B>,
-  entry: KeyedEntry<A, C>,
-) {
-  entries.delete(patch.key);
-  indices.delete(patch.index);
-  return entry.interrupt;
-}
-
-function updateValue<A, B extends PropertyKey, C>(
-  { entries, indices }: KeyedState<A, B, C>,
-  values: ReadonlyArray<A>,
-  patch: Update<A, B> | Moved<A, B>,
-) {
-  const key = patch.key;
-  const entry = entries.get(key)!;
-
-  if (patch._tag === "Moved") {
-    const currentKey = indices.get(patch.index);
-    if (currentKey === key) {
-      indices.delete(patch.index);
-    }
-    indices.set(patch.to, key);
-    entry.value = values[(entry.index = patch.to)];
-  } else {
-    entry.value = values[(entry.index = patch.index)];
-  }
-
-  return RefSubject.set(entry.ref, entry.value);
-}
-
-function withDebounceFork<A, E, R>(
-  f: (
-    fork: <R>(effect: Effect.Effect<A, never, R>) => Effect.Effect<void, never, R>,
-    scope: Scope.Scope,
-  ) => Effect.Effect<A, E, R>,
-  duration: Duration.Input,
-): Effect.Effect<unknown, E, R | Scope.Scope> {
-  return withScopedFork(
-    (fork, scope) =>
-      Effect.flatMap(SynchronizedRef.make(Option.none<Fiber.Fiber<unknown>>()), (ref) =>
-        Effect.flatMap(
-          f(
-            (effect) =>
-              SynchronizedRef.updateEffect(
-                ref,
-                Option.match({
-                  onNone: () => Effect.asSome(fork(Effect.delay(effect, duration))),
-                  onSome: (fiber) =>
-                    Fiber.interrupt(fiber).pipe(
-                      Effect.flatMap(() => fork(Effect.delay(effect, duration))),
-                      Effect.asSome,
-                    ),
-                }),
-              ),
-            scope,
-          ),
-          () =>
-            SynchronizedRef.updateEffect(
-              ref,
-              Option.match({
-                onNone: () => Effect.succeedNone,
-                onSome: (fiber) => Fiber.join(fiber).pipe(Effect.as(Option.none())),
-              }),
-            ),
-        ),
-      ),
-    "sequential",
-  );
-}
-
-function* adjustTime() {
-  const services = yield* Effect.services<never>();
-  const clock = ServiceMap.get(services, Clock.Clock) as Clock.Clock | TestClock.TestClock;
-  if ("adjust" in clock) {
-    yield* clock.adjust(Duration.millis(1));
-  } else {
-    yield* clock.sleep(Duration.millis(1));
-  }
-}

package/src/Fx/combinators/loop.ts

@@ -1,27 +0,0 @@
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Loops over an Fx with an accumulator, producing a new value for each element
- * and updating the accumulator.
- *
- * @param seed - The initial value of the accumulator.
- * @param f - A function that takes the accumulator and an element, returning a tuple of the emitted value and the new accumulator.
- * @returns An `Fx` that emits the transformed values.
- * @since 1.0.0
- * @category combinators
- */
-export const loop: {
-  <B, A, C>(
-    seed: B,
-    f: (acc: B, a: A) => readonly [C, B],
-  ): <E, R>(self: Fx<A, E, R>) => Fx<C, E, R>;
-
-  <A, E, R, B, C>(self: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<C, E, R>;
-} = dual(
-  3,
-  <A, E, R, B, C>(self: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<C, E, R> =>
-    make<C, E, R>((sink) => self.run(sinkCore.loop(sink, seed, f))),
-);

package/src/Fx/combinators/loopCause.ts

@@ -1,34 +0,0 @@
-import type * as Cause from "effect/Cause";
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Loops over the failure causes of an Fx with an accumulator.
- *
- * @param seed - The initial state.
- * @param f - The loop function for causes.
- * @returns An `Fx` with transformed errors.
- * @since 1.0.0
- * @category combinators
- */
-export const loopCause: {
-  <B, A, C>(
-    seed: B,
-    f: (acc: B, a: Cause.Cause<A>) => readonly [Cause.Cause<C>, B],
-  ): <E, R>(self: Fx<A, E, R>) => Fx<A, C, R>;
-
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: Cause.Cause<E>) => readonly [Cause.Cause<C>, B],
-  ): Fx<A, C, R>;
-} = dual(
-  3,
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: Cause.Cause<E>) => readonly [Cause.Cause<C>, B],
-  ): Fx<A, C, R> => make<A, C, R>((sink) => self.run(sinkCore.loopCause(sink, seed, f))),
-);

package/src/Fx/combinators/loopCauseEffect.ts

@@ -1,36 +0,0 @@
-import type * as Cause from "effect/Cause";
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Effectfully loops over the failure causes of an Fx with an accumulator.
- *
- * @param seed - The initial state.
- * @param f - The effectful loop function for causes.
- * @returns An `Fx` with transformed errors.
- * @since 1.0.0
- * @category combinators
- */
-export const loopCauseEffect: {
-  <B, A, E, R2, C>(
-    seed: B,
-    f: (acc: B, a: Cause.Cause<A>) => Effect.Effect<readonly [Cause.Cause<C>, B], R2>,
-  ): <R>(self: Fx<A, E, R>) => Fx<A, C | E, R | R2>;
-
-  <A, E, R, B, R2, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E, R2>,
-  ): Fx<A, C, R | R2>;
-} = dual(
-  3,
-  <A, E, R, B, R2, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E, R2>,
-  ): Fx<A, C | E, R | R2> =>
-    make<A, C | E, R | R2>((sink) => self.run(sinkCore.loopCauseEffect(sink, seed, f))),
-);

package/src/Fx/combinators/loopEffect.ts

@@ -1,34 +0,0 @@
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Effectfully loops over an Fx with an accumulator, producing a new value for each element.
- *
- * @param seed - The initial state.
- * @param f - The effectful loop function.
- * @returns An `Fx` emitting the transformed values.
- * @since 1.0.0
- * @category combinators
- */
-export const loopEffect: {
-  <B, A, E2, R2, C>(
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>,
-  ): <E, R>(self: Fx<A, E | E2, R>) => Fx<C, E | E2, R | R2>;
-
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E, R>,
-  ): Fx<C, E, R>;
-} = dual(
-  3,
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E, R>,
-  ): Fx<C, E, R> => make<C, E, R>((sink) => self.run(sinkCore.loopEffect(seed, f)(sink))),
-);

package/src/Fx/combinators/map.ts

@@ -1,22 +0,0 @@
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Transforms the elements of an Fx using a provided function.
- *
- * @param f - A function that transforms values of type `A` to `B`.
- * @returns An `Fx` that emits values of type `B`.
- * @since 1.0.0
- * @category combinators
- */
-export const map: {
-  <A, B>(f: (a: A) => B): <E, R>(self: Fx<A, E, R>) => Fx<B, E, R>;
-
-  <A, E, R, B>(self: Fx<A, E, R>, f: (a: A) => B): Fx<B, E, R>;
-} = dual(
-  2,
-  <A, E, R, B>(self: Fx<A, E, R>, f: (a: A) => B): Fx<B, E, R> =>
-    make<B, E, R>((sink) => self.run(sinkCore.map(sink, f))),
-);

package/src/Fx/combinators/mapBoth.ts

@@ -1,40 +0,0 @@
-import * as Cause from "effect/Cause";
-import { dual } from "effect/Function";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Transforms both the success and error channels of an Fx using the provided options.
- *
- * Mirrors `Effect.mapBoth`: `onSuccess` maps emitted values, `onFailure` maps the
- * typed failure (via `Cause.map`); defects and interrupts are preserved.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const mapBoth: {
-  <E, E2, A, A2>(options: {
-    readonly onFailure: (e: E) => E2;
-    readonly onSuccess: (a: A) => A2;
-  }): <R>(self: Fx<A, E, R>) => Fx<A2, E2, R>;
-
-  <A, E, R, E2, A2>(
-    self: Fx<A, E, R>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 },
-  ): Fx<A2, E2, R>;
-} = dual(
-  2,
-  <A, E, R, E2, A2>(
-    self: Fx<A, E, R>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 },
-  ): Fx<A2, E2, R> =>
-    make<A2, E2, R>((sink) =>
-      self.run(
-        makeSink(
-          (cause) => sink.onFailure(Cause.map(cause, options.onFailure)),
-          (a) => sink.onSuccess(options.onSuccess(a)),
-        ),
-      ),
-    ),
-);

package/src/Fx/combinators/mapEffect.ts

@@ -1,32 +0,0 @@
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Transforms the elements of an Fx using a provided Effectful function.
- *
- * @param f - A function that transforms values of type `A` to an Effect of `B`.
- * @returns An `Fx` that emits values of type `B`.
- * @since 1.0.0
- * @category combinators
- */
-export const mapEffect: {
-  <A, B, E2, R2>(
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-  ): <E, R>(fx: Fx<A, E | E2, R>) => Fx<B, E | E2, R | R2>;
-
-  <A, E, R, B, E2, R2>(
-    fx: Fx<A, E | E2, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-  ): Fx<B, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-  ): Fx<B, E | E2, R | R2 | Scope.Scope> =>
-    make<B, E | E2, R | R2 | Scope.Scope>((sink) => self.run(sinkCore.mapEffect(sink, f))),
-);