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

package/src/RefSubject/RefTrie.ts

@@ -1,356 +0,0 @@
-/**
- * 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

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

@@ -1,231 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-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";