@typed/fx 2.0.0-beta.3 → 2.0.0-beta.5

package/src/Fx/combinators/withSpan.ts

@@ -1,24 +0,0 @@
-import * as Effect from "effect/Effect";
-import type { SpanOptionsNoTrace } from "effect/Tracer";
-import { make as makeSink, type Sink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-export const withSpan = <A, E, R>(
-  fx: Fx<A, E, R>,
-  name: string,
-  options?: SpanOptionsNoTrace,
-): Fx<A, E, R> => {
-  return make<A, E, R>(<RSink>(sink: Sink<A, E, RSink>) =>
-    Effect.withSpan(
-      fx.run(
-        makeSink(
-          (cause) => Effect.withSpan(sink.onFailure(cause), `onFailure(${name})`, options),
-          (value) => Effect.withSpan(sink.onSuccess(value), `onSuccess(${name})`, options),
-        ),
-      ),
-      `Fx(${name})`,
-      options,
-    ),
-  );
-};

package/src/Fx/combinators/zip.ts

@@ -1,175 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Queue from "effect/Queue";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-import { map } from "./map.js";
-import { tuple } from "./tuple.js";
-
-/**
- * Zips two Fx streams in strict lockstep: emits a pair `[a, b]` only when both
- * streams have produced their next value. Emits the i-th pair when both have
- * produced at least i values.
- *
- * **Completion:** The zipped stream completes when the **first** of the two
- * streams completes (no further pairs are emitted). The other stream is
- * interrupted.
- *
- * **Errors:** The first failure from either stream fails the zipped stream.
- *
- * @param that - The second Fx stream.
- * @returns An Fx that emits pairs `[A, B]`.
- * @since 1.0.0
- * @category combinators
- */
-export const zip: {
-  <A2, E2, R2>(
-    that: Fx<A2, E2, R2>,
-  ): <A, E, R>(self: Fx<A, E, R>) => Fx<readonly [A, A2], E | E2, R | R2>;
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    that: Fx<A2, E2, R2>,
-  ): Fx<readonly [A, A2], E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    that: Fx<A2, E2, R2>,
-  ): Fx<readonly [A, A2], E | E2, R | R2> =>
-    make<readonly [A, A2], E | E2, R | R2>((sink) =>
-      Effect.gen(function* () {
-        const leftQueue = yield* Queue.unbounded<Option.Option<A>>();
-        const rightQueue = yield* Queue.unbounded<Option.Option<A2>>();
-
-        const leftSink = makeSink(sink.onFailure, (a: A) => Queue.offer(leftQueue, Option.some(a)));
-        const rightSink = makeSink(sink.onFailure, (b: A2) =>
-          Queue.offer(rightQueue, Option.some(b)),
-        );
-
-        const runLeft = self
-          .run(leftSink)
-          .pipe(Effect.ensuring(Queue.offer(leftQueue, Option.none())));
-        const runRight = that
-          .run(rightSink)
-          .pipe(Effect.ensuring(Queue.offer(rightQueue, Option.none())));
-
-        const consumer = Effect.gen(function* () {
-          while (true) {
-            const exitA = yield* Effect.exit(Queue.take(leftQueue));
-            if (Exit.isFailure(exitA)) return;
-            if (Option.isNone(exitA.value)) return;
-            const exitB = yield* Effect.exit(Queue.take(rightQueue));
-            if (Exit.isFailure(exitB)) return;
-            if (Option.isNone(exitB.value)) return;
-            yield* sink.onSuccess([exitA.value.value, exitB.value.value] as const);
-          }
-        });
-
-        const leftFiber = yield* Effect.forkChild(runLeft);
-        const rightFiber = yield* Effect.forkChild(runRight);
-        yield* consumer.pipe(
-          Effect.ensuring(Fiber.interrupt(leftFiber)),
-          Effect.ensuring(Fiber.interrupt(rightFiber)),
-        );
-      }),
-    ),
-);
-
-/**
- * Zips two Fx streams in strict lockstep and combines each pair with a function.
- * Emits `f(a, b)` when both streams have produced their next value.
- *
- * **Completion:** Completes when the **first** of the two streams completes.
- * **Errors:** The first failure from either stream fails the result.
- *
- * @param that - The second Fx stream.
- * @param f - Function to combine the pair `(a, b)` into a single value.
- * @returns An Fx that emits combined values.
- * @since 1.0.0
- * @category combinators
- */
-export const zipWith: {
-  <A, A2, E2, R2, B>(
-    that: Fx<A2, E2, R2>,
-    f: (a: A, b: A2) => B,
-  ): <E, R>(self: Fx<A, E, R>) => Fx<B, E | E2, R | R2>;
-  <A, E, R, A2, E2, R2, B>(
-    self: Fx<A, E, R>,
-    that: Fx<A2, E2, R2>,
-    f: (a: A, b: A2) => B,
-  ): Fx<B, E | E2, R | R2>;
-} = dual(
-  3,
-  <A, E, R, A2, E2, R2, B>(
-    self: Fx<A, E, R>,
-    that: Fx<A2, E2, R2>,
-    f: (a: A, b: A2) => B,
-  ): Fx<B, E | E2, R | R2> => map(zip(self, that), (pair) => f(pair[0], pair[1])),
-);
-
-/**
- * Zips two Fx streams by latest values: waits for both to emit at least once,
- * then emits `[left, right]` whenever **either** stream emits (using the latest
- * value from the other). No strict pairing; output count is the sum of
- * emissions from both after the first pair.
- *
- * **Completion:** Completes when **both** streams have completed.
- * **Errors:** The first failure from either stream fails the result.
- *
- * @param that - The second Fx stream.
- * @returns An Fx that emits `[AL, AR]` on every update from either stream.
- * @since 1.0.0
- * @category combinators
- */
-export const zipLatest: {
-  <AR, ER, RR>(
-    that: Fx<AR, ER, RR>,
-  ): <AL, EL, RL>(self: Fx<AL, EL, RL>) => Fx<readonly [AL, AR], EL | ER, RL | RR>;
-  <AL, EL, RL, AR, ER, RR>(
-    self: Fx<AL, EL, RL>,
-    that: Fx<AR, ER, RR>,
-  ): Fx<readonly [AL, AR], EL | ER, RL | RR>;
-} = dual(
-  2,
-  <AL, EL, RL, AR, ER, RR>(
-    self: Fx<AL, EL, RL>,
-    that: Fx<AR, ER, RR>,
-  ): Fx<readonly [AL, AR], EL | ER, RL | RR> => tuple(self, that),
-);
-
-/**
- * Zips two Fx streams by latest values and combines each pair with a function.
- * Waits for both to emit at least once, then emits `f(left, right)` whenever
- * either stream emits.
- *
- * **Completion:** Completes when **both** streams have completed.
- * **Errors:** The first failure from either stream fails the result.
- *
- * @param that - The second Fx stream.
- * @param f - Function to combine the latest `(left, right)` into a single value.
- * @returns An Fx that emits combined values.
- * @since 1.0.0
- * @category combinators
- */
-export const zipLatestWith: {
-  <AL, AR, ER, RR, B>(
-    that: Fx<AR, ER, RR>,
-    f: (left: AL, right: AR) => B,
-  ): <EL, RL>(self: Fx<AL, EL, RL>) => Fx<B, EL | ER, RL | RR>;
-  <AL, EL, RL, AR, ER, RR, B>(
-    self: Fx<AL, EL, RL>,
-    that: Fx<AR, ER, RR>,
-    f: (left: AL, right: AR) => B,
-  ): Fx<B, EL | ER, RL | RR>;
-} = dual(
-  3,
-  <AL, EL, RL, AR, ER, RR, B>(
-    self: Fx<AL, EL, RL>,
-    that: Fx<AR, ER, RR>,
-    f: (left: AL, right: AR) => B,
-  ): Fx<B, EL | ER, RL | RR> => map(zipLatest(self, that), (pair) => f(pair[0], pair[1])),
-);

package/src/Fx/constructors/at.ts

@@ -1,23 +0,0 @@
-import type * as Duration from "effect/Duration";
-import { flatMap, sleep } from "effect/Effect";
-import { dual } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * Creates an Fx that emits a single value after a specified delay.
- *
- * @param value - The value to emit.
- * @param delay - The duration to wait before emitting.
- * @returns An `Fx` that emits the value after the delay.
- * @since 1.0.0
- * @category constructors
- */
-export const at: {
-  (delay: Duration.Input): <A>(value: A) => Fx<A>;
-  <A>(value: A, delay: Duration.Input): Fx<A>;
-} = dual(
-  2,
-  <A>(value: A, delay: Duration.Input): Fx<A> =>
-    make<A, never, never>((sink) => flatMap(sleep(delay), () => sink.onSuccess(value))),
-);

package/src/Fx/constructors/die.ts

@@ -1,17 +0,0 @@
-import * as Cause from "effect/Cause";
-import { flow } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { failCause } from "./failCause.js";
-
-/**
- * Creates an Fx that immediately terminates with a defect (unexpected error).
- *
- * @param defect - The defect value.
- * @returns An `Fx` that dies immediately.
- * @since 1.0.0
- * @category constructors
- */
-export const die: (defect: unknown) => Fx<never, never, never> = /*#__PURE__*/ flow(
-  Cause.die,
-  failCause,
-);

package/src/Fx/constructors/empty.ts

@@ -1,10 +0,0 @@
-import { void as void_ } from "effect/Effect";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * An Fx that emits no values and completes immediately.
- * @since 1.0.0
- * @category constructors
- */
-export const empty: Fx<never, never, never> = make<never, never, never>(() => void_);

package/src/Fx/constructors/fail.ts

@@ -1,14 +0,0 @@
-import * as Cause from "effect/Cause";
-import { flow } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { failCause } from "./failCause.js";
-
-/**
- * Creates an Fx that immediately fails with the specified error.
- *
- * @param error - The error to fail with.
- * @returns An `Fx` that fails immediately.
- * @since 1.0.0
- * @category constructors
- */
-export const fail: <E>(error: E) => Fx<never, E, never> = /*#__PURE__*/ flow(Cause.fail, failCause);

package/src/Fx/constructors/failCause.ts

@@ -1,14 +0,0 @@
-import type * as Cause from "effect/Cause";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * Creates an Fx that immediately terminates with the specified Cause.
- *
- * @param cause - The cause of failure.
- * @returns An `Fx` that terminates with the given cause.
- * @since 1.0.0
- * @category constructors
- */
-export const failCause = <E>(cause: Cause.Cause<E>): Fx<never, E, never> =>
-  /*#__PURE__*/ make<never, E, never>((sink) => sink.onFailure(cause));

package/src/Fx/constructors/fn.ts

@@ -1,245 +0,0 @@
-import * as Effect from "effect/Effect";
-import type { SpanOptionsNoTrace } from "effect/Tracer";
-import type { unassigned } from "effect/Types";
-import { unwrap } from "../combinators/unwrap.js";
-import type { Fx } from "../Fx.js";
-import { isFx } from "../TypeId.js";
-
-/** Extract error type from Yieldable (Effect v4 has no Yieldable.Error) */
-type _YieldableError<Y> = Y extends Effect.Yieldable<any, any, infer E, any> ? E : never;
-/** Extract services type from Yieldable (Effect v4 has no Yieldable.Services) */
-type _YieldableServices<Y> = Y extends Effect.Yieldable<any, any, any, infer R> ? R : never;
-
-/**
- * @since 1.0.0
- * @category function
- */
-export namespace fn {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Gen = {
-    <
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-    >(
-      body: (this: unassigned, ...args: Args) => Generator<Eff, ReturnFx>,
-    ): (
-      ...args: Args
-    ) => Fx<
-      Fx.Success<ReturnFx>,
-      Fx.Error<ReturnFx> | _YieldableError<Eff>,
-      Fx.Services<ReturnFx> | _YieldableServices<Eff>
-    >;
-    <
-      Self,
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-    >(
-      body: (this: Self, ...args: Args) => Generator<Eff, ReturnFx>,
-    ): (
-      this: Self,
-      ...args: Args
-    ) => Fx<
-      Fx.Success<ReturnFx>,
-      Fx.Error<ReturnFx> | _YieldableError<Eff>,
-      Fx.Services<ReturnFx> | _YieldableServices<Eff>
-    >;
-
-    <
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-      A,
-    >(
-      body: (this: unassigned, ...args: Args) => Generator<Eff, ReturnFx>,
-      a: (
-        _: Fx<
-          Fx.Success<ReturnFx>,
-          Fx.Error<ReturnFx> | _YieldableError<Eff>,
-          Fx.Services<ReturnFx> | _YieldableServices<Eff>
-        >,
-        ...args: Args
-      ) => A,
-    ): (...args: Args) => A;
-    <
-      Self,
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-      A,
-    >(
-      body: (this: Self, ...args: Args) => Generator<Eff, ReturnFx>,
-      a: (
-        _: Fx<
-          Fx.Success<ReturnFx>,
-          Fx.Error<ReturnFx> | _YieldableError<Eff>,
-          Fx.Services<ReturnFx> | _YieldableServices<Eff>
-        >,
-        ...args: Args
-      ) => A,
-    ): (this: Self, ...args: Args) => A;
-
-    <
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-      A,
-      B,
-    >(
-      body: (this: unassigned, ...args: Args) => Generator<Eff, ReturnFx>,
-      a: (
-        _: Fx<
-          Fx.Success<ReturnFx>,
-          Fx.Error<ReturnFx> | _YieldableError<Eff>,
-          Fx.Services<ReturnFx> | _YieldableServices<Eff>
-        >,
-        ...args: Args
-      ) => A,
-      b: (_: A, ...args: Args) => B,
-    ): (...args: Args) => B;
-    <
-      Self,
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-      A,
-      B,
-    >(
-      body: (this: Self, ...args: Args) => Generator<Eff, ReturnFx>,
-      a: (
-        _: Fx<
-          Fx.Success<ReturnFx>,
-          Fx.Error<ReturnFx> | _YieldableError<Eff>,
-          Fx.Services<ReturnFx> | _YieldableServices<Eff>
-        >,
-        ...args: Args
-      ) => A,
-      b: (_: A, ...args: Args) => B,
-    ): (this: Self, ...args: Args) => B;
-
-    <
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-      A,
-      B,
-      C,
-    >(
-      body: (this: unassigned, ...args: Args) => Generator<Eff, ReturnFx>,
-      a: (
-        _: Fx<
-          Fx.Success<ReturnFx>,
-          Fx.Error<ReturnFx> | _YieldableError<Eff>,
-          Fx.Services<ReturnFx> | _YieldableServices<Eff>
-        >,
-        ...args: Args
-      ) => A,
-      b: (_: A, ...args: Args) => B,
-      c: (_: B, ...args: Args) => C,
-    ): (...args: Args) => C;
-    <
-      Self,
-      Eff extends Effect.Yieldable<any, any, any, any>,
-      ReturnFx extends Fx.Any,
-      Args extends Array<any>,
-      A,
-      B,
-      C,
-    >(
-      body: (this: Self, ...args: Args) => Generator<Eff, ReturnFx>,
-      a: (
-        _: Fx<
-          Fx.Success<ReturnFx>,
-          Fx.Error<ReturnFx> | _YieldableError<Eff>,
-          Fx.Services<ReturnFx> | _YieldableServices<Eff>
-        >,
-        ...args: Args
-      ) => A,
-      b: (_: A, ...args: Args) => B,
-      c: (_: B, ...args: Args) => C,
-    ): (this: Self, ...args: Args) => C;
-  };
-
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type NonGen = {
-    <Args extends Array<any>, ReturnFx extends Fx.Any>(
-      body: (this: unassigned, ...args: Args) => ReturnFx,
-    ): (...args: Args) => ReturnFx;
-    <Self, Args extends Array<any>, ReturnFx extends Fx.Any>(
-      body: (this: Self, ...args: Args) => ReturnFx,
-    ): (this: Self, ...args: Args) => ReturnFx;
-
-    <Args extends Array<any>, ReturnFx extends Fx.Any, A>(
-      body: (this: unassigned, ...args: Args) => ReturnFx,
-      a: (_: ReturnFx, ...args: Args) => A,
-    ): (...args: Args) => A;
-    <Self, Args extends Array<any>, ReturnFx extends Fx.Any, A>(
-      body: (this: Self, ...args: Args) => ReturnFx,
-      a: (_: ReturnFx, ...args: Args) => A,
-    ): (this: Self, ...args: Args) => A;
-
-    <Args extends Array<any>, ReturnFx extends Fx.Any, A, B>(
-      body: (this: unassigned, ...args: Args) => ReturnFx,
-      a: (_: ReturnFx, ...args: Args) => A,
-      b: (_: A, ...args: Args) => B,
-    ): (...args: Args) => B;
-    <Self, Args extends Array<any>, ReturnFx extends Fx.Any, A, B>(
-      body: (this: Self, ...args: Args) => ReturnFx,
-      a: (_: ReturnFx, ...args: Args) => A,
-      b: (_: A, ...args: Args) => B,
-    ): (this: Self, ...args: Args) => B;
-
-    <Args extends Array<any>, ReturnFx extends Fx.Any, A, B, C>(
-      body: (this: unassigned, ...args: Args) => ReturnFx,
-      a: (_: ReturnFx, ...args: Args) => A,
-      b: (_: A, ...args: Args) => B,
-      c: (_: B, ...args: Args) => C,
-    ): (...args: Args) => C;
-    <Self, Args extends Array<any>, ReturnFx extends Fx.Any, A, B, C>(
-      body: (this: Self, ...args: Args) => ReturnFx,
-      a: (_: ReturnFx, ...args: Args) => A,
-      b: (_: A, ...args: Args) => B,
-      c: (_: B, ...args: Args) => C,
-    ): (this: Self, ...args: Args) => C;
-  };
-}
-
-export const fn: fn.Gen &
-  fn.NonGen & {
-    (name: string, options?: SpanOptionsNoTrace): fn.Gen & fn.NonGen;
-  } = function (...args: Array<any>): any {
-  const [first, ...rest] = args;
-
-  if (typeof first === "string") {
-    const fn_ = Effect.fn(first, ...rest);
-    return (body: any, ...pipeables: Array<Function>) =>
-      fn_(
-        unwrapApply(body),
-        unwrap,
-        // @ts-expect-error - It's fine to be variadic
-        ...pipeables,
-      );
-  }
-
-  return Effect.fn(
-    unwrapApply(first),
-    unwrap,
-    // @ts-expect-error - It's fine to be variadic
-    ...rest,
-  );
-};
-
-function unwrapApply(fn: Function) {
-  return function (this: any, ...args: Array<any>) {
-    const x = fn.apply(this, args);
-    if (isFx(x)) return Effect.succeed(x);
-    return x;
-  };
-}

package/src/Fx/constructors/fromEffect.ts

@@ -1,24 +0,0 @@
-import * as Effect from "effect/Effect";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * Creates an Fx from an Effect.
- *
- * If the Effect succeeds, the Fx emits the value and completes.
- * If the Effect fails, the Fx fails with the same error.
- *
- * @param effect - The effect to convert.
- * @returns An `Fx` representing the execution of the effect.
- * @since 1.0.0
- * @category constructors
- */
-export const fromEffect = <A, E = never, R = never>(effect: Effect.Effect<A, E, R>): Fx<A, E, R> =>
-  /*#__PURE__*/ make<A, E, R>((sink) => Effect.matchCauseEffect(effect, sink));
-
-/**
- * An Fx that runs forever without emitting any values.
- * @since 1.0.0
- * @category constructors
- */
-export const never: Fx<never, never, never> = make<never, never, never>(() => Effect.never);

package/src/Fx/constructors/fromFailures.ts

@@ -1,19 +0,0 @@
-import * as Cause from "effect/Cause";
-import { flow } from "effect/Function";
-import { failCause } from "./failCause.js";
-
-const fromFailuresCause = <E>(failures: Iterable<E>): Cause.Cause<E> =>
-  Array.from(failures).reduce(
-    (acc, e) => Cause.combine(acc, Cause.fail(e)),
-    Cause.empty as Cause.Cause<E>,
-  );
-
-/**
- * Creates an Fx from a collection of failures (errors).
- *
- * @param failures - An iterable of failures.
- * @returns An `Fx` that fails with the combined failures.
- * @since 1.0.0
- * @category constructors
- */
-export const fromFailures = /*#__PURE__*/ flow(fromFailuresCause, failCause);

package/src/Fx/constructors/fromIterable.ts

@@ -1,15 +0,0 @@
-import { forEach } from "effect/Effect";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * Creates an Fx from an Iterable.
- * Emits each value from the iterable in order and then completes.
- *
- * @param iterable - The iterable to emit values from.
- * @returns An `Fx` that emits the values from the iterable.
- * @since 1.0.0
- * @category constructors
- */
-export const fromIterable = <A>(iterable: Iterable<A>): Fx<A> =>
-  make<A>((sink) => forEach(iterable, sink.onSuccess, { discard: true }));

package/src/Fx/constructors/fromSchedule.ts

@@ -1,18 +0,0 @@
-import { schedule as schedule_Effect } from "effect/Effect";
-import type { Schedule } from "effect/Schedule";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * Creates an Fx that emits values according to a Schedule.
- * The Fx emits `void` each time the schedule fires.
- *
- * @param schedule - The schedule to follow.
- * @returns An `Fx` that emits periodically according to the schedule.
- * @since 1.0.0
- * @category constructors
- */
-export const fromSchedule = <Error, Env>(
-  schedule: Schedule<unknown, unknown, Error, Env>,
-): Fx<void, Error, Env> =>
-  /*#__PURE__*/ make<void, Error, Env>((sink) => schedule_Effect(sink.onSuccess(), schedule));

package/src/Fx/constructors/fromYieldable.ts

@@ -1,17 +0,0 @@
-import type { Yieldable } from "effect/Effect";
-import { matchCauseEffect } from "effect/Effect";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * Creates an Fx from any Yieldable value (e.g., Effect, Promise, etc.).
- *
- * @param yieldable - The yieldable value to convert.
- * @returns An `Fx` that emits the result of the yieldable.
- * @since 1.0.0
- * @category constructors
- */
-export const fromYieldable = <A, E = never, R = never>(
-  yieldable: Yieldable<any, A, E, R>,
-): Fx<A, E, R> =>
-  /*#__PURE__*/ make<A, E, R>((sink) => matchCauseEffect(yieldable.asEffect(), sink));

package/src/Fx/constructors/index.ts

@@ -1,15 +0,0 @@
-export * from "./at.js";
-export * from "./die.js";
-export * from "./empty.js";
-export * from "./fail.js";
-export * from "./failCause.js";
-export * from "./fn.js";
-export * from "./fromEffect.js";
-export * from "./fromFailures.js";
-export * from "./fromIterable.js";
-export * from "./fromSchedule.js";
-export * from "./fromYieldable.js";
-export * from "./interrupt.js";
-export * from "./make.js";
-export * from "./periodic.js";
-export * from "./succeed.js";

package/src/Fx/constructors/interrupt.ts

@@ -1,13 +0,0 @@
-import * as Cause from "effect/Cause";
-import { flow } from "effect/Function";
-import { failCause } from "./failCause.js";
-
-/**
- * Creates an Fx that immediately interrupts.
- *
- * @param id - The FiberId responsible for the interruption.
- * @returns An `Fx` that is interrupted.
- * @since 1.0.0
- * @category constructors
- */
-export const interrupt = /*#__PURE__*/ flow(Cause.interrupt, failCause);