@typed/fx 1.31.0 → 2.0.0-beta.0

package/src/RefSubject/RefTrie.ts

@@ -0,0 +1,356 @@
+/**
+ * Extensions to RefSubject for working with Trie values
+ * @since 1.18.0
+ */
+
+import type * as Effect from "effect/Effect";
+import { equals } from "effect/Equal";
+import { dual } from "effect/Function";
+import type * as Option from "effect/Option";
+import type * as Scope from "effect/Scope";
+import * as Trie from "effect/Trie";
+import type * as Fx from "../Fx/index.js";
+import * as RefSubject from "./RefSubject.js";
+
+/**
+ * A RefTrie is a RefSubject specialized over a Trie.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefTrie<in out V, in out E = never, out R = never> extends RefSubject.RefSubject<
+  Trie.Trie<V>,
+  E,
+  R
+> {}
+
+/**
+ * Creates a new `RefTrie` from a Trie, `Effect`, or `Fx`.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<V, E, R>(
+  initial: Trie.Trie<V> | Effect.Effect<Trie.Trie<V>, E, R> | Fx.Fx<Trie.Trie<V>, E, R>,
+): Effect.Effect<RefTrie<V, E>, never, R | Scope.Scope> {
+  return RefSubject.make(initial, { eq: equals });
+}
+
+// ========================================
+// Combinators
+// ========================================
+
+/**
+ * Insert a key-value pair into the Trie.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const insert: {
+  <V>(key: string, value: V): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, key: string, value: V): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(3, function insert<V, E, R>(ref: RefTrie<V, E, R>, key: string, value: V) {
+  return RefSubject.update(ref, Trie.insert(key, value));
+});
+
+/**
+ * Insert multiple key-value pairs into the Trie.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const insertMany: {
+  <V>(
+    entries: Iterable<[string, V]>,
+  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(
+    ref: RefTrie<V, E, R>,
+    entries: Iterable<[string, V]>,
+  ): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(2, function insertMany<V, E, R>(ref: RefTrie<V, E, R>, entries: Iterable<[string, V]>) {
+  return RefSubject.update(ref, Trie.insertMany(entries));
+});
+
+/**
+ * Remove a key from the Trie.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const remove: {
+  (key: string): <V, E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, key: string): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(2, function remove<V, E, R>(ref: RefTrie<V, E, R>, key: string) {
+  return RefSubject.update(ref, Trie.remove(key));
+});
+
+/**
+ * Remove multiple keys from the Trie.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const removeMany: {
+  (keys: Iterable<string>): <V, E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, keys: Iterable<string>): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(2, function removeMany<V, E, R>(ref: RefTrie<V, E, R>, keys: Iterable<string>) {
+  return RefSubject.update(ref, Trie.removeMany(keys));
+});
+
+/**
+ * Modify the value at a key if it exists.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const modify: {
+  <V>(
+    key: string,
+    f: (v: V) => V,
+  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, key: string, f: (v: V) => V): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(3, function modify<V, E, R>(ref: RefTrie<V, E, R>, key: string, f: (v: V) => V) {
+  return RefSubject.update(ref, Trie.modify(key, f));
+});
+
+/**
+ * Clear all entries from the Trie.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const clear = <V, E, R>(ref: RefTrie<V, E, R>): Effect.Effect<Trie.Trie<V>, E, R> =>
+  RefSubject.update(ref, () => Trie.empty());
+
+/**
+ * Map values in place (endomorphic).
+ * @since 1.18.0
+ * @category combinators
+ */
+export const map: {
+  <V>(
+    f: (value: V, key: string) => V,
+  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(
+    ref: RefTrie<V, E, R>,
+    f: (value: V, key: string) => V,
+  ): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(2, function map<V, E, R>(ref: RefTrie<V, E, R>, f: (value: V, key: string) => V) {
+  return RefSubject.update(ref, Trie.map(f));
+});
+
+/**
+ * Filter entries in place.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filter: {
+  <V>(
+    predicate: (value: V, key: string) => boolean,
+  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(
+    ref: RefTrie<V, E, R>,
+    predicate: (value: V, key: string) => boolean,
+  ): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(2, function filter<
+  V,
+  E,
+  R,
+>(ref: RefTrie<V, E, R>, predicate: (value: V, key: string) => boolean) {
+  return RefSubject.update(ref, Trie.filter(predicate));
+});
+
+/**
+ * Filter and map entries in place.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filterMap: {
+  <V>(
+    f: (value: V, key: string) => Option.Option<V>,
+  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  <V, E, R>(
+    ref: RefTrie<V, E, R>,
+    f: (value: V, key: string) => Option.Option<V>,
+  ): Effect.Effect<Trie.Trie<V>, E, R>;
+} = dual(2, function filterMap<
+  V,
+  E,
+  R,
+>(ref: RefTrie<V, E, R>, f: (value: V, key: string) => Option.Option<V>) {
+  return RefSubject.update(ref, Trie.filterMap(f));
+});
+
+// ========================================
+// Computed
+// ========================================
+
+/**
+ * Compact Option values.
+ * @since 1.18.0
+ * @category computed
+ */
+export const compact = <V, E, R>(ref: RefTrie<Option.Option<V>, E, R>) =>
+  RefSubject.map(ref, Trie.compact);
+
+/**
+ * Get the current size of the Trie.
+ * @since 1.18.0
+ * @category computed
+ */
+export const size = <V, E, R>(ref: RefTrie<V, E, R>): RefSubject.Computed<number, E, R> =>
+  RefSubject.map(ref, Trie.size);
+
+/**
+ * Check if the Trie is empty.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isEmpty = <V, E, R>(ref: RefTrie<V, E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, Trie.isEmpty);
+
+/**
+ * Check if the Trie is non-empty.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isNonEmpty = <V, E, R>(ref: RefTrie<V, E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, (t) => !Trie.isEmpty(t));
+
+/**
+ * Check if a key exists in the Trie.
+ * @since 1.18.0
+ * @category computed
+ */
+export const has: {
+  (key: string): <V, E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<boolean, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, key: string): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function has<V, E, R>(ref: RefTrie<V, E, R>, key: string) {
+  return RefSubject.map(ref, Trie.has(key));
+});
+
+/**
+ * Get all keys from the Trie.
+ * @since 1.18.0
+ * @category computed
+ */
+export const keys = <V, E, R>(ref: RefTrie<V, E, R>): RefSubject.Computed<Array<string>, E, R> =>
+  RefSubject.map(ref, (t) => Array.from(Trie.keys(t)));
+
+/**
+ * Get all values from the Trie.
+ * @since 1.18.0
+ * @category computed
+ */
+export const values = <V, E, R>(ref: RefTrie<V, E, R>): RefSubject.Computed<Array<V>, E, R> =>
+  RefSubject.map(ref, (t) => Array.from(Trie.values(t)));
+
+/**
+ * Get all entries from the Trie.
+ * @since 1.18.0
+ * @category computed
+ */
+export const entries = <V, E, R>(
+  ref: RefTrie<V, E, R>,
+): RefSubject.Computed<Array<[string, V]>, E, R> => RefSubject.map(ref, Trie.toEntries);
+
+/**
+ * Get all keys with a given prefix.
+ * @since 1.18.0
+ * @category computed
+ */
+export const keysWithPrefix: {
+  (prefix: string): <V, E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Array<string>, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, prefix: string): RefSubject.Computed<Array<string>, E, R>;
+} = dual(2, function keysWithPrefix<V, E, R>(ref: RefTrie<V, E, R>, prefix: string) {
+  return RefSubject.map(ref, (t) => Array.from(Trie.keysWithPrefix(t, prefix)));
+});
+
+/**
+ * Get all values with a given prefix.
+ * @since 1.18.0
+ * @category computed
+ */
+export const valuesWithPrefix: {
+  (prefix: string): <V, E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Array<V>, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, prefix: string): RefSubject.Computed<Array<V>, E, R>;
+} = dual(2, function valuesWithPrefix<V, E, R>(ref: RefTrie<V, E, R>, prefix: string) {
+  return RefSubject.map(ref, (t) => Array.from(Trie.valuesWithPrefix(t, prefix)));
+});
+
+/**
+ * Get all entries with a given prefix.
+ * @since 1.18.0
+ * @category computed
+ */
+export const entriesWithPrefix: {
+  (
+    prefix: string,
+  ): <V, E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Array<[string, V]>, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, prefix: string): RefSubject.Computed<Array<[string, V]>, E, R>;
+} = dual(2, function entriesWithPrefix<V, E, R>(ref: RefTrie<V, E, R>, prefix: string) {
+  return RefSubject.map(ref, Trie.toEntriesWithPrefix(prefix));
+});
+
+/**
+ * Get the longest prefix of a key that exists in the Trie.
+ * @since 1.18.0
+ * @category computed
+ */
+export const longestPrefixOf: {
+  (
+    key: string,
+  ): <V, E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<[string, V] | undefined, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, key: string): RefSubject.Computed<[string, V] | undefined, E, R>;
+} = dual(2, function longestPrefixOf<V, E, R>(ref: RefTrie<V, E, R>, key: string) {
+  return RefSubject.map(ref, Trie.longestPrefixOf(key));
+});
+
+/**
+ * Map values to a different type.
+ * @since 1.18.0
+ * @category computed
+ */
+export const mapValues: {
+  <V, B>(
+    f: (value: V, key: string) => B,
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Trie.Trie<B>, E, R>;
+  <V, E, R, B>(
+    ref: RefTrie<V, E, R>,
+    f: (value: V, key: string) => B,
+  ): RefSubject.Computed<Trie.Trie<B>, E, R>;
+} = dual(2, function mapValues<V, E, R, B>(ref: RefTrie<V, E, R>, f: (value: V, key: string) => B) {
+  return RefSubject.map(ref, Trie.map(f));
+});
+
+/**
+ * Reduce the entries to a single value.
+ * @since 1.18.0
+ * @category computed
+ */
+export const reduce: {
+  <V, B>(
+    b: B,
+    f: (b: B, value: V, key: string) => B,
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<B, E, R>;
+  <V, E, R, B>(
+    ref: RefTrie<V, E, R>,
+    b: B,
+    f: (b: B, value: V, key: string) => B,
+  ): RefSubject.Computed<B, E, R>;
+} = dual(3, function reduce<
+  V,
+  E,
+  R,
+  B,
+>(ref: RefTrie<V, E, R>, b: B, f: (b: B, value: V, key: string) => B) {
+  return RefSubject.map(ref, Trie.reduce(b, f));
+});
+
+// ========================================
+// Filtered
+// ========================================
+
+/**
+ * Get the value at a key as a Filtered.
+ * @since 1.18.0
+ * @category filtered
+ */
+export const get: {
+  (key: string): <V, E, R>(ref: RefTrie<V, E, R>) => RefSubject.Filtered<V, E, R>;
+  <V, E, R>(ref: RefTrie<V, E, R>, key: string): RefSubject.Filtered<V, E, R>;
+} = dual(2, function get<V, E, R>(ref: RefTrie<V, E, R>, key: string) {
+  return RefSubject.filterMap(ref, Trie.get(key));
+});

package/src/RefSubject/RefTuple.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import * as Tuple from "effect/Tuple";
+import * as RefTuple from "./RefTuple.js";
+
+describe("RefTuple", () => {
+  it("creates and gets value", () =>
+    Effect.gen(function* () {
+      const value = Tuple.make(1, "hello", true);
+      const ref = yield* RefTuple.make(value);
+      const current = yield* ref;
+      expect(current).toEqual(value);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sets value at index", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefTuple.make(Tuple.make(1, "hello", true));
+      yield* RefTuple.setAt(ref, 1, "world");
+      const result = yield* ref;
+      expect(result[1]).toBe("world");
+      expect(result[0]).toBe(1);
+      expect(result[2]).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("updates value at index", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefTuple.make(Tuple.make(1, 2, 3));
+      yield* RefTuple.updateAt(ref, 1, (n) => n * 2);
+      const result = yield* ref;
+      expect(result[1]).toBe(4);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("appends element", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefTuple.make(Tuple.make(1, 2));
+      const result = yield* RefTuple.appendElement(ref, 3);
+      expect(result).toEqual([1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("prepends element", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefTuple.make(Tuple.make(2, 3));
+      const result = yield* RefTuple.prependElement(ref, 1);
+      expect(result).toEqual([1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("gets element at index", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefTuple.make(Tuple.make(1, "hello", true));
+      const value = yield* RefTuple.get(ref, 1);
+      expect(value).toBe("hello");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("gets length", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefTuple.make(Tuple.make(1, 2, 3));
+      const length = yield* RefTuple.length(ref);
+      expect(length).toBe(3);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/RefSubject/RefTuple.ts

@@ -0,0 +1,231 @@
+/**
+ * Extensions to RefSubject for working with tuple values
+ * @since 1.18.0
+ */
+
+import type * as Effect from "effect/Effect";
+import { equals } from "effect/Equal";
+import * as Equivalence_ from "effect/Equivalence";
+import type { Equivalence } from "effect/Equivalence";
+import { dual } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import * as Tuple from "effect/Tuple";
+import type * as Fx from "../Fx/index.js";
+import * as RefSubject from "./RefSubject.js";
+
+/**
+ * A RefTuple is a RefSubject specialized over a tuple value.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefTuple<
+  in out T extends ReadonlyArray<unknown>,
+  in out E = never,
+  out R = never,
+> extends RefSubject.RefSubject<T, E, R> {}
+
+/**
+ * Creates a new `RefTuple` from a tuple, `Effect`, or `Fx`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Tuple } from "effect"
+ * import * as RefTuple from "effect/typed/fx/RefSubject/RefTuple"
+ *
+ * const program = Effect.gen(function* () {
+ *   const value = yield* RefTuple.make(Tuple.make(1, "hello", true))
+ *   const current = yield* value
+ *   console.log(current) // [1, "hello", true]
+ * })
+ * ```
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<T extends ReadonlyArray<unknown>, E = never, R = never>(
+  initial: T | Effect.Effect<T, E, R> | Fx.Fx<T, E, R>,
+  eq: Equivalence<T> = Equivalence_.make((a, b) => equals(a, b)),
+): Effect.Effect<RefTuple<T, E>, never, R | Scope.Scope> {
+  return RefSubject.make(initial, { eq });
+}
+
+/**
+ * Set the value at a specific index in the current state of a RefTuple.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const setAt: {
+  <T extends ReadonlyArray<unknown>, I extends number>(
+    index: I,
+    value: T[I],
+  ): <E, R>(ref: RefTuple<T, E, R>) => Effect.Effect<T, E, R>;
+  <T extends ReadonlyArray<unknown>, I extends number, E, R>(
+    ref: RefTuple<T, E, R>,
+    index: I,
+    value: T[I],
+  ): Effect.Effect<T, E, R>;
+} = dual(3, function setAt<
+  T extends ReadonlyArray<unknown>,
+  I extends number,
+  E,
+  R,
+>(ref: RefTuple<T, E, R>, index: I, value: T[I]) {
+  return RefSubject.update(ref, (self) => {
+    const result = [...self] as unknown as T;
+    result[index] = value;
+    return result;
+  });
+});
+
+/**
+ * Update the value at a specific index in the current state of a RefTuple using a function.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const updateAt: {
+  <T extends ReadonlyArray<unknown>, I extends number>(
+    index: I,
+    f: (value: T[I]) => T[I],
+  ): <E, R>(ref: RefTuple<T, E, R>) => Effect.Effect<T, E, R>;
+  <T extends ReadonlyArray<unknown>, I extends number, E, R>(
+    ref: RefTuple<T, E, R>,
+    index: I,
+    f: (value: T[I]) => T[I],
+  ): Effect.Effect<T, E, R>;
+} = dual(3, function updateAt<
+  T extends ReadonlyArray<unknown>,
+  I extends number,
+  E,
+  R,
+>(ref: RefTuple<T, E, R>, index: I, f: (value: T[I]) => T[I]) {
+  return RefSubject.update(ref, (self) => Tuple.evolve(self, { [index]: f } as any) as T);
+});
+
+// ========================================
+// Computed
+// ========================================
+
+/**
+ * Append an element to the end of the current state of a RefTuple.
+ * @since 1.18.0
+ * @category computed
+ */
+export const appendElement: {
+  <E>(
+    element: E,
+  ): <T extends ReadonlyArray<unknown>, Err, R>(
+    ref: RefTuple<T, Err, R>,
+  ) => RefSubject.Computed<[...T, E], Err, R>;
+  <T extends ReadonlyArray<unknown>, E, Err, R>(
+    ref: RefTuple<T, Err, R>,
+    element: E,
+  ): RefSubject.Computed<[...T, E], Err, R>;
+} = dual(2, function appendElement<
+  T extends ReadonlyArray<unknown>,
+  E,
+  Err,
+  R,
+>(ref: RefTuple<T, Err, R>, element: E) {
+  return RefSubject.map(ref, (self) => Tuple.appendElement(self, element));
+});
+
+/**
+ * Prepend an element to the beginning of the current state of a RefTuple.
+ * @since 1.18.0
+ * @category computed
+ */
+export const prependElement: {
+  <E>(
+    element: E,
+  ): <T extends ReadonlyArray<unknown>, Err, R>(
+    ref: RefTuple<T, Err, R>,
+  ) => RefSubject.Computed<[E, ...T], Err, R>;
+  <T extends ReadonlyArray<unknown>, E, Err, R>(
+    ref: RefTuple<T, Err, R>,
+    element: E,
+  ): RefSubject.Computed<[E, ...T], Err, R>;
+} = dual(2, function prependElement<
+  T extends ReadonlyArray<unknown>,
+  E,
+  Err,
+  R,
+>(ref: RefTuple<T, Err, R>, element: E) {
+  return RefSubject.map(ref, (self) => [element, ...self] as [E, ...T]);
+});
+
+/**
+ * Get the element at a specific index from the current state of a RefTuple.
+ * @since 1.18.0
+ * @category computed
+ */
+type Indices<T extends ReadonlyArray<unknown>> = Exclude<Partial<T>["length"], T["length"]>;
+
+export const get: {
+  <T extends ReadonlyArray<unknown>, I extends Indices<T> & keyof T>(
+    index: I,
+  ): <E, R>(ref: RefTuple<T, E, R>) => RefSubject.Computed<T[I], E, R>;
+  <T extends ReadonlyArray<unknown>, I extends Indices<T> & keyof T, E, R>(
+    ref: RefTuple<T, E, R>,
+    index: I,
+  ): RefSubject.Computed<T[I], E, R>;
+} = dual(2, function get<
+  T extends ReadonlyArray<unknown>,
+  I extends Indices<T> & keyof T,
+  E,
+  R,
+>(ref: RefTuple<T, E, R>, index: I) {
+  return RefSubject.map(ref, (self) => Tuple.get(self, index));
+});
+
+/**
+ * Get the length of the current state of a RefTuple.
+ * @since 1.18.0
+ * @category computed
+ */
+export const length = <T extends ReadonlyArray<unknown>, E, R>(
+  ref: RefTuple<T, E, R>,
+): RefSubject.Computed<number, E, R> => RefSubject.map(ref, (self) => self.length);
+
+/**
+ * Pick elements at specific indices from the current state of a RefTuple.
+ * @since 1.18.0
+ * @category computed
+ */
+export const pick: {
+  <T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(
+    indices: I,
+  ): <E, R>(ref: RefTuple<T, E, R>) => RefSubject.Computed<Array<T[number]>, E, R>;
+  <T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>, E, R>(
+    ref: RefTuple<T, E, R>,
+    indices: I,
+  ): RefSubject.Computed<Array<T[number]>, E, R>;
+} = dual(2, function pick<
+  T extends ReadonlyArray<unknown>,
+  const I extends ReadonlyArray<Indices<T>>,
+  E,
+  R,
+>(ref: RefTuple<T, E, R>, indices: I) {
+  return RefSubject.map(ref, (self) => Tuple.pick(self, indices));
+});
+
+/**
+ * Omit elements at specific indices from the current state of a RefTuple.
+ * @since 1.18.0
+ * @category computed
+ */
+export const omit: {
+  <T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(
+    indices: I,
+  ): <E, R>(ref: RefTuple<T, E, R>) => RefSubject.Computed<Array<T[number]>, E, R>;
+  <T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>, E, R>(
+    ref: RefTuple<T, E, R>,
+    indices: I,
+  ): RefSubject.Computed<Array<T[number]>, E, R>;
+} = dual(2, function omit<
+  T extends ReadonlyArray<unknown>,
+  const I extends ReadonlyArray<Indices<T>>,
+  E,
+  R,
+>(ref: RefTuple<T, E, R>, indices: I) {
+  return RefSubject.map(ref, (self) => Tuple.omit(self, indices));
+});

package/src/RefSubject/index.ts

@@ -0,0 +1,21 @@
+export * as RefArray from "./RefArray.js";
+export * as RefBigDecimal from "./RefBigDecimal.js";
+export * as RefBigInt from "./RefBigInt.js";
+export * as RefBoolean from "./RefBoolean.js";
+export * as RefCause from "./RefCause.js";
+export * as RefChunk from "./RefChunk.js";
+export * as RefDateTime from "./RefDateTime.js";
+export * as RefDuration from "./RefDuration.js";
+export * as RefGraph from "./RefGraph.js";
+export * as RefHashMap from "./RefHashMap.js";
+export * as RefHashRing from "./RefHashRing.js";
+export * as RefHashSet from "./RefHashSet.js";
+export * as RefIterable from "./RefIterable.js";
+export * as RefOption from "./RefOption.js";
+export * as RefRecord from "./RefRecord.js";
+export * as RefResult from "./RefResult.js";
+export * as RefString from "./RefString.js";
+export * as RefStruct from "./RefStruct.js";
+export * as RefSubject from "./RefSubject.js";
+export * as RefTrie from "./RefTrie.js";
+export * as RefTuple from "./RefTuple.js";