@typed/fx 1.17.4 → 1.18.0

package/src/Computed.ts

@@ -1,163 +1,289 @@
-import * as Option from '@effect/data/Option'
-import * as Pipeable from '@effect/data/Pipeable'
-import * as Effect from '@effect/io/Effect'
-
-import { Filtered, FilteredImpl } from './Filtered.js'
-import { RefTransform, RefTransformImpl, RefTransformInput } from './RefTransform.js'
-import { mapEffect } from './mapEffect.js'
+/**
+ * A Computed is a Subject that has a current value that can be read and observed
+ * @since 1.18.0
+ */
 
-export const ComputedTypeId = Symbol.for('@typed/fx/Computed')
-export type ComputedTypeId = typeof ComputedTypeId
+import type { Tag } from "@typed/context"
+import type { Context, Equivalence, Layer, Runtime } from "effect"
+import * as Effect from "effect/Effect"
+import { equals } from "effect/Equal"
+import { dual } from "effect/Function"
+import * as Option from "effect/Option"
+// eslint-disable-next-line import/no-cycle
+import { Filtered } from "./Filtered"
+import { type Fx } from "./Fx"
+import * as core from "./internal/core"
+import { fromFxEffect } from "./internal/fx"
+import { FxEffectBase } from "./internal/protos"
+import { hold } from "./internal/share"
+import { VersionedTransform } from "./internal/versioned-transform"
+import { ComputedTypeId } from "./TypeId"
+import * as Versioned from "./Versioned"
 
 /**
- * A Computed is essentially a "read-only" RefSubject which allows
- * for mapping over the value using an Effect.
- *
- * It always prefers the latest value so it will utilize switchMap
- * internally when running as an Fx.
+ * A Computed is a Subject that has a current value that can be read and observed
+ * @since 1.18.0
+ * @category models
  */
-export interface Computed<R, E, A> extends RefTransform<R, E, A, R, E, A>, Pipeable.Pipeable {
+export interface Computed<out R, out E, out A> extends Versioned.Versioned<R, never, R, E, A, R, E, A> {
   readonly [ComputedTypeId]: ComputedTypeId
 
-  mapEffect<R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): Computed<R | R2, E | E2, B>
-
-  map<B>(f: (a: A) => B): Computed<R, E, B>
-
-  filterMapEffect<R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
-  ): Filtered<R | R2, E | E2, B>
+  /**
+   * Map the current value of this Computed to a new value using an Effect
+   * @since 1.18.0
+   */
+  readonly mapEffect: <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) => Computed<R | R2, E | E2, B>
 
-  filterMap<B>(f: (a: A) => Option.Option<B>): Filtered<R, E, B>
+  /**
+   * Map the current value of this Computed to a new value
+   * @since 1.18.0
+   */
+  readonly map: <B>(f: (a: A) => B) => Computed<R, E, B>
 
-  filter(f: (a: A) => boolean): Filtered<R, E, A>
+  /**
+   * Map the current value of this Filtered to a new value using an Effect
+   * @since 1.18.0
+   */
+  readonly filterMapEffect: <R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+  ) => Filtered<R | R2, E | E2, B>
 
-  filterEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): Filtered<R | R2, E | E2, A>
+  /**
+   * Map the current value of this Filtered to a new value
+   * @since 1.18.0
+   */
+  readonly filterMap: <B>(f: (a: A) => Option.Option<B>) => Filtered<R, E, B>
 
-  filterNot(f: (a: A) => boolean): Filtered<R, E, A>
+  /**
+   * Filter the current value of this Filtered to a new value using an Effect
+   */
+  readonly filterEffect: <R2, E2>(
+    f: (a: A) => Effect.Effect<R2, E2, boolean>
+  ) => Filtered<R | R2, E | E2, A>
 
-  filterNotEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): Filtered<R | R2, E | E2, A>
+  /**
+   * Filter the current value of this Filtered to a new value
+   */
+  readonly filter: (f: (a: A) => boolean) => Filtered<R, E, A>
 
   /**
-   * @internal
+   * Skip values that match the provided Equivalence instance
    */
-  version(): number
+  readonly skipRepeats: (eq?: Equivalence.Equivalence<A>) => Computed<R, E, A>
 }
 
-export namespace Computed {
-  export type Context<T> = [T] extends [never]
-    ? never
-    : // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    [T] extends [Computed<infer R, infer _E, any>]
-    ? R
-    : never
-  export type Error<T> = [T] extends [never]
-    ? never
-    : // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    [T] extends [Computed<infer _R, infer E, any>]
-    ? E
-    : never
-  export type Success<T> = [T] extends [never]
-    ? never
-    : // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    [T] extends [Computed<infer _R, infer _E, infer A>]
-    ? A
-    : never
-
-  export function tuple<Computeds extends ReadonlyArray<Computed<any, any, any>>>(
-    ...computeds: Computeds
-  ): Computed<
-    Computed.Context<Computeds[number]>,
-    Computed.Error<Computeds[number]>,
-    { readonly [K in keyof Computeds]: Computed.Success<Computeds[K]> }
-  > {
-    return new ComputedImpl(RefTransformInput.tuple(computeds) as any, Effect.succeed) as any
-  }
+/**
+ * Create a Computed from a data type which is an Fx and an Effect.
+ * @since 1.18.0
+ */
+export function Computed<R, E, A, R2, E2, B>(
+  input: Versioned.Versioned<R, never, R, E, A, R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>
+): Computed<R | R2, E | E2, B> {
+  return new ComputedImpl(input, f) as any
+}
 
-  export function struct<Computeds extends Readonly<Record<string, Computed<any, any, any>>>>(
-    computeds: Computeds,
-  ): Computed<
-    Computed.Context<Computeds[string]>,
-    Computed.Error<Computeds[string]>,
-    { readonly [K in keyof Computeds]: Computed.Success<Computeds[K]> }
-  > {
-    return new ComputedImpl(
-      RefTransformInput.tuple(
-        Object.entries(computeds).map(([k, c]) => c.map((v) => [k, v] as const)),
-      ) as any,
-      (entries) => Effect.sync(() => Object.fromEntries(entries as any)),
-    ) as any
-  }
+/**
+ * @since 1.18.0
+ */
+export namespace Computed {
+  /**
+   * @since 1.18.0
+   */
+  export type Context<T> = [T] extends [Computed<infer R, infer _E, infer _A>] ? R : never
+  /**
+   * @since 1.18.0
+   */
+  export type Error<T> = [T] extends [Computed<infer _R, infer E, infer _A>] ? E : never
+  /**
+   * @since 1.18.0
+   */
+  export type Success<T> = [T] extends [Computed<infer _R, infer _E, infer A>] ? A : never
 }
 
-export class ComputedImpl<R, E, A, R2, E2, R3, E3, B>
-  extends RefTransformImpl<
-    R,
-    E,
-    A,
-    R2,
-    E2,
-    A,
-    R | R2 | R3,
-    E | E2 | E3,
-    B,
-    R | R2 | R3,
-    E | E2 | E3,
-    B
-  >
-  implements Computed<R | R2 | R3, E | E2 | E3, B>
+class ComputedImpl<R, E, A, R2, E2, B>
+  extends VersionedTransform<R, never, R, E, A, R, E, A, R | R2, E | E2, B, R | R2, E | E2, B>
+  implements Computed<R | R2, E | E2, B>
 {
   readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
 
   constructor(
-    readonly input: RefTransformInput<R, E, A, R2, E2, A>,
-    f: (a: A) => Effect.Effect<R3, E3, B>,
+    readonly input: Versioned.Versioned<R, never, R, E, A, R, E, A>,
+    readonly f: (a: A) => Effect.Effect<R2, E2, B>
   ) {
     super(
       input,
-      (fx) => mapEffect(fx, f),
-      (eff) => Effect.flatMap(eff, f),
+      (fx) => {
+        const computed = core.skipRepeats(core.mapEffect(fx, f))
+
+        return core.suspend(() => {
+          if (Option.isSome(this._currentValue)) {
+            return core.startWith(computed, this._currentValue.value)
+          } else {
+            return computed
+          }
+        })
+      },
+      Effect.flatMap(f)
     )
   }
 
-  mapEffect<R4, E4, C>(
-    f: (b: B) => Effect.Effect<R4, E4, C>,
-  ): Computed<R | R2 | R3 | R4, E | E2 | E3 | E4, C> {
-    return new ComputedImpl(this as Computed<R | R2 | R3, E | E2 | E3, B>, f)
-  }
+  mapEffect: Computed<R | R2, E | E2, B>["mapEffect"] = (f) => Computed(this, f)
 
-  map<C>(f: (b: B) => C) {
-    return this.mapEffect((a) => Effect.sync(() => f(a)))
-  }
+  map: Computed<R | R2, E | E2, B>["map"] = (f) => this.mapEffect((a) => Effect.sync(() => f(a)))
 
-  filterMapEffect<R4, E4, C>(
-    f: (b: B) => Effect.Effect<R4, E4, Option.Option<C>>,
-  ): Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, C> {
-    return new FilteredImpl(this, f) as Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, C>
-  }
+  filterMapEffect: Computed<R | R2, E | E2, B>["filterMapEffect"] = (f) => Filtered(this, f)
 
-  filterMap<D>(f: (a: B) => Option.Option<D>) {
-    return this.filterMapEffect((a) => Effect.sync(() => f(a)))
-  }
+  filterMap: Computed<R | R2, E | E2, B>["filterMap"] = (f) => this.filterMapEffect((a) => Effect.sync(() => f(a)))
+
+  filterEffect: Computed<R | R2, E | E2, B>["filterEffect"] = (f) =>
+    this.filterMapEffect((a) => Effect.map(f(a), (b) => (b ? Option.some(a) : Option.none())))
 
-  filterEffect<R4, E4>(
-    f: (a: B) => Effect.Effect<R4, E4, boolean>,
-  ): Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, B> {
-    return this.filterMapEffect((a) =>
-      Effect.map(f(a), (b) => (b ? Option.some<B>(a) : Option.none<B>())),
+  filter: Computed<R | R2, E | E2, B>["filter"] = (f) => this.filterEffect((a) => Effect.sync(() => f(a)))
+
+  skipRepeats: (eq?: Equivalence.Equivalence<B> | undefined) => Computed<R | R2, E | E2, B> = (eq = equals) =>
+    Computed<R | R2, E | E2, B, never, never, B>(
+      Versioned.transformFx<R | R2, never, R | R2, E | E2, B, R | R2, E | E2, B, R | R2, E | E2, B>(
+        this,
+        core.skipRepeatsWith(eq)
+      ),
+      Effect.succeed
     )
+}
+
+/**
+ * @since 1.18.0
+ */
+export function combine<const Computeds extends ReadonlyArray<Computed<any, any, any>>>(computeds: Computeds): Computed<
+  Fx.Context<Computeds[keyof Computeds]>,
+  Fx.Error<Computeds[keyof Computeds]>,
+  { readonly [K in keyof Computeds]: Fx.Success<Computeds[keyof Computeds]> }
+> {
+  return Computed(
+    Versioned.combine(computeds) as Versioned.Versioned<
+      Fx.Context<Computeds[keyof Computeds]>,
+      never,
+      Fx.Context<Computeds[keyof Computeds]>,
+      Fx.Error<Computeds[keyof Computeds]>,
+      { readonly [K in keyof Computeds]: Fx.Success<Computeds[keyof Computeds]> },
+      Fx.Context<Computeds[keyof Computeds]>,
+      Fx.Error<Computeds[keyof Computeds]>,
+      { readonly [K in keyof Computeds]: Fx.Success<Computeds[keyof Computeds]> }
+    >,
+    Effect.succeed
+  )
+}
+
+/**
+ * @since 1.18.0
+ */
+export function struct<const Computeds extends Readonly<Record<string, Computed<any, any, any>>>>(
+  computeds: Computeds
+): Computed<
+  Computed.Context<Computeds[keyof Computeds]>,
+  Computed.Error<Computeds[keyof Computeds]>,
+  { readonly [K in keyof Computeds]: Computed.Success<Computeds[K]> }
+> {
+  return Computed(
+    Versioned.struct(computeds) as Versioned.Versioned<
+      Computed.Context<Computeds[keyof Computeds]>,
+      never,
+      Computed.Context<Computeds[keyof Computeds]>,
+      Computed.Error<Computeds[keyof Computeds]>,
+      { readonly [K in keyof Computeds]: Computed.Success<Computeds[K]> },
+      Computed.Context<Computeds[keyof Computeds]>,
+      Computed.Error<Computeds[keyof Computeds]>,
+      { readonly [K in keyof Computeds]: Computed.Success<Computeds[K]> }
+    >,
+    Effect.succeed
+  )
+}
+
+/**
+ * @since 1.18.0
+ */
+export const fromTag: {
+  <S, R2, E2, B>(f: (s: S) => Computed<R2, E2, B>): <I>(tag: Tag<I, S>) => Computed<I | R2, E2, B>
+  <I, S, R2, E2, B>(tag: Tag<I, S>, f: (s: S) => Computed<R2, E2, B>): Computed<I | R2, E2, B>
+} = dual(
+  2,
+  function fromTag<I, S, R2, E2, B>(tag: Tag<I, S>, f: (s: S) => Computed<R2, E2, B>): Computed<I | R2, E2, B> {
+    return new ContextImpl(tag, f)
   }
+)
 
-  filter(f: (a: B) => boolean) {
-    return this.filterEffect((a) => Effect.sync(() => f(a)))
+class ContextImpl<I, S, R2, E2, B> extends FxEffectBase<I | R2, E2, B, I | R2, E2, B>
+  implements Computed<I | R2, E2, B>
+{
+  readonly [ComputedTypeId]: ComputedTypeId = ComputedTypeId
+  private _computed: Effect.Effect<I, never, Computed<R2, E2, B>>
+  readonly version: Effect.Effect<I | R2, never, number>
+
+  constructor(readonly tag: Tag<I, S>, readonly f: (s: S) => Computed<R2, E2, B>) {
+    super()
+
+    this._computed = Effect.map(this.tag, this.f)
+    this.version = Effect.flatMap(this._computed, (c) => c.version)
   }
 
-  filterNotEffect<R4, E4>(
-    f: (a: B) => Effect.Effect<R4, E4, boolean>,
-  ): Filtered<R | R2 | R3 | R4, E | E2 | E3 | E4, B> {
-    return this.filterEffect((a) => Effect.map(f(a), (b) => !b))
+  protected toFx(): Fx<I | R2, E2, B> {
+    return hold(fromFxEffect(this._computed))
   }
 
-  filterNot(f: (a: B) => boolean) {
-    return this.filterNotEffect((a) => Effect.sync(() => f(a)))
+  protected toEffect(): Effect.Effect<I | R2, E2, B> {
+    return Effect.flatten(this._computed)
   }
+
+  mapEffect: Computed<I | R2, E2, B>["mapEffect"] = (f) => Computed(this, f)
+
+  map: Computed<I | R2, E2, B>["map"] = (f) => this.mapEffect((a) => Effect.sync(() => f(a)))
+
+  filterMapEffect: Computed<I | R2, E2, B>["filterMapEffect"] = (f) => Filtered(this, f)
+
+  filterMap: Computed<I | R2, E2, B>["filterMap"] = (f) => this.filterMapEffect((a) => Effect.sync(() => f(a)))
+
+  filterEffect: Computed<I | R2, E2, B>["filterEffect"] = (f) =>
+    this.filterMapEffect((a) => Effect.map(f(a), (b) => (b ? Option.some(a) : Option.none())))
+
+  filter: Computed<I | R2, E2, B>["filter"] = (f) => this.filterEffect((a) => Effect.sync(() => f(a)))
+
+  skipRepeats: (eq?: Equivalence.Equivalence<B> | undefined) => Computed<I | R2, E2, B> = (eq = equals) =>
+    new ContextImpl(this.tag, (s) => this.f(s).skipRepeats(eq))
 }
+
+/**
+ * @since 1.18.0
+ */
+export const provide: {
+  <R2, E2, S>(
+    layer: Layer.Layer<R2, E2, S>
+  ): <R, E, A>(computed: Computed<R, E, A>) => Computed<R2 | Exclude<R, S>, E | E2, A>
+
+  <S>(
+    runtime: Runtime.Runtime<S>
+  ): <R, E, A>(computed: Computed<R, E, A>) => Computed<Exclude<R, S>, E, A>
+
+  <S>(
+    context: Context.Context<S>
+  ): <R, E, A>(computed: Computed<R, E, A>) => Computed<Exclude<R, S>, E, A>
+
+  <R2, E2, S>(
+    layer: Layer.Layer<R2, E2, S>
+  ): <R, E, A>(computed: Computed<R, E, A>) => Computed<R2 | Exclude<R, S>, E | E2, A>
+
+  <R, E, A, R2, E2, S>(
+    computed: Computed<R, E, A>,
+    layer: Layer.Layer<R2, E2, S>
+  ): Computed<R2 | Exclude<R, S>, E | E2, A>
+
+  <R, E, A, S>(computed: Computed<R, E, A>, runtime: Runtime.Runtime<S>): Computed<Exclude<R, S>, E, A>
+  <R, E, A, S>(computed: Computed<R, E, A>, context: Context.Context<S>): Computed<Exclude<R, S>, E, A>
+} = dual(2, function provide<R, E, A, R2, E2, S>(
+  computed: Computed<R, E, A>,
+  layer: Layer.Layer<R2, E2, S>
+): Computed<R2 | Exclude<R, S>, E | E2, A> {
+  return Computed(
+    Versioned.provide(computed, layer),
+    Effect.succeed
+  )
+})

package/src/Emitter.ts

@@ -0,0 +1,54 @@
+/**
+ * An Emitter is a a Sink-like type which is can be utilized to adapt external
+ * APIs into an Fx.
+ * @since 1.18.0
+ */
+
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import type * as Fiber from "effect/Fiber"
+import type * as Scope from "effect/Scope"
+import type { ScopedRuntime } from "./internal/helpers"
+import { scopedRuntime } from "./internal/helpers"
+import type * as Sink from "./Sink"
+
+/**
+ * An Emitter is a a Sink-like type which is can be utilized to adapt external
+ * APIs into an Fx.
+ * @since 1.18.0
+ */
+export interface Emitter<E, A> {
+  (exit: Exit.Exit<E, A>): Fiber.Fiber<never, unknown>
+
+  readonly succeed: (a: A) => Fiber.Fiber<never, unknown>
+  readonly failCause: (e: Cause.Cause<E>) => Fiber.Fiber<never, unknown>
+  readonly fail: (e: E) => Fiber.Fiber<never, unknown>
+  readonly die: (e: unknown) => Fiber.Fiber<never, unknown>
+  readonly end: () => Fiber.Fiber<never, unknown>
+}
+
+/**
+ * Create an Emitter from a Sink
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<E, A>(sink: Sink.WithEarlyExit<E, A>): Effect.Effect<Scope.Scope, never, Emitter<E, A>> {
+  return Effect.map(scopedRuntime<never>(), (runtime) => makeWithRuntime(runtime, sink))
+}
+function makeWithRuntime<E, A>(
+  runtime: ScopedRuntime<never>,
+  sink: Sink.WithEarlyExit<E, A>
+): Emitter<E, A> {
+  function emit(exit: Exit.Exit<E, A>): Fiber.Fiber<never, unknown> {
+    return runtime.run(Exit.match(exit, sink))
+  }
+
+  emit.succeed = (a: A) => emit(Exit.succeed(a))
+  emit.failCause = (e: Cause.Cause<E>) => emit(Exit.failCause(e))
+  emit.fail = (e: E) => emit(Exit.fail(e))
+  emit.die = (e: unknown) => emit(Exit.die(e))
+  emit.end = () => runtime.run(sink.earlyExit)
+
+  return emit
+}