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

package/src/Fx/constructors/make.ts

@@ -1,103 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import type { Fiber } from "effect/Fiber";
-import { identity } from "effect/Function";
-import { pipeArguments } from "effect/Pipeable";
-import * as Scope from "effect/Scope";
-import { withEarlyExit } from "../../Sink/combinators.js";
-import type { Sink } from "../../Sink/Sink.js";
-import type { Fx } from "../Fx.js";
-import { FxTypeId } from "../TypeId.js";
-
-const VARIANCE: Fx.Variance<any, any, any> = {
-  _A: identity,
-  _E: identity,
-  _R: identity,
-};
-
-class Make<A, E, R> implements Fx<A, E, R> {
-  readonly [FxTypeId]: Fx.Variance<A, E, R> = VARIANCE;
-  readonly run: <RSink>(sink: Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>;
-
-  constructor(run: <RSink>(sink: Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>) {
-    this.run = run;
-  }
-
-  pipe(this: Fx<A, E, R>) {
-    return pipeArguments(this, arguments);
-  }
-}
-
-/**
- * Creates an Fx from a function that provides values to a Sink.
- *
- * This is the lowest-level constructor for Fx, giving you full control over
- * the stream's behavior.
- *
- * @param run - A function that takes a `Sink` and returns an `Effect` that drives the stream.
- * @returns An `Fx` instance.
- * @since 1.0.0
- * @category constructors
- */
-export const make = <A, E = never, R = never>(
-  run: <RSink = never>(sink: Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>,
-): Fx<A, E, R> => new Make<A, E, R>(run);
-
-/**
- * Interface for emitting values, errors, or completion signals in a callback-based Fx.
- * @since 1.0.0
- * @category models
- */
-export type Emit<A, E = never> = {
-  succeed: (value: A) => Fiber<unknown, never>;
-  failCause: (cause: Cause.Cause<E>) => Fiber<unknown, never>;
-  fail: (error: E) => Fiber<unknown, never>;
-  die: (error: unknown) => Fiber<unknown, never>;
-  done: () => Fiber<unknown, never>;
-};
-
-/**
- * Creates an Fx from a callback-based source.
- *
- * @param run - A function that receives an `Emit` object to push values/errors.
- *              It can return a cleanup effect.
- * @returns An `Fx` adapted from the callback.
- * @since 1.0.0
- * @category constructors
- */
-export const callback = <A, E = never, R = never>(
-  run: (emit: Emit<A, E>) => void | Effect.Effect<unknown, never, R>,
-): Fx<A, E, R> =>
-  make<A, E, R>((sink) =>
-    Effect.acquireUseRelease(
-      Scope.make(),
-      (scope) =>
-        withEarlyExit(
-          sink,
-          Effect.fn(function* <RSink = never>(sink: Sink.WithEarlyExit<A, E, RSink>) {
-            const services = yield* Effect.services<R | RSink>();
-            const runFork = Effect.runForkWith(services);
-            const controller = new AbortController();
-            yield* Scope.addFinalizer(
-              scope,
-              Effect.sync(() => controller.abort()),
-            );
-
-            const runEffect = <A, E>(effect: Effect.Effect<A, E, RSink>) =>
-              runFork(effect, { signal: controller.signal });
-            const emit: Emit<A, E> = {
-              succeed: (value) => runEffect(sink.onSuccess(value)),
-              failCause: (cause) => runEffect(sink.onFailure(cause)),
-              fail: (error) => runEffect(sink.onFailure(Cause.fail(error))),
-              die: (error) => runEffect(sink.onFailure(Cause.die(error))),
-              done: () => runEffect(sink.earlyExit),
-            };
-
-            const effect = run(emit);
-            if (effect) yield* Scope.addFinalizer(scope, Effect.provideServices(effect, services));
-            return yield* Effect.never;
-          }),
-        ),
-      Scope.close,
-    ),
-  );

package/src/Fx/constructors/periodic.ts

@@ -1,15 +0,0 @@
-import type * as Duration from "effect/Duration";
-import { spaced } from "effect/Schedule";
-import type { Fx } from "../Fx.js";
-import { fromSchedule } from "./fromSchedule.js";
-
-/**
- * Creates an Fx that emits a `void` value periodically.
- *
- * @param period - The duration between emissions.
- * @returns An `Fx` that emits repeatedly.
- * @since 1.0.0
- * @category constructors
- */
-export const periodic = (period: Duration.Input): Fx<void> =>
-  /*#__PURE__*/ fromSchedule(spaced(period));

package/src/Fx/constructors/succeed.ts

@@ -1,37 +0,0 @@
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-/**
- * Creates an Fx that emits a single value and then completes.
- *
- * @param value - The value to emit.
- * @returns An `Fx` that emits the value.
- * @since 1.0.0
- * @category constructors
- */
-export const succeed = <A>(value: A): Fx<A> =>
-  /*#__PURE__*/ make<A>((sink) => sink.onSuccess(value));
-
-/**
- * An Fx that emits `null` and then completes.
- * @since 1.0.0
- * @category constructors
- */
-export const succeedNull = succeed<null>(null);
-export { succeedNull as null };
-
-/**
- * An Fx that emits `undefined` and then completes.
- * @since 1.0.0
- * @category constructors
- */
-export const succeedUndefined = succeed<undefined>(undefined);
-export { succeedUndefined as undefined };
-
-/**
- * An Fx that emits `void` and then completes.
- * @since 1.0.0
- * @category constructors
- */
-export const succeedVoid = succeed<void>(void 0);
-export { succeedVoid as void };

package/src/Fx/constructors/suspend.ts

@@ -1,6 +0,0 @@
-import * as Effect from "effect/Effect";
-import type { Fx } from "../Fx.js";
-import { make } from "./make.js";
-
-export const suspend = <A, E, R>(fx: () => Fx<A, E, R>): Fx<A, E, R> =>
-  make<A, E, R>((sink) => Effect.suspend(() => fx().run(sink)));

package/src/Fx/index.ts

@@ -1,6 +0,0 @@
-export * from "./combinators/index.js";
-export * from "./constructors/index.js";
-export * from "./Fx.js";
-export * from "./run/index.js";
-export * from "./stream.js";
-export * from "./TypeId.js";

package/src/Fx/internal/DeferredRef.ts

@@ -1,87 +0,0 @@
-import * as Deferred from "effect/Deferred";
-import * as Effect from "effect/Effect";
-import type * as Equivalence from "effect/Equivalence";
-import * as Exit from "effect/Exit";
-import * as MutableRef from "effect/MutableRef";
-import * as Option from "effect/Option";
-
-/**
- * This is the core piece of state for {@link RefSubject}. It presents an Yieldable/Effect interface
- * which supports retrieving the latest Exit<A, E> or waiting for an initial Exit<A, E> to be set otherwise.
- *
- * It utilizes a Equivalence to determine if the latest Exit<A, E> is the same as the current Exit<A, E> through the
- * done method.
- *
- * @internal
- */
-export class DeferredRef<E, A> extends Effect.YieldableClass<A, E, never> {
-  public version!: number;
-  public deferred!: Deferred.Deferred<A, E>;
-
-  readonly fiberId: number | undefined;
-  readonly eq: Equivalence.Equivalence<Exit.Exit<A, E>>;
-  readonly current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>;
-
-  constructor(
-    fiberId: number | undefined,
-    eq: Equivalence.Equivalence<Exit.Exit<A, E>>,
-    current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>,
-  ) {
-    super();
-    this.fiberId = fiberId;
-    this.eq = eq;
-    this.current = current;
-    this.reset();
-  }
-
-  asEffect() {
-    return Effect.suspend(() => {
-      const current = MutableRef.get(this.current);
-      if (Option.isNone(current)) {
-        return Deferred.await(this.deferred);
-      } else {
-        return current.value;
-      }
-    });
-  }
-
-  done(exit: Exit.Exit<A, E>): boolean {
-    const current = MutableRef.get(this.current);
-
-    MutableRef.set(this.current, Option.some(exit));
-
-    if (Option.isSome(current) && this.eq(current.value, exit)) {
-      return false;
-    }
-
-    Deferred.doneUnsafe(this.deferred, exit);
-    this.version += 1;
-
-    return true;
-  }
-
-  reset() {
-    MutableRef.set(this.current, Option.none());
-    this.version = -1;
-
-    if (this.deferred) {
-      Deferred.doneUnsafe(this.deferred, Exit.interrupt(this.fiberId));
-    }
-
-    this.deferred = Deferred.makeUnsafe();
-  }
-}
-
-export function make<E, A>(eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
-  return Effect.withFiber((fiber) =>
-    Effect.succeed(new DeferredRef(fiber.id, eq, MutableRef.make(Option.none()))),
-  );
-}
-
-export function unsafeMake<E, A>(
-  id: number | undefined,
-  eq: Equivalence.Equivalence<Exit.Exit<A, E>>,
-  current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>,
-) {
-  return new DeferredRef(id, eq, current);
-}

package/src/Fx/internal/UnionToTuple.ts

@@ -1,12 +0,0 @@
-type Contra<T> = T extends any ? (arg: T) => void : never;
-
-type InferContra<T> = [T] extends [(arg: infer I) => void] ? I : never;
-
-type PickOne<T> = InferContra<InferContra<Contra<Contra<T>>>>;
-
-export type UnionToTuple<T> =
-  PickOne<T> extends infer U
-    ? Exclude<T, U> extends never
-      ? [T]
-      : [...UnionToTuple<Exclude<T, U>>, U]
-    : never;

package/src/Fx/internal/diff.ts

@@ -1,191 +0,0 @@
-import * as Equal from "effect/Equal";
-import type * as Equivalence from "effect/Equivalence";
-import { identity } from "effect/Function";
-
-export type DiffResult<A, B> = ReadonlyArray<Diff<A, B>>;
-
-export type Diff<A, B> = Add<A, B> | Remove<A, B> | Update<A, B> | Moved<A, B>;
-
-export interface Add<A, B> {
-  readonly _tag: "Add";
-  readonly index: number;
-  readonly value: A;
-  readonly key: B;
-}
-
-export const add = <A, B>(value: A, index: number, key: B): Add<A, B> => ({
-  _tag: "Add",
-  index,
-  value,
-  key,
-});
-
-export interface Remove<A, B> {
-  readonly _tag: "Remove";
-  readonly index: number;
-  readonly value: A;
-  readonly key: B;
-}
-
-export const remove = <A, B>(value: A, index: number, key: B): Remove<A, B> => ({
-  _tag: "Remove",
-  index,
-  value,
-  key,
-});
-
-export interface Update<A, B> {
-  readonly _tag: "Update";
-  readonly index: number;
-  readonly value: A;
-  readonly key: B;
-}
-
-export const update = <A, B>(value: A, index: number, key: B): Update<A, B> => ({
-  _tag: "Update",
-  index,
-  value,
-  key,
-});
-
-export interface Moved<A, B> {
-  readonly _tag: "Moved";
-  readonly index: number;
-  readonly to: number;
-  readonly value: A;
-  readonly key: B;
-}
-
-export const moved = <A, B>(value: A, from: number, to: number, key: B): Moved<A, B> => ({
-  _tag: "Moved",
-  index: from,
-  to,
-  value,
-  key,
-});
-
-export type DiffOptions<A, B extends PropertyKey> = {
-  readonly getKey: (a: A) => B;
-  readonly eq?: Equivalence.Equivalence<A>;
-  readonly previousKeyMap?: Map<PropertyKey, number> | undefined;
-  readonly keyMap?: Map<PropertyKey, number> | undefined;
-};
-
-export function diff<A extends PropertyKey>(
-  oldValue: ReadonlyArray<A>,
-  newValue: ReadonlyArray<A>,
-  options?: Omit<DiffOptions<A, A>, "getKey">,
-): DiffResult<A, A>;
-
-export function diff<A, B extends PropertyKey>(
-  oldValue: ReadonlyArray<A>,
-  newValue: ReadonlyArray<A>,
-  options: DiffOptions<A, B>,
-): DiffResult<A, B>;
-
-export function diff<A, B extends PropertyKey>(
-  a: ReadonlyArray<A>,
-  b: ReadonlyArray<A>,
-  options: Partial<DiffOptions<A, B>> = {},
-): DiffResult<A, B> {
-  const getKey = options.getKey ?? (identity as NonNullable<typeof options.getKey>);
-
-  // Fast-path for empty arrays.
-  if (a.length === 0) return b.map((value, i) => add(value, i, getKey(value)));
-  if (b.length === 0) return a.map((value, i) => remove(value, i, getKey(value)));
-
-  const eq = options.eq ?? Equal.equals;
-  const diff: Array<Diff<A, B>> = [];
-  const oldKeyMap = options.previousKeyMap ?? getKeyMap(a, getKey);
-  const keyMap = options.keyMap ?? getKeyMap(b, getKey);
-
-  for (let i = 0; i < a.length; ++i) {
-    const aValue = a[i];
-    const key = getKey(aValue);
-    const bIndex = keyMap.get(key);
-    if (bIndex === undefined) {
-      diff.push(remove(aValue, i, key));
-    }
-  }
-
-  for (let i = 0; i < b.length; ++i) {
-    const bValue = b[i];
-    const key = getKey(bValue);
-    const aIndex = oldKeyMap.get(key);
-    if (aIndex === undefined) {
-      diff.push(add(bValue, i, key));
-    } else {
-      if (aIndex !== i) {
-        diff.push(moved(bValue, aIndex, i, key));
-      } else if (!eq(a[aIndex], bValue)) {
-        diff.push(update(bValue, i, key));
-      }
-    }
-  }
-
-  return diff;
-}
-
-export function diffIterator<A extends PropertyKey>(
-  oldValue: ReadonlyArray<A>,
-  newValue: ReadonlyArray<A>,
-  options?: Omit<DiffOptions<A, A>, "getKey">,
-): Generator<Diff<A, A>>;
-
-export function diffIterator<A, B extends PropertyKey>(
-  oldValue: ReadonlyArray<A>,
-  newValue: ReadonlyArray<A>,
-  options: DiffOptions<A, B>,
-): Generator<Diff<A, B>>;
-
-export function* diffIterator<A, B extends PropertyKey>(
-  a: ReadonlyArray<A>,
-  b: ReadonlyArray<A>,
-  options: Partial<DiffOptions<A, B>> = {},
-): Generator<Diff<A, B>> {
-  const { eq = Object.is, getKey = identity as any } = options;
-  const oldKeyMap = options.previousKeyMap ?? getKeyMap(a, getKey);
-  const keyMap = options.keyMap ?? getKeyMap(b, getKey);
-
-  for (let i = 0; i < a.length; ++i) {
-    const aValue = a[i];
-    const key = getKey(aValue);
-    const bIndex = keyMap.get(key);
-    if (bIndex === undefined) {
-      yield remove(aValue, i, key);
-    }
-  }
-
-  for (let i = 0; i < b.length; ++i) {
-    const bValue = b[i];
-    const key = getKey(bValue);
-    const aIndex = oldKeyMap.get(key);
-    if (aIndex === undefined) {
-      yield add(bValue, i, key);
-    } else {
-      if (aIndex !== i) {
-        yield moved(bValue, aIndex, i, key);
-      } else if (!eq(a[aIndex], bValue)) {
-        yield update(bValue, i, key);
-      }
-    }
-  }
-}
-
-const keysMaps = new WeakMap<any, Map<PropertyKey, number>>();
-
-export function getKeyMap<A>(
-  a: ReadonlyArray<A>,
-  getKey: (a: A) => PropertyKey,
-): Map<PropertyKey, number> {
-  let keyMap = keysMaps.get(a);
-  if (keyMap === undefined) {
-    keyMap = new Map();
-    keysMaps.set(a, keyMap);
-    const len = a.length;
-    for (let i = 0; i < len; ++i) {
-      keyMap.set(getKey(a[i]), i);
-    }
-  }
-  return keyMap;
-}

package/src/Fx/internal/equivalence.ts

@@ -1,12 +0,0 @@
-import { equals } from "effect/Equal";
-import * as Equivalence from "effect/Equivalence";
-import type * as Exit from "effect/Exit";
-
-export const getExitEquivalence = <E, A>(A: Equivalence.Equivalence<A>) =>
-  Equivalence.make<Exit.Exit<A, E>>((a, b) => {
-    if (a._tag === "Failure") {
-      return b._tag === "Failure" && equals(a.cause, b.cause);
-    } else {
-      return b._tag === "Success" && A(a.value, b.value);
-    }
-  });

package/src/Fx/internal/multicast.ts

@@ -1,51 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-
-export class MulticastEffect<A, E, R> extends Effect.YieldableClass<A, E, R> {
-  private _fiber: Fiber.Fiber<A, E> | null = null;
-
-  readonly effect: Effect.Effect<A, E, R>;
-
-  constructor(effect: Effect.Effect<A, E, R>) {
-    super();
-    this.effect = effect;
-  }
-
-  asEffect() {
-    return Effect.suspend(() => {
-      if (this._fiber) {
-        return Fiber.join(this._fiber);
-      } else {
-        return Effect.forkDetach(this.effect).pipe(
-          Effect.tap((fiber) => Effect.sync(() => (this._fiber = fiber))),
-          Effect.flatMap((fiber) =>
-            Effect.ensuring(
-              Fiber.join(fiber),
-              Effect.sync(() => (this._fiber === fiber ? (this._fiber = null) : null)),
-            ),
-          ),
-        );
-      }
-    });
-  }
-
-  interrupt() {
-    return Effect.withFiber((fiber) => {
-      if (this._fiber) {
-        const eff = Fiber.interruptAs(this._fiber, fiber.id);
-        return Effect.ensuring(
-          eff,
-          Effect.sync(() => (this._fiber = null)),
-        );
-      } else {
-        return Effect.void;
-      }
-    });
-  }
-}
-
-export const makeMulticastEffect = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-  Effect.acquireRelease(
-    Effect.sync(() => new MulticastEffect(effect)),
-    (multicastEffect) => multicastEffect.interrupt(),
-  );

package/src/Fx/internal/ring-buffer.ts

@@ -1,60 +0,0 @@
-import { type Effect, flatMap, void as void_ } from "effect/Effect";
-
-export class RingBuffer<A> {
-  readonly capacity: number;
-
-  constructor(capacity: number) {
-    this.capacity = capacity;
-    this._buffer = Array(this.capacity);
-  }
-
-  private _buffer: Array<A>;
-  private _size = 0;
-  private _head = 0;
-
-  get size() {
-    return this._size;
-  }
-
-  push(a: A) {
-    this._buffer[this._head] = a;
-    this._head = (this._head + 1) % this.capacity;
-    if (this._size < this.capacity) {
-      this._size++;
-    }
-  }
-
-  private at(index: number): A {
-    if (this._size < this.capacity) {
-      return this._buffer[index];
-    }
-    return this._buffer[(this._head + index) % this.capacity];
-  }
-
-  forEach<B, E2, R2>(f: (a: A, i: number) => Effect<B, E2, R2>) {
-    switch (this._size) {
-      case 0:
-        return void_;
-      case 1:
-        return f(this.at(0), 0);
-      case 2:
-        return flatMap(f(this.at(0), 0), () => f(this.at(1), 1));
-      case 3:
-        return flatMap(f(this.at(0), 0), () => flatMap(f(this.at(1), 1), () => f(this.at(2), 2)));
-      default: {
-        let eff: Effect<unknown, E2, R2> = f(this.at(0), 0);
-        for (let i = 1; i < this._size; i++) {
-          const idx = i;
-          eff = flatMap(eff, () => f(this.at(idx), idx));
-        }
-        return eff;
-      }
-    }
-  }
-
-  clear() {
-    this._buffer = Array(this.capacity);
-    this._size = 0;
-    this._head = 0;
-  }
-}

package/src/Fx/internal/scope.ts

@@ -1,58 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import type { Scheduler } from "effect/Scheduler";
-import * as Scope from "effect/Scope";
-
-export type ExecutionStrategy = "sequential" | "parallel";
-
-export const withCloseableScope = <A, E, R>(
-  f: (scope: Scope.Closeable) => Effect.Effect<A, E, R>,
-  executionStrategy?: ExecutionStrategy,
-): Effect.Effect<A, E, R | Scope.Scope> =>
-  Effect.scopedWith((scope) => Effect.flatMap(Scope.fork(scope, executionStrategy), f));
-
-export const extendScope = <A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, R | Scope.Scope> =>
-  withCloseableScope(
-    (scope) => Scope.provide(effect.pipe(Effect.onExit((exit) => Scope.close(scope, exit))), scope),
-    "sequential",
-  );
-
-export const withExtendedScope = <A, E, R>(
-  f: (scope: Scope.Closeable) => Effect.Effect<A, E, R>,
-  executionStrategy?: ExecutionStrategy,
-): Effect.Effect<A, E, R | Scope.Scope> =>
-  withCloseableScope(
-    (scope) =>
-      Scope.provide(f(scope).pipe(Effect.onExit((exit) => Scope.close(scope, exit))), scope),
-    executionStrategy,
-  );
-
-export type Fork = <A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-) => Effect.Effect<Fiber.Fiber<A, E>, never, R>;
-
-export const withScopedFork = <A, E, R>(
-  f: (fork: Fork, scope: Scope.Closeable) => Effect.Effect<A, E, R>,
-  executionStrategy?: ExecutionStrategy,
-): Effect.Effect<A, E, R | Scope.Scope> =>
-  withExtendedScope(
-    (scope) =>
-      f(
-        (eff) => Effect.forkIn(eff, scope, { uninterruptible: false, startImmediately: false }),
-        scope,
-      ),
-    executionStrategy,
-  );
-
-export function awaitScopeClose(scope: Scope.Scope) {
-  return Effect.callback<unknown, never, never>(function (this: Scheduler, cb) {
-    return Fiber.interrupt(
-      Effect.runFork(
-        Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.void))),
-        { scheduler: this },
-      ),
-    );
-  });
-}

package/src/Fx/internal/yieldable.ts

@@ -1,31 +0,0 @@
-import * as Effect from "effect/Effect";
-import { identity } from "effect/Function";
-import { pipeArguments } from "effect/Pipeable";
-import type { Sink } from "../../Sink/Sink.js";
-import type * as Fx from "../Fx.js";
-import { FxTypeId } from "../TypeId.js";
-
-const VARIANCE = {
-  _A: identity,
-  _E: identity,
-  _R: identity,
-};
-
-export abstract class YieldableFx<A, E, R, B, E2, R2>
-  extends Effect.YieldableClass<B, E2, R2>
-  implements Fx.Fx<A, E, R>
-{
-  readonly [FxTypeId] = VARIANCE;
-  abstract run<RSink>(sink: Sink<A, E, RSink>): Effect.Effect<unknown, never, R | RSink>;
-  abstract toEffect(): Effect.Effect<B, E2, R2>;
-
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-
-  // Memoize the effect
-  protected _effect: Effect.Effect<B, E2, R2> | null = null;
-  asEffect(): Effect.Effect<B, E2, R2> {
-    return (this._effect ??= this.toEffect());
-  }
-}