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

package/src/Fx/combinators/mapError.ts

@@ -1,28 +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 the error channel of an Fx using the provided function.
- *
- * Failures (Cause) are mapped via `Cause.map`, so only the typed failure (`Fail`)
- * is transformed; defects and interrupts are preserved unchanged.
- *
- * Mirrors `Effect.mapError`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const mapError: {
-  <E, E2>(f: (e: E) => E2): <A, R>(self: Fx<A, E, R>) => Fx<A, E2, R>;
-
-  <A, E, R, E2>(self: Fx<A, E, R>, f: (e: E) => E2): Fx<A, E2, R>;
-} = dual(
-  2,
-  <A, E, R, E2>(self: Fx<A, E, R>, f: (e: E) => E2): Fx<A, E2, R> =>
-    make<A, E2, R>((sink) =>
-      self.run(makeSink((cause) => sink.onFailure(Cause.map(cause, f)), sink.onSuccess)),
-    ),
-);

package/src/Fx/combinators/mergeAll.ts

@@ -1,22 +0,0 @@
-import * as Effect from "effect/Effect";
-import { skipInterrupt } from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Merges multiple Fx streams into a single Fx that emits values from all input streams concurrently.
- *
- * @param fx - The Fx streams to merge.
- * @returns An `Fx` that emits values from all input streams.
- * @since 1.0.0
- * @category combinators
- */
-export const mergeAll = <FX extends ReadonlyArray<Fx<any, any, any>>>(
-  ...fx: FX
-): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>> =>
-  make<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>>((sink) =>
-    Effect.forEach(fx, (fx) => fx.run(skipInterrupt(sink)), {
-      concurrency: fx.length,
-      discard: true,
-    }),
-  );

package/src/Fx/combinators/mergeOrdered.ts

@@ -1,123 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Deferred from "effect/Deferred";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Sink from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Merges multiple Fx streams concurrently but emits values in the order of the input streams.
- *
- * This ensures that values from the first Fx are emitted before values from the second Fx, and so on.
- * Values from later streams are buffered until earlier streams complete or emit their values (depending on semantics, but usually this means strictly ordered emission).
- *
- * @param fx - The Fx streams to merge.
- * @returns An `Fx` that emits values in order.
- * @since 1.0.0
- * @category combinators
- */
-export function mergeOrdered<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  ...fx: FX
-): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>> {
-  return make<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>>(
-    Effect.fn(function* (sink) {
-      const { makeSink, onEnd } = withBuffers(fx.length, sink);
-
-      yield* Effect.forEach(fx, (fx, i) => Effect.onExit(fx.run(makeSink(i)), () => onEnd(i)), {
-        concurrency: "unbounded",
-        discard: true,
-      });
-    }),
-  );
-}
-
-function withBuffers<A, E, R>(size: number, sink: Sink.Sink<A, E, R>) {
-  const buffers = indexedBuffers(size, sink);
-  const onSuccess = (index: number, value: A) => buffers.get(index)!.onSuccess(value);
-  const onEnd = (index: number) => buffers.get(index)!.onEnd;
-
-  const makeSink = (index: number) =>
-    Sink.make<A, E, R>(
-      (cause) => (Cause.hasInterruptsOnly(cause) ? onEnd(index) : sink.onFailure(cause)),
-      (value) => onSuccess(index, value),
-    );
-
-  return {
-    onSuccess,
-    onEnd,
-    makeSink,
-  } as const;
-}
-
-function indexedBuffers<A, E, R>(size: number, sink: Sink.Sink<A, E, R>) {
-  const buffers = new Map<number, ReturnType<typeof IndexedBuffer<A, E, R>>>();
-
-  const last = size - 1;
-  for (let i = 0; i < size; i++) {
-    const deferred = Deferred.makeUnsafe<void>();
-    const state = {
-      ready: i === 0,
-      deferred,
-    };
-
-    // First should start immediately
-    if (i === 0) {
-      Deferred.doneUnsafe(deferred, Exit.void);
-    }
-
-    buffers.set(
-      i,
-      IndexedBuffer(
-        state,
-        sink,
-        i === last
-          ? Effect.void
-          : Effect.suspend(() => {
-              const next = buffers.get(i + 1)!;
-              next.state.ready = true;
-              return Deferred.done(next.state.deferred, Exit.void);
-            }),
-      ),
-    );
-  }
-
-  return buffers;
-}
-
-function IndexedBuffer<A, E, R>(
-  state: {
-    ready: boolean;
-    deferred: Deferred.Deferred<void>;
-  },
-  sink: Sink.Sink<A, E, R>,
-  onDone: Effect.Effect<void>,
-) {
-  let buffer: Array<A> = [];
-
-  const onSuccess = (value: A) => {
-    if (state.ready) {
-      if (buffer.length === 0) return sink.onSuccess(value);
-      buffer.push(value);
-      const effect = Effect.forEach(buffer, sink.onSuccess);
-      buffer = [];
-      return effect;
-    } else {
-      buffer.push(value);
-      return Effect.void;
-    }
-  };
-
-  const onEnd = Effect.flatMap(Deferred.await(state.deferred), () => {
-    if (buffer.length === 0) return onDone;
-    const effect = Effect.forEach(buffer, sink.onSuccess);
-    buffer = [];
-    return Effect.ensuring(effect, onDone);
-  });
-
-  return {
-    state,
-    onSuccess,
-    onEnd,
-  };
-}

package/src/Fx/combinators/onError.ts

@@ -1,40 +0,0 @@
-import type * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-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";
-
-/**
- * Adds an `Effect.onError`-style finalizer to an `Fx`.
- *
- * The cleanup is run only if the stream fails (including defects / interrupts
- * carried in the `Cause`).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const onError: {
-  <E, X, R2>(
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>,
-  ): <A, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
-
-  <A, E, R, X, R2>(
-    self: Fx<A, E, R>,
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>,
-  ): Fx<A, E, R | R2>;
-} = dual(
-  2,
-  <A, E, R, X, R2>(
-    self: Fx<A, E, R>,
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>,
-  ): Fx<A, E, R | R2> =>
-    make<A, E, R | R2>((sink) =>
-      self.run(
-        makeSink(
-          (cause) => Effect.flatMap(sink.onFailure(cause), () => Effect.ignore(cleanup(cause))),
-          sink.onSuccess,
-        ),
-      ),
-    ),
-);

package/src/Fx/combinators/onExit.ts

@@ -1,82 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-const toFinalizer =
-  <A, E, XE, XR>(f: (exit: Exit.Exit<A, E>) => void | Effect.Effect<void, XE, XR>) =>
-  (exit: Exit.Exit<A, E>): Effect.Effect<void, XE, XR> => {
-    const x = f(exit);
-    return Effect.isEffect(x) ? x : Effect.void;
-  };
-
-/**
- * Adds an `Effect.onExit`-style finalizer to an `Fx`.
- *
- * The finalizer is run when the `Fx` terminates (success, failure, or interruption).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const onExit: {
-  <A, E, XE = never, XR = never>(
-    f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>,
-  ): <R>(self: Fx<A, E, R>) => Fx<A, E | XE, R | XR>;
-
-  <A, E, R, XE = never, XR = never>(
-    self: Fx<A, E, R>,
-    f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>,
-  ): Fx<A, E | XE, R | XR>;
-} = dual(
-  2,
-  <A, E, R, XE, XR>(
-    self: Fx<A, E, R>,
-    f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>,
-  ): Fx<A, E | XE, R | XR> =>
-    make<A, E | XE, R | XR>(
-      Effect.fnUntraced(function* (sink) {
-        const finalizer = toFinalizer(f);
-        const observed = yield* Ref.make(Option.none<Exit.Exit<void, E>>());
-
-        const recordExit = (exit: Exit.Exit<void, E>) =>
-          Ref.modify(observed, (current) =>
-            Option.isNone(current)
-              ? ([true, Option.some(exit)] as const)
-              : ([false, current] as const),
-          ).pipe(Effect.asVoid);
-
-        const runFinalizer = (exit: Exit.Exit<void, E>, allowReportFailure: boolean) =>
-          Effect.matchCauseEffect(finalizer(exit), {
-            onFailure: (cause) => (allowReportFailure ? sink.onFailure(cause) : Effect.void),
-            onSuccess: () => Effect.void,
-          });
-
-        return yield* self
-          .run(
-            makeSink(
-              (cause) =>
-                Effect.flatMap(recordExit(Exit.failCause(cause)), () => sink.onFailure(cause)),
-              sink.onSuccess,
-            ),
-          )
-          .pipe(
-            Effect.onExit((runExit) =>
-              Effect.flatMap(Ref.get(observed), (maybe) =>
-                Option.match(maybe, {
-                  onSome: (exit) => runFinalizer(exit, false),
-                  onNone: () =>
-                    Exit.match(runExit, {
-                      onFailure: (cause) => runFinalizer(Exit.failCause(cause), false),
-                      onSuccess: () => runFinalizer(Exit.succeed<void>(undefined), true),
-                    }),
-                }),
-              ),
-            ),
-          );
-      }),
-    ),
-);

package/src/Fx/combinators/onInterrupt.ts

@@ -1,87 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-const toFinalizer =
-  <XE, XR>(
-    f:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ) =>
-  (interruptors: ReadonlySet<number>) =>
-    typeof f === "function" ? f(interruptors) : f;
-
-/**
- * Adds an `Effect.onInterrupt`-style finalizer to an `Fx`.
- *
- * The finalizer is run only when the stream is interrupted (either via an
- * interrupt cause or by interrupting the running fiber).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const onInterrupt: {
-  <XE, XR>(
-    finalizer:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E | XE, R | XR>;
-
-  <A, E, R, XE, XR>(
-    self: Fx<A, E, R>,
-    finalizer:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ): Fx<A, E | XE, R | XR>;
-} = dual(
-  2,
-  <A, E, R, XE, XR>(
-    self: Fx<A, E, R>,
-    finalizer_:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ): Fx<A, E | XE, R | XR> =>
-    make<A, E | XE, R | XR>(
-      Effect.fnUntraced(function* (sink) {
-        const finalizer = toFinalizer(finalizer_);
-        const interrupted = yield* Ref.make(Option.none<ReadonlySet<number>>());
-
-        const record = (ids: ReadonlySet<number>) =>
-          Ref.modify(interrupted, (current) =>
-            Option.isNone(current)
-              ? ([true, Option.some(ids)] as const)
-              : ([false, current] as const),
-          );
-
-        const runFinalizer = (ids: ReadonlySet<number>) =>
-          Effect.flatMap(record(ids), (first) =>
-            first
-              ? Effect.matchCauseEffect(finalizer(ids), {
-                  onFailure: () => Effect.void,
-                  onSuccess: () => Effect.void,
-                })
-              : Effect.void,
-          );
-
-        return yield* self
-          .run(
-            makeSink(
-              (cause) =>
-                Cause.hasInterruptsOnly(cause)
-                  ? Effect.matchCauseEffect(finalizer(Cause.interruptors(cause)), {
-                      onFailure: (cause2) => sink.onFailure(Cause.combine(cause, cause2)),
-                      onSuccess: () => sink.onFailure(cause),
-                    })
-                  : sink.onFailure(cause),
-              sink.onSuccess,
-            ),
-          )
-          .pipe(Effect.onInterrupt((ids) => runFinalizer(ids)));
-      }),
-    ),
-);

package/src/Fx/combinators/provide.ts

@@ -1,124 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { dual } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Provides context to an Fx from a Layer.
- *
- * The context is provided to the entire Fx stream, including any effects run
- * during its execution. The context is scoped to the lifetime of the stream.
- *
- * @param layer - The Layer to provide.
- * @returns An `Fx` with the required context provided.
- * @since 1.0.0
- * @category combinators
- */
-export const provide: {
-  <R2, E2 = never, R3 = never>(
-    layer: Layer.Layer<R2, E2, R3>,
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, Exclude<R, R2> | R3>;
-
-  <A, E, R, R2, E2 = never, R3 = never>(
-    fx: Fx<A, E, R>,
-    layer: Layer.Layer<R2, E2, R3>,
-  ): Fx<A, E | E2, Exclude<R, R2> | R3>;
-} = dual(
-  2,
-  <A, E, R, R2, E2 = never, R3 = never>(
-    fx: Fx<A, E, R>,
-    layer: Layer.Layer<R2, E2, R3>,
-  ): Fx<A, E | E2, Exclude<R, R2> | R3> =>
-    make<A, E | E2, Exclude<R, R2> | R3>(
-      Effect.fnUntraced(function* (sink) {
-        const scope = yield* Scope.make();
-        const servicesExit = yield* layer.pipe(Layer.buildWithScope(scope), Effect.exit);
-
-        if (Exit.isFailure(servicesExit)) {
-          yield* Scope.close(scope, servicesExit);
-          return yield* sink.onFailure(servicesExit.cause);
-        }
-
-        return yield* fx.run(sink).pipe(
-          Effect.provideServices(servicesExit.value),
-          Effect.onExit((exit) => Scope.close(scope, exit)),
-        );
-      }),
-    ),
-);
-
-export const provideServices: {
-  <R2>(services: ServiceMap.ServiceMap<R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, R2>>;
-
-  <A, E, R, R2>(fx: Fx<A, E, R>, services: ServiceMap.ServiceMap<R2>): Fx<A, E, Exclude<R, R2>>;
-} = dual(
-  2,
-  <A, E, R, R2>(fx: Fx<A, E, R>, services: ServiceMap.ServiceMap<R2>): Fx<A, E, Exclude<R, R2>> =>
-    provide(fx, Layer.succeedServices(services)),
-);
-
-/**
- * Provides a single service to an Fx.
- *
- * Equivalent to `provideServices(fx, ServiceMap.make(tag, service))`. The service
- * is available for the entire Fx stream, scoped to the stream lifetime.
- *
- * @param tag - The service tag (identifier).
- * @param service - The service implementation.
- * @returns An `Fx` with the required service provided.
- * @since 1.0.0
- * @category combinators
- */
-export const provideService: {
-  <Id, S>(
-    tag: ServiceMap.Service<Id, S>,
-    service: S,
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, Id>>;
-  <A, E, R, Id, S>(
-    fx: Fx<A, E, R>,
-    tag: ServiceMap.Service<Id, S>,
-    service: S,
-  ): Fx<A, E, Exclude<R, Id>>;
-} = dual(
-  3,
-  <A, E, R, Id, S>(
-    fx: Fx<A, E, R>,
-    tag: ServiceMap.Service<Id, S>,
-    service: S,
-  ): Fx<A, E, Exclude<R, Id>> => provideServices(fx, ServiceMap.make(tag, service)),
-);
-
-/**
- * Provides a single service to an Fx by running an effect that produces the service.
- *
- * The effect is run when the Fx is run; the resulting service is provided to the
- * entire stream. Equivalent to `provide(fx, Layer.effect(tag, serviceEffect))`.
- *
- * @param tag - The service tag (identifier).
- * @param serviceEffect - Effect that produces the service (may have its own requirements).
- * @returns An `Fx` with the required service provided.
- * @since 1.0.0
- * @category combinators
- */
-export const provideServiceEffect: {
-  <Id, S, E2, R2>(
-    tag: ServiceMap.Service<Id, S>,
-    serviceEffect: Effect.Effect<S, E2, R2>,
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, Exclude<R, Id> | R2>;
-  <A, E, R, Id, S, E2, R2>(
-    fx: Fx<A, E, R>,
-    tag: ServiceMap.Service<Id, S>,
-    serviceEffect: Effect.Effect<S, E2, R2>,
-  ): Fx<A, E | E2, Exclude<R, Id> | R2>;
-} = dual(
-  3,
-  <A, E, R, Id, S, E2, R2>(
-    fx: Fx<A, E, R>,
-    tag: ServiceMap.Service<Id, S>,
-    serviceEffect: Effect.Effect<S, E2, R2>,
-  ): Fx<A, E | E2, Exclude<R, Id> | R2> => provide(fx, Layer.effect(tag, serviceEffect)),
-);

package/src/Fx/combinators/result.ts

@@ -1,39 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Result from "effect/Result";
-import type { Sink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Materializes success and failure of an Fx as `Result` values.
- *
- * - **Success**: each emitted value is wrapped as `Result.succeed(value)`.
- * - **Failure**: any failure (including typed error, defect, and interrupt) is
- *   materialized as `Result.fail(cause)`. The output error type is `Cause<E>`,
- *   so defects and interrupts are explicitly represented in the `Result` and
- *   the resulting Fx has error type `never`.
- *
- * The resulting Fx never fails at the stream level; all outcomes are emitted as
- * `Result<A, Cause<E>>`. Consumers can use `Result.match` or `Result.isSuccess` /
- * `Result.isFailure` to handle success vs failure (including defect/interrupt).
- *
- * @param fx - The `Fx` stream.
- * @returns An `Fx` emitting `Result<A, Cause<E>>`.
- * @since 1.0.0
- * @category combinators
- */
-export const result = <A, E, R>(fx: Fx<A, E, R>): Fx<Result.Result<A, Cause.Cause<E>>, never, R> =>
-  make<Result.Result<A, Cause.Cause<E>>, never, R>((sink) => fx.run(new ResultSink(sink)));
-
-class ResultSink<A, E, R> implements Sink<A, E, R> {
-  readonly sink: Sink<Result.Result<A, Cause.Cause<E>>, never, R>;
-  readonly onSuccess: (value: A) => import("effect/Effect").Effect<unknown, never, R>;
-  readonly onFailure: (cause: Cause.Cause<E>) => import("effect/Effect").Effect<unknown, never, R>;
-
-  constructor(sink: Sink<Result.Result<A, Cause.Cause<E>>, never, R>) {
-    this.sink = sink;
-    const s = sink;
-    this.onSuccess = (value) => s.onSuccess(Result.succeed(value));
-    this.onFailure = (cause) => s.onSuccess(Result.fail(cause));
-  }
-}

package/src/Fx/combinators/scan.ts

@@ -1,82 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual, pipe } from "effect/Function";
-import { loop as sinkLoop, loopEffect as sinkLoopEffect } from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-import { Sink } from "../../Sink.js";
-
-/**
- * Scans the stream with a pure function, emitting the accumulated state after each element.
- * Emits the initial value first, then for each input `a` emits `f(state, a)` and updates state.
- *
- * Semantics align with Effect Stream's `scan`: output is `initial`, `f(initial, a1)`, `f(..., a2)`, ...
- *
- * @param initial - Initial state (first value emitted).
- * @param f - Reducer `(state, value) => nextState`.
- * @returns An `Fx` that emits the accumulated state at each step.
- * @since 1.0.0
- * @category combinators
- */
-export const scan: {
-  <S, A>(initial: S, f: (s: S, a: A) => S): <E, R>(fx: Fx<A, E, R>) => Fx<S, E, R>;
-  <A, E, R, S>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => S): Fx<S, E, R>;
-} = dual(
-  3,
-  <A, E, R, S>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => S): Fx<S, E, R> =>
-    make<S, E, R>((sink) =>
-      Effect.gen(function* () {
-        yield* sink.onSuccess(initial);
-        yield* fx.run(
-          sinkLoop(sink, initial, (s, a) => {
-            const next = f(s, a);
-            return [next, next] as const;
-          }),
-        );
-      }),
-    ),
-);
-
-/**
- * Scans the stream with an effectful function, emitting the accumulated state after each element.
- * Emits the initial value first, then for each input `a` runs `f(state, a)` and emits the resulting state.
- *
- * @param initial - Initial state (first value emitted).
- * @param f - Effectful reducer `(state, value) => Effect<nextState>`.
- * @returns An `Fx` that emits the accumulated state at each step.
- * @since 1.0.0
- * @category combinators
- */
-export const scanEffect: {
-  <S, A, E2, R2>(
-    initial: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>,
-  ): <E, R>(fx: Fx<A, E, R>) => Fx<S, E | E2, R | R2>;
-  <A, E, R, S, E2, R2>(
-    fx: Fx<A, E, R>,
-    initial: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>,
-  ): Fx<S, E | E2, R | R2>;
-} = dual(
-  3,
-  <A, E, R, S, E2, R2>(
-    fx: Fx<A, E, R>,
-    initial: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>,
-  ): Fx<S, E | E2, R | R2> =>
-    make<S, E | E2, R | R2>(<RSink>(sink: Sink<S, E | E2, RSink>) =>
-      Effect.gen(function* () {
-        const services = yield* Effect.services<R | R2 | RSink>();
-        yield* sink.onSuccess(initial);
-        yield* fx.run(
-          sinkLoopEffect(sink, initial, (s, a) =>
-            pipe(
-              f(s, a),
-              Effect.catchCause((cause) => sink.onFailure(cause).pipe(Effect.as(s))),
-              Effect.map((next) => [next, next] as const),
-              Effect.provideServices(services),
-            ),
-          ),
-        );
-      }),
-    ),
-);

package/src/Fx/combinators/skip.ts

@@ -1,41 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { slice } from "./slice.js";
-import { unwrap } from "./unwrap.js";
-
-/**
- * Skips the first `n` elements of an Fx.
- *
- * @param n - The number of elements to skip.
- * @returns An `Fx` that emits values after the first `n` elements.
- * @since 1.0.0
- * @category combinators
- */
-export const skip: {
-  (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
-
-  <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>;
-} = dual(
-  2,
-  <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => slice(fx, { skip: n, take: Infinity }),
-);
-
-/**
- * Skips the first `n` elements where `n` is produced by an Effect.
- *
- * @param count - Effect that produces the number of elements to skip.
- * @returns An `Fx` that emits values after the first `n` elements.
- * @since 1.0.0
- * @category combinators
- */
-export const skipEffect: {
-  <E2, R2>(
-    count: Effect.Effect<number, E2, R2>,
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
-  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2> =>
-    unwrap(Effect.map(count, (n) => skip(fx, n))),
-);

package/src/Fx/combinators/skipRepeats.ts

@@ -1,15 +0,0 @@
-import { equals } from "effect/Equal";
-import type { Fx } from "../Fx.js";
-import { skipRepeatsWith } from "./skipRepeatsWith.js";
-
-const skipRepeats_ = skipRepeatsWith<any>(equals);
-
-/**
- * Drops elements that are equal to the previous element using standard equality.
- *
- * @param fx - The `Fx` stream.
- * @returns An `Fx` with consecutive duplicates removed.
- * @since 1.0.0
- * @category combinators
- */
-export const skipRepeats: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R> = skipRepeats_;