@typed/fx 1.18.4 → 1.20.0

package/src/Versioned.ts

@@ -1,147 +1,162 @@
 /**
- * This module provides a data type which is both an Fx and an Effect. This is a more advanced types, and is the basis
- * for creating Computed + Filtered types from a RefSubject which is the canonical implementation of
- * an at type which is both Fx + Effect.
- * @since 1.18.0
+ * Versioned is a special Fx which is also an Effect, and keeps track of a version number of the
+ * current value it holds. The Fx portion is used to subscribe to changes, the Effect portion to
+ * sample the current value. The version can be utilized to avoid computing work related to this value.
+ * @since 1.0.0
  */
 
-import type { Context, Layer, Runtime } from "effect"
-import { Effect, identity } from "effect"
-import { dual } from "effect/Function"
+import type * as Context from "@typed/context"
+import type { Layer, Runtime, Scope } from "effect"
+import * as Effect from "effect/Effect"
+import { dual, flow } from "effect/Function"
 import { sum } from "effect/Number"
-import type * as Fx from "./Fx.js"
+import * as Option from "effect/Option"
+import type { Fx } from "./Fx.js"
 import * as core from "./internal/core.js"
-import * as fxEffectProto from "./internal/fx-effect-proto.js"
-import { VersionedTransform } from "./internal/versioned-transform.js"
+import { MulticastEffect } from "./internal/helpers.js"
+import { FxEffectBase } from "./internal/protos.js"
+import * as coreShare from "./internal/share.js"
+import type { Sink } from "./Sink.js"
+
+// TODO: dualize
+// TODO: context abstraction
+// TODO: More operators
 
 /**
- * A data type which is both an Fx and an Effect. This is a more advanced type, and is the basis
- * for creating Computed + Filtered types from a RefSubject which is the canonical implementation of
- * an at type which is both an Fx and an Effect.
- *
- * The Fx portion naturally has representations for dealing with keeping things up-to-date and
- * avoiding doing any work that is not necessary. The Effect, or "pull", portion utilizes the
- * version to determine if the current value is up to date. If it is not, then the Fx portion
- * will be run to update the value. This allows for derived types to cache values locally and
- * avoid doing any work if the value is up to date.
- * @since 1.18.0
- * @category models
+ * @since 1.0.0
  */
-export interface Versioned<R0, E0, R, E, A, R2, E2, B> extends Fx.Fx<R, E, A>, Effect.Effect<R2, E2, B> {
-  /**
-   * The current version of this FxEffect. This is used to determine if the current value
-   * is up to date to allow localized caching of value.
-   */
-  readonly version: Effect.Effect<R0, E0, number>
+export interface Versioned<R1, E1, R2, E2, A2, R3, E3, A3> extends Fx<R2, E2, A2>, Effect.Effect<R3, E3, A3> {
+  readonly version: Effect.Effect<R1, E1, number>
 }
 
 /**
- * @since 1.18.0
+ * @since 1.0.0
  */
 export namespace Versioned {
   /**
-   * @since 1.18.0
+   * @category models
+   * @since 1.0.0
+   */
+  export type Unify<T> = T extends
+    Versioned<infer R1, infer E1, infer R2, infer E2, infer A2, infer R3, infer E3, infer A3> | infer _
+    ? Versioned<R1, E1, R2, E2, A2, R3, E3, A3>
+    : never
+
+  /**
+   * @since 1.0.0
    */
-  export type VersionContext<T> = T extends
-    Versioned<infer R0, infer _E0, infer _R, infer _E, infer _A, infer _R2, infer _E2, infer _B> ? R0 : never
+  export type VersionContext<T> = T extends Versioned<infer R, any, any, any, any, any, any, any> ? R : never
 
   /**
-   * @since 1.18.0
+   * @since 1.0.0
    */
-  export type VersionError<T> = T extends
-    Versioned<infer _R0, infer E0, infer _R, infer _E, infer _A, infer _R2, infer _E2, infer _B> ? E0 : never
+  export type VersionError<T> = T extends Versioned<any, infer E, any, any, any, any, any, any> ? E : never
 }
 
 /**
- * Construct a Versioned type.
- * @since 1.18.0
- * @category constructors
+ * @since 1.0.0
  */
-export const make: <R0, E0, R, E, A, R2, E2, B>(
-  { effect, fx, version }: {
-    version: Effect.Effect<R0, E0, number>
-    fx: Fx.Fx<R, E, A>
-    effect: Effect.Effect<R2, E2, B>
+export function make<R1, E1, R2, E2, A2, R3, E3, A3>(
+  version: Effect.Effect<R1, E1, number>,
+  fx: Fx<R2, E2, A2>,
+  effect: Effect.Effect<R3, E3, A3>
+): Versioned<R1, E1, R2, E2, A2, R3, E3, A3> {
+  return new VersionedImpl(version, fx, effect)
+}
+
+class VersionedImpl<R1, E1, R2, E2, A2, R3, E3, A3> extends FxEffectBase<R2, E2, A2, R3, E3, A3>
+  implements Versioned<R1, E1, R2, E2, A2, R3, E3, A3>
+{
+  constructor(
+    readonly version: Effect.Effect<R1, E1, number>,
+    readonly fx: Fx<R2, E2, A2>,
+    readonly effect: Effect.Effect<R3, E3, A3>
+  ) {
+    super()
   }
-) => Versioned<R0, E0, R, E, A, R2, E2, B> = fxEffectProto.makeVersioned
 
-/**
- * Construct a Versioned type from a static value.
- * @since 1.18.0
- * @category constructors
- */
-export const of: <A>(value: A) => Versioned<never, never, never, never, A, never, never, A> = fxEffectProto.versionedOf
+  run<R3>(sink: Sink<R3, E2, A2>): Effect.Effect<R2 | R3, never, unknown> {
+    return this.fx.run(sink)
+  }
+
+  toEffect(): Effect.Effect<R3, E3, A3> {
+    return this.effect
+  }
+}
 
 /**
- * Transform a Versioned as an Fx and as an Effect separately.
- * @since 1.18.0
- * @category combinators
+ * @since 1.0.0
  */
-export const transform: {
-  <R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
-    transformFx: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>,
-    transformGet: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>
-  ): <R0, E0>(
-    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
-  ) => Versioned<never, never, R3, E3, C, R0 | R4, E0 | E4, D>
-  <R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
-    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-    transformFx: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>,
-    transformGet: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>
-  ): Versioned<never, never, R3, E3, C, R0 | R4, E0 | E4, D>
-} = dual(3, function transform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
-  versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-  transformFx: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>,
+export function transform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
+  input: Versioned<R0, E0, R, E, A, R2, E2, B>,
+  transformFx: (fx: Fx<R, E, A>) => Fx<R3, E3, C>,
   transformGet: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>
 ): Versioned<never, never, R3, E3, C, R0 | R4, E0 | E4, D> {
-  return new VersionedTransform(versioned, transformFx, transformGet)
-})
+  if (isVersionedTransform(input)) {
+    return new VersionedTransform(
+      input.input,
+      flow(input._transformFx, transformFx),
+      flow(input._transformEffect, transformGet)
+    )
+  } else {
+    return new VersionedTransform(input, transformFx, transformGet)
+  }
+}
 
 /**
- * Transform a Versioned as an Fx separately from its Effect interface.
- * @since 1.18.0
- * @category combinators
+ * @internal
  */
-export const transformFx: {
-  <R, E, A, R3, E3, C>(
-    f: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>
-  ): <R0, E0, R2, E2, B>(
-    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
-  ) => Versioned<never, never, R3, E3, C, R0 | R2, E0 | E2, B>
+export class VersionedTransform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>
+  extends FxEffectBase<R3, E3, C, R0 | R4, E0 | E4, D>
+  implements Versioned<never, never, R3, E3, C, R0 | R4, E0 | E4, D>
+{
+  protected _version = -1
+  protected _currentValue: Option.Option<D> = Option.none()
+  private _fx: Fx<R3, E3, C>
 
-  <R0, E0, R, E, A, R2, E2, B, R3, E3, C>(
-    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-    f: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>
-  ): Versioned<never, never, R3, E3, C, R0 | R2, E0 | E2, B>
-} = dual(2, function transformFx<R0, E0, R, E, A, R2, E2, B, R3, E3, C>(
-  versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-  f: (fx: Fx.Fx<R, E, A>) => Fx.Fx<R3, E3, C>
-): Versioned<never, never, R3, E3, C, R0 | R2, E0 | E2, B> {
-  return transform(versioned, f, identity)
-})
+  constructor(
+    readonly input: Versioned<R0, E0, R, E, A, R2, E2, B>,
+    readonly _transformFx: (fx: Fx<R, E, A>) => Fx<R3, E3, C>,
+    readonly _transformEffect: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>
+  ) {
+    super()
 
-/**
- * Transform a Versioned as an Effect separately from its Fx interface.
- * @since 1.18.0
- * @category combinators
- */
-export const transformEffect: {
-  <R2, E2, B, R3, E3, C>(
-    f: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R3, E3, C>
-  ): <R0, E0, R, E, A>(
-    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
-  ) => Versioned<never, never, R, E, A, R0 | R3, E0 | E3, C>
+    this._fx = _transformFx(this.input)
+  }
 
-  <R0, E0, R, E, A, R2, E2, B, R3, E3, C>(
-    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-    f: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R3, E3, C>
-  ): Versioned<never, never, R, E, A, R0 | R3, E0 | E3, C>
-} = dual(2, function transformEffect<R0, E0, R, E, A, R2, E2, B, R3, E3, C>(
-  versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-  f: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R3, E3, C>
-): Versioned<never, never, R, E, A, R0 | R3, E0 | E3, C> {
-  return transform(versioned, identity, f)
-})
+  readonly version = Effect.sync(() => this._version)
+
+  run<R5>(sink: Sink<R5, E3, C>): Effect.Effect<R3 | R5, never, unknown> {
+    return this._fx.run(sink)
+  }
+
+  toEffect(): Effect.Effect<R0 | R4, E0 | E4, D> {
+    const transformed = this._transformEffect(this.input as any as Effect.Effect<R2, E2, B>)
+    const update = (v: number) =>
+      Effect.tap(
+        transformed,
+        (value) =>
+          Effect.sync(() => {
+            this._currentValue = Option.some(value)
+            this._version = v
+          })
+      )
+
+    return new MulticastEffect(Effect.flatMap(this.input.version, (version) => {
+      if (version === this._version && Option.isSome(this._currentValue)) {
+        return Effect.succeed(this._currentValue.value)
+      }
+
+      return update(version)
+    }))
+  }
+}
+
+function isVersionedTransform(
+  u: unknown
+): u is VersionedTransform<any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+  return u instanceof VersionedTransform
+}
 
 /**
  * Transform a Versioned's output value as both an Fx and Effect.
@@ -172,7 +187,7 @@ export const map: {
     onEffect: (b: B) => D
   }
 ): Versioned<never, never, R, E, C, R0 | R2, E0 | E2, D> {
-  return transform(versioned, core.map(options.onFx), Effect.map(options.onEffect))
+  return transform(versioned, (fx) => core.map(fx, options.onFx), Effect.map(options.onEffect))
 })
 
 /**
@@ -198,29 +213,29 @@ export const mapEffect: {
     onEffect: (b: B) => Effect.Effect<R4, E4, D>
   }
 ): Versioned<never, never, R | R3, E | E3, C, R0 | R2 | R4, E0 | E2 | E4, D> {
-  return transform(versioned, core.mapEffect(options.onFx), Effect.flatMap(options.onEffect))
+  return transform(versioned, (fx) => core.mapEffect(fx, options.onFx), Effect.flatMap(options.onEffect))
 })
 
 /**
  * @since 1.0.0
  */
-export function combine<const VS extends ReadonlyArray<Versioned<any, any, any, any, any, any, any, any>>>(
+export function tuple<const VS extends ReadonlyArray<Versioned<any, any, any, any, any, any, any, any>>>(
   versioneds: VS
 ): Versioned<
   Versioned.VersionContext<VS[number]>,
   Versioned.VersionError<VS[number]>,
-  Fx.Fx.Context<VS[number]>,
-  Fx.Fx.Error<VS[number]>,
-  { readonly [K in keyof VS]: Fx.Fx.Success<VS[K]> },
+  Fx.Context<VS[number]>,
+  Fx.Error<VS[number]>,
+  { readonly [K in keyof VS]: Fx.Success<VS[K]> },
   Effect.Effect.Context<VS[number]>,
   Effect.Effect.Error<VS[number]>,
   { readonly [K in keyof VS]: Effect.Effect.Success<VS[K]> }
 > {
-  return make({
-    fx: core.combine(versioneds),
-    effect: Effect.all(versioneds, { concurrency: "unbounded" }) as any,
-    version: Effect.map(Effect.all(versioneds.map((v) => v.version)), (versions) => versions.reduce(sum, 0))
-  })
+  return make(
+    Effect.map(Effect.all(versioneds.map((v) => v.version)), (versions) => versions.reduce(sum, 0)),
+    core.tuple(versioneds),
+    Effect.all(versioneds, { concurrency: "unbounded" }) as any
+  )
 }
 
 /**
@@ -231,17 +246,20 @@ export function struct<const VS extends Readonly<Record<string, Versioned<any, a
 ): Versioned<
   Versioned.VersionContext<VS[keyof VS]>,
   Versioned.VersionError<VS[keyof VS]>,
-  Fx.Fx.Context<VS[keyof VS]>,
-  Fx.Fx.Error<VS[keyof VS]>,
-  { readonly [K in keyof VS]: Fx.Fx.Success<VS[K]> },
+  Fx.Context<VS[keyof VS]>,
+  Fx.Error<VS[keyof VS]>,
+  { readonly [K in keyof VS]: Fx.Success<VS[K]> },
   Effect.Effect.Context<VS[keyof VS]>,
   Effect.Effect.Error<VS[keyof VS]>,
   { readonly [K in keyof VS]: Effect.Effect.Success<VS[K]> }
 > {
   return map(
-    combine(
+    tuple(
       Object.entries(versioneds).map(([k, v]) =>
-        map(v, { onFx: (x) => [k, x] as const, onEffect: (x) => [k, x] as const })
+        map(v, {
+          onFx: (x) => [k, x] as const,
+          onEffect: (x) => [k, x] as const
+        })
       )
     ),
     {
@@ -255,48 +273,82 @@ export function struct<const VS extends Readonly<Record<string, Versioned<any, a
  * @since 1.0.0
  */
 export const provide: {
-  <R3, E3, C3>(
-    layer: Layer.Layer<R3, E3, C3>
-  ): <R0, E0, R1, E1, A1, R2, E2, B2>(
-    versioned: Versioned<R0, E0, R1, E1, A1, R2, E2, B2>
-  ) => Versioned<never, never, R3 | Exclude<R1, C3>, E1 | E3, A1, R3 | Exclude<R0 | R2, C3>, E0 | E2 | E3, B2>
-  <C3>(
-    runtime: Runtime.Runtime<C3>
-  ): <R0, E0, R1, E1, A1, R2, E2, B2>(
-    versioned: Versioned<R0, E0, R1, E1, A1, R2, E2, B2>
-  ) => Versioned<never, never, Exclude<R1, C3>, E1, A1, Exclude<R0 | R2, C3>, E0 | E2, B2>
-
-  <C3>(
-    context: Context.Context<C3>
-  ): <R0, E0, R1, E1, A1, R2, E2, B2>(
-    versioned: Versioned<R0, E0, R1, E1, A1, R2, E2, B2>
-  ) => Versioned<never, never, Exclude<R1, C3>, E1, A1, Exclude<R0 | R2, C3>, E0 | E2, B2>
-
-  <R0, E0, R1, E1, A1, R2, E2, B2, R3, E3, C3>(
-    versioned: Versioned<R0, E0, R1, E1, A1, R2, E2, B2>,
-    layer: Layer.Layer<R3, E3, C3>
-  ): Versioned<never, never, R3 | Exclude<R1, C3>, E1 | E3, A1, R3 | Exclude<R0 | R2, C3>, E0 | E2 | E3, B2>
-
-  <R0, E0, R1, E1, A1, R2, E2, B2, C3>(
-    versioned: Versioned<R0, E0, R1, E1, A1, R2, E2, B2>,
-    runtime: Runtime.Runtime<C3>
-  ): Versioned<never, never, Exclude<R1, C3>, E1, A1, Exclude<R0 | R2, C3>, E0 | E2, B2>
-
-  <R0, E0, R1, E1, A1, R2, E2, B2, C3>(
-    versioned: Versioned<R0, E0, R1, E1, A1, R2, E2, B2>,
-    context: Context.Context<C3>
-  ): Versioned<never, never, Exclude<R1, C3>, E1, A1, Exclude<R0 | R2, C3>, E0 | E2, B2>
-} = dual(2, function provide<R0, E0, R1, E1, A1, R2, E2, B2, R3, E3, C3>(
-  versioned: Versioned<R0, E0, R1, E1, A1, R2, E2, B2>,
-  layer: Layer.Layer<R3, E3, C3>
-): Versioned<never, never, R3 | Exclude<R1, C3>, E1 | E3, A1, R3 | Exclude<R0 | R2, C3>, E0 | E2 | E3, B2> {
-  return transform(
-    make({
-      effect: versioned,
-      fx: versioned,
-      version: Effect.provide(versioned.version, layer)
-    }),
-    core.provide(layer),
-    Effect.provide(layer)
+  <S>(ctx: Context.Context<S> | Runtime.Runtime<S>): <R0, E0, R, E, A, R2, E2, B>(
+    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
+  ) => Versioned<Exclude<R0, S>, E0, Exclude<R, S>, E, A, Exclude<R2, S>, E2, B>
+
+  <R3, S>(layer: Layer.Layer<R3, never, S>): <R0, E0, R, E, A, R2, E2, B>(
+    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
+  ) => Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B>
+
+  <R0, E0, R, E, A, R2, E2, B, S>(
+    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
+    context: Context.Context<S> | Runtime.Runtime<S>
+  ): Versioned<Exclude<R0, S>, E0, Exclude<R, S>, E, A, Exclude<R2, S>, E2, B>
+
+  <R0, E0, R, E, A, R2, E2, B, R3 = never, S = never>(
+    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
+    context: Layer.Layer<R3, never, S>
+  ): Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B>
+
+  <R0, E0, R, E, A, R2, E2, B, R3 = never, S = never>(
+    versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
+    context: Context.Context<S> | Runtime.Runtime<S> | Layer.Layer<R3, never, S>
+  ): Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B>
+} = dual(2, function provide<R0, E0, R, E, A, R2, E2, B, R3 = never, S = never>(
+  versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
+  context: Context.Context<S> | Runtime.Runtime<S> | Layer.Layer<R3, never, S>
+): Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B> {
+  return make(
+    Effect.provide(versioned.version, context as Layer.Layer<R3, never, S>),
+    core.provide(versioned, context),
+    Effect.provide(versioned, context as Layer.Layer<R3, never, S>)
   )
 })
+
+/**
+ * @since 1.0.0
+ */
+export function of<A>(value: A): Versioned<never, never, never, never, A, never, never, A> {
+  return make(Effect.succeed(1), core.succeed(value), Effect.succeed(value))
+}
+
+/**
+ * @since 1.0.0
+ */
+export function hold<R0, E0, R, E, A, R2, E2, B>(
+  versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
+): Versioned<R0, E0, R | Scope.Scope, E, A, R2, E2, B> {
+  return make(
+    versioned.version,
+    coreShare.hold(versioned),
+    versioned
+  )
+}
+
+/**
+ * @since 1.0.0
+ */
+export function multicast<R0, E0, R, E, A, R2, E2, B>(
+  versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
+): Versioned<R0, E0, R | Scope.Scope, E, A, R2, E2, B> {
+  return make(
+    versioned.version,
+    coreShare.multicast(versioned),
+    versioned
+  )
+}
+
+/**
+ * @since 1.0.0
+ */
+export function replay<R0, E0, R, E, A, R2, E2, B>(
+  versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
+  bufferSize: number
+): Versioned<R0, E0, R | Scope.Scope, E, A, R2, E2, B> {
+  return make(
+    versioned.version,
+    coreShare.replay(versioned, bufferSize),
+    versioned
+  )
+}

package/src/index.ts

@@ -10,22 +10,64 @@
  */
 
 /**
- * [Computed documentation](https://tylors.github.io/typed/fx/Computed.ts.html)
+ * [Fx documentation](https://tylors.github.io/typed/fx/Fx.ts.html)
  * @since 1.18.0
  */
-export * as Computed from "./Computed.js"
+export * from "./Fx.js"
 
 /**
- * [Filtered documentation](https://tylors.github.io/typed/fx/Filtered.ts.html)
+ * [AsyncData documentation](https://tylors.github.io/typed/fx/AsyncData.ts.html)
  * @since 1.18.0
  */
-export * as Filtered from "./Filtered.js"
+export * as AsyncData from "./AsyncData.js"
 
 /**
- * [Fx documentation](https://tylors.github.io/typed/fx/Fx.ts.html)
+ * [Emitter documentation](https://tylors.github.io/typed/fx/Emitter.ts.html)
  * @since 1.18.0
  */
-export * from "./Fx.js"
+export * as Emitter from "./Emitter.js"
+
+/**
+ * [Form documentation](https://tylors.github.io/typed/fx/Form.ts.html)
+ * @since 1.18.0
+ */
+export * as Form from "./Form.js"
+
+/**
+ * [FormEntry documentation](https://tylors.github.io/typed/fx/FormEntry.ts.html)
+ * @since 1.18.0
+ */
+export * as FormEntry from "./FormEntry.js"
+
+/**
+ * [Guard documentation](https://tylors.github.io/typed/fx/Guard.ts.html)
+ * @since 1.18.0
+ */
+export * as Guard from "./Guard.js"
+
+/**
+ * [Idle documentation](https://tylors.github.io/typed/fx/Idle.ts.html)
+ * @since 1.18.0
+ */
+export * as Idle from "./Idle.js"
+
+/**
+ * [Match documentation](https://tylors.github.io/typed/fx/Match.ts.html)
+ * @since 1.18.0
+ */
+export * as Match from "./Match.js"
+
+/**
+ * [Pull documentation](https://tylors.github.io/typed/fx/Pull.ts.html)
+ * @since 1.18.0
+ */
+export * as Pull from "./Pull.js"
+
+/**
+ * [Push documentation](https://tylors.github.io/typed/fx/Push.ts.html)
+ * @since 1.18.0
+ */
+export * as Push from "./Push.js"
 
 /**
  * [RefArray documentation](https://tylors.github.io/typed/fx/RefArray.ts.html)
@@ -33,6 +75,24 @@ export * from "./Fx.js"
  */
 export * as RefArray from "./RefArray.js"
 
+/**
+ * [RefChunk documentation](https://tylors.github.io/typed/fx/RefChunk.ts.html)
+ * @since 1.18.0
+ */
+export * as RefChunk from "./RefChunk.js"
+
+/**
+ * [RefHashMap documentation](https://tylors.github.io/typed/fx/RefHashMap.ts.html)
+ * @since 1.18.0
+ */
+export * as RefHashMap from "./RefHashMap.js"
+
+/**
+ * [RefHashSet documentation](https://tylors.github.io/typed/fx/RefHashSet.ts.html)
+ * @since 1.18.0
+ */
+export * as RefHashSet from "./RefHashSet.js"
+
 /**
  * [RefSubject documentation](https://tylors.github.io/typed/fx/RefSubject.ts.html)
  * @since 1.18.0
@@ -45,6 +105,12 @@ export * as RefSubject from "./RefSubject.js"
  */
 export * as Sink from "./Sink.js"
 
+/**
+ * [Stream documentation](https://tylors.github.io/typed/fx/Stream.ts.html)
+ * @since 1.18.0
+ */
+export * as Stream from "./Stream.js"
+
 /**
  * [Subject documentation](https://tylors.github.io/typed/fx/Subject.ts.html)
  * @since 1.18.0
@@ -62,3 +128,9 @@ export * as Typeclass from "./Typeclass.js"
  * @since 1.18.0
  */
 export * from "./TypeId.js"
+
+/**
+ * [Versioned documentation](https://tylors.github.io/typed/fx/Versioned.ts.html)
+ * @since 1.18.0
+ */
+export * as Versioned from "./Versioned.js"

package/src/internal/DeferredRef.ts

@@ -0,0 +1,62 @@
+import type { Equivalence, FiberId } from "effect"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Option from "effect/Option"
+import { EffectBase } from "./protos.js"
+
+export class DeferredRef<E, A> extends EffectBase<never, E, A> {
+  // Keep track of the latest value emitted by the stream
+  public current!: Option.Option<Exit.Exit<E, A>>
+  public version!: number
+  public deferred!: Deferred.Deferred<E, A>
+
+  constructor(private id: FiberId.FiberId, private eq: Equivalence.Equivalence<Exit.Exit<E, A>>) {
+    super()
+    this.reset()
+  }
+
+  toEffect() {
+    return Effect.suspend(() => {
+      if (Option.isNone(this.current)) {
+        return Deferred.await(this.deferred)
+      } else {
+        return this.current.value
+      }
+    })
+  }
+
+  done(exit: Exit.Exit<E, A>) {
+    const current = this.current
+
+    this.current = Option.some(exit)
+
+    if (Option.isSome(current) && this.eq(current.value, exit)) {
+      return false
+    }
+
+    Deferred.unsafeDone(this.deferred, exit)
+    this.version += 1
+
+    return true
+  }
+
+  reset() {
+    this.current = Option.none()
+    this.version = 0
+
+    if (this.deferred) {
+      Deferred.unsafeDone(this.deferred, Exit.interrupt(this.id))
+    }
+
+    this.deferred = Deferred.unsafeMake(this.id)
+  }
+}
+
+export function make<E, A>(eq: Equivalence.Equivalence<Exit.Exit<E, A>>) {
+  return Effect.map(Effect.fiberId, (id) => new DeferredRef(id, eq))
+}
+
+export function unsafeMake<E, A>(id: FiberId.FiberId, eq: Equivalence.Equivalence<Exit.Exit<E, A>>) {
+  return new DeferredRef(id, eq)
+}

package/src/internal/UnionToTuple.ts

@@ -0,0 +1,11 @@
+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