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

package/src/Fx/combinators/tapEffect.ts

@@ -1,39 +0,0 @@
-import * 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";
-
-/**
- * Performs an effect for each element of the Fx, without changing the elements.
- *
- * @param f - An effectful function to apply to each element.
- * @returns An `Fx` that emits the original elements.
- * @since 1.0.0
- * @category combinators
- */
-export const tap: {
-  <A, E2 = never, R2 = never>(
-    f: (a: A) => void | Effect.Effect<unknown, E2, R2>,
-  ): <E, R>(self: Fx<A, E | E2, R>) => Fx<A, E | E2, R | R2>;
-
-  <A, E, R, E2 = never, R2 = never>(
-    self: Fx<A, E | E2, R>,
-    f: (a: A) => void | Effect.Effect<unknown, E2, R2>,
-  ): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => void | Effect.Effect<unknown, E2, R2>,
-  ): Fx<A, E | E2, R | R2> =>
-    make<A, E | E2, R | R2>((sink) =>
-      self.run(
-        sinkCore.tapEffect(sink, (a) => {
-          const x = f(a);
-          if (Effect.isEffect(x)) return x;
-          return Effect.void;
-        }),
-      ),
-    ),
-);

package/src/Fx/combinators/tuple.ts

@@ -1,79 +0,0 @@
-import * as Effect from "effect/Effect";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import { succeed } from "../constructors/succeed.js";
-import type { Fx } from "../Fx.js";
-import { map } from "./map.js";
-
-/**
- * Combines multiple Fx streams into a single Fx that emits a tuple of the latest values from each stream.
- * The resulting Fx waits for all input streams to emit at least once before emitting the first tuple.
- * Afterwards, it emits a new tuple whenever any input stream emits a new value.
- *
- * @param fxs - The Fx streams to combine.
- * @returns An `Fx` emitting tuples of values.
- * @since 1.0.0
- * @category combinators
- */
-export function tuple<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  ...fxs: FX
-): Fx<
-  { readonly [K in keyof FX]: Fx.Success<FX[K]> },
-  Fx.Error<FX[number]>,
-  Fx.Services<FX[number]>
-> {
-  if (fxs.length === 0) return succeed([] as { readonly [K in keyof FX]: Fx.Success<FX[K]> });
-  if (fxs.length === 1) return fxs[0];
-
-  type Result = { readonly [K in keyof FX]: Fx.Success<FX[K]> };
-  return make(
-    Effect.fn(function* (sink) {
-      const len = fxs.length;
-      // oxlint-disable-next-line unicorn/no-new-array
-      const result: Array<Fx.Success<FX[number]>> = new Array(len);
-      const filled = new Set<number>();
-
-      return yield* Effect.forEach(
-        fxs,
-        (fx, i) =>
-          fx.run(
-            makeSink(
-              sink.onFailure,
-              Effect.fn(function* (value) {
-                result[i] = value;
-                filled.add(i);
-                if (filled.size === len) {
-                  yield* sink.onSuccess(result as Result);
-                }
-              }),
-            ),
-          ),
-        { concurrency: "unbounded", discard: true },
-      );
-    }),
-  );
-}
-
-/**
- * Combines a record of Fx streams into a single Fx that emits a record of the latest values.
- * Similar to `tuple`, but for objects.
- *
- * @param fxs - A record of Fx streams.
- * @returns An `Fx` emitting records of values.
- * @since 1.0.0
- * @category combinators
- */
-export function struct<FXS extends Readonly<Record<string, Fx<any, any, any>>>>(
-  fxs: FXS,
-): Fx<
-  { readonly [K in keyof FXS]: Fx.Success<FXS[K]> },
-  Fx.Error<FXS[keyof FXS]>,
-  Fx.Services<FXS[keyof FXS]>
-> {
-  return map(
-    tuple(...Object.entries(fxs).map(([key, fx]) => map(fx, (value) => [key, value] as const))),
-    Object.fromEntries as (entries: ReadonlyArray<readonly [string, any]>) => {
-      readonly [K in keyof FXS]: Fx.Success<FXS[K]>;
-    },
-  );
-}

package/src/Fx/combinators/unwrap.ts

@@ -1,21 +0,0 @@
-import * as Effect from "effect/Effect";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Unwraps an Effect that produces an Fx into a single Fx.
- *
- * @param effect - An `Effect` that produces an `Fx`.
- * @returns An `Fx` that runs the effect and then the produced Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const unwrap = <A, E, R, E2, R2>(
-  effect: Effect.Effect<Fx<A, E, R>, E2, R2>,
-): Fx<A, E | E2, R | R2> =>
-  make<A, E | E2, R | R2>((sink) =>
-    Effect.matchCauseEffect(effect, {
-      onFailure: (cause) => sink.onFailure(cause),
-      onSuccess: (fx) => fx.run(sink),
-    }),
-  );

package/src/Fx/combinators/unwrapScoped.ts

@@ -1,26 +0,0 @@
-import * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Unwraps an Effect that produces an Fx into a single Fx, managing the scope of the effect.
- *
- * The scope of the effect is closed when the Fx completes or is interrupted.
- *
- * @param effect - An `Effect` that produces an `Fx`.
- * @returns An `Fx` that runs the effect and then the produced Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const unwrapScoped = <A, E, R, E2, R2>(
-  effect: Effect.Effect<Fx<A, E, R>, E2, R2 | Scope.Scope>,
-): Fx<A, E | E2, Exclude<R | R2, Scope.Scope>> =>
-  make<A, E | E2, Exclude<R | R2, Scope.Scope>>((sink) =>
-    Effect.scoped(
-      Effect.matchCauseEffect(effect, {
-        onFailure: (cause) => sink.onFailure(cause),
-        onSuccess: (fx) => fx.run(sink),
-      }),
-    ),
-  );

package/src/Fx/combinators/when.ts

@@ -1,64 +0,0 @@
-import { dual } from "effect/Function";
-import type { Scope } from "effect/Scope";
-import { succeed } from "../constructors/succeed.js";
-import type { Fx } from "../Fx.js";
-import { switchMap } from "./switchMap.js";
-
-/**
- * Conditionally runs one of two Fx streams based on the boolean value emitted by the condition stream.
- *
- * @param condition - An `Fx` emitting booleans.
- * @param matchers - An object containing `onTrue` and `onFalse` Fx streams.
- * @returns An `Fx` that switches between `onTrue` and `onFalse` based on the condition.
- * @since 1.0.0
- * @category combinators
- */
-const if_: {
-  <B, E2, R2, C, E3, R3>(matchers: {
-    onTrue: Fx<B, E2, R2>;
-    onFalse: Fx<C, E3, R3>;
-  }): <E, R>(condition: Fx<boolean, E, R>) => Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope>;
-
-  <E, R, B, E2, R2, C, E3, R3>(
-    condition: Fx<boolean, E, R>,
-    matchers: {
-      onTrue: Fx<B, E2, R2>;
-      onFalse: Fx<C, E3, R3>;
-    },
-  ): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope>;
-} = dual(
-  2,
-  <E, R, B, E2, R2, C, E3, R3>(
-    condition: Fx<boolean, E, R>,
-    matchers: {
-      onTrue: Fx<B, E2, R2>;
-      onFalse: Fx<C, E3, R3>;
-    },
-  ): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope> => {
-    return switchMap(
-      condition,
-      (pass): Fx<B | C, E2 | E3, R2 | R3> => (pass ? matchers.onTrue : matchers.onFalse),
-    );
-  },
-);
-
-export { if_ as if };
-
-/**
- * Conditionally emits one of two values based on the boolean value emitted by the condition stream.
- *
- * @param condition - An `Fx` emitting booleans.
- * @param matchers - An object containing `onTrue` and `onFalse` values.
- * @returns An `Fx` that emits the matched value.
- * @since 1.0.0
- * @category combinators
- */
-export const when = <E, R, B, C>(
-  condition: Fx<boolean, E, R>,
-  matchers: {
-    onTrue: B;
-    onFalse: C;
-  },
-): Fx<B | C, E, R | Scope> => {
-  return if_(condition, { onTrue: succeed(matchers.onTrue), onFalse: succeed(matchers.onFalse) });
-};

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/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.DurationInput): <A>(value: A) => Fx<A>;
-  <A>(value: A, delay: Duration.DurationInput): Fx<A>;
-} = dual(
-  2,
-  <A>(value: A, delay: Duration.DurationInput): 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));