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

package/src/RefSubject/RefHashRing.ts

@@ -1,262 +0,0 @@
-/**
- * Extensions to RefSubject for working with HashRing values
- * @since 1.18.0
- */
-
-import type * as Effect from "effect/Effect";
-import { equals } from "effect/Equal";
-import { dual } from "effect/Function";
-import * as HashRing from "effect/HashRing";
-import * as Option from "effect/Option";
-import type * as PrimaryKey from "effect/PrimaryKey";
-import type * as Scope from "effect/Scope";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-/**
- * A RefHashRing is a RefSubject specialized over a HashRing.
- * @since 1.18.0
- * @category models
- */
-export interface RefHashRing<
-  in out A extends PrimaryKey.PrimaryKey,
-  in out E = never,
-  out R = never,
-> extends RefSubject.RefSubject<HashRing.HashRing<A>, E, R> {}
-
-/**
- * Creates a new `RefHashRing` from a HashRing, `Effect`, or `Fx`.
- * @since 1.18.0
- * @category constructors
- */
-export function make<A extends PrimaryKey.PrimaryKey, E, R>(
-  initial:
-    | HashRing.HashRing<A>
-    | Effect.Effect<HashRing.HashRing<A>, E, R>
-    | Fx.Fx<HashRing.HashRing<A>, E, R>,
-): Effect.Effect<RefHashRing<A, E>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq: equals });
-}
-
-/**
- * Creates a new empty RefHashRing.
- * @since 1.18.0
- * @category constructors
- */
-export function empty<A extends PrimaryKey.PrimaryKey, E, R>(options?: {
-  readonly baseWeight?: number;
-}): Effect.Effect<RefHashRing<A, E>, never, R | Scope.Scope> {
-  return RefSubject.make(HashRing.make<A>(options), { eq: equals });
-}
-
-// Helper to copy a HashRing before mutation
-function copyRing<A extends PrimaryKey.PrimaryKey>(
-  ring: HashRing.HashRing<A>,
-): HashRing.HashRing<A> {
-  const newRing = HashRing.make<A>({ baseWeight: ring.baseWeight });
-  return HashRing.addMany(newRing, ring);
-}
-
-// ========================================
-// Combinators
-// ========================================
-
-/**
- * Add a node to the HashRing.
- * @since 1.18.0
- * @category combinators
- */
-export const add: {
-  <A extends PrimaryKey.PrimaryKey>(
-    node: A,
-    options?: { readonly weight?: number },
-  ): <E, R>(ref: RefHashRing<A, E, R>) => Effect.Effect<HashRing.HashRing<A>, E, R>;
-  <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    node: A,
-    options?: { readonly weight?: number },
-  ): Effect.Effect<HashRing.HashRing<A>, E, R>;
-} = dual(
-  (args) => RefSubject.isRefSubject(args[0]),
-  function add<A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    node: A,
-    options?: { readonly weight?: number },
-  ) {
-    return RefSubject.update(ref, (ring) => HashRing.add(copyRing(ring), node, options));
-  },
-);
-
-/**
- * Add multiple nodes to the HashRing.
- * @since 1.18.0
- * @category combinators
- */
-export const addMany: {
-  <A extends PrimaryKey.PrimaryKey>(
-    nodes: Iterable<A>,
-    options?: { readonly weight?: number },
-  ): <E, R>(ref: RefHashRing<A, E, R>) => Effect.Effect<HashRing.HashRing<A>, E, R>;
-  <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    nodes: Iterable<A>,
-    options?: { readonly weight?: number },
-  ): Effect.Effect<HashRing.HashRing<A>, E, R>;
-} = dual(
-  (args) => RefSubject.isRefSubject(args[0]),
-  function addMany<A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    nodes: Iterable<A>,
-    options?: { readonly weight?: number },
-  ) {
-    return RefSubject.update(ref, (ring) => HashRing.addMany(copyRing(ring), nodes, options));
-  },
-);
-
-/**
- * Remove a node from the HashRing.
- * @since 1.18.0
- * @category combinators
- */
-export const remove: {
-  <A extends PrimaryKey.PrimaryKey>(
-    node: A,
-  ): <E, R>(ref: RefHashRing<A, E, R>) => Effect.Effect<HashRing.HashRing<A>, E, R>;
-  <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    node: A,
-  ): Effect.Effect<HashRing.HashRing<A>, E, R>;
-} = dual(2, function remove<
-  A extends PrimaryKey.PrimaryKey,
-  E,
-  R,
->(ref: RefHashRing<A, E, R>, node: A) {
-  return RefSubject.update(ref, (ring) => HashRing.remove(copyRing(ring), node));
-});
-
-// ========================================
-// Computed
-// ========================================
-
-/**
- * Check if a node exists in the HashRing.
- * @since 1.18.0
- * @category computed
- */
-export const has: {
-  <A extends PrimaryKey.PrimaryKey>(
-    node: A,
-  ): <E, R>(ref: RefHashRing<A, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    node: A,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function has<
-  A extends PrimaryKey.PrimaryKey,
-  E,
-  R,
->(ref: RefHashRing<A, E, R>, node: A) {
-  return RefSubject.map(ref, HashRing.has(node));
-});
-
-/**
- * Get the number of nodes in the HashRing.
- * @since 1.18.0
- * @category computed
- */
-export const size = <A extends PrimaryKey.PrimaryKey, E, R>(
-  ref: RefHashRing<A, E, R>,
-): RefSubject.Computed<number, E, R> => RefSubject.map(ref, (ring) => ring.nodes.size);
-
-/**
- * Check if the HashRing is empty.
- * @since 1.18.0
- * @category computed
- */
-export const isEmpty = <A extends PrimaryKey.PrimaryKey, E, R>(
-  ref: RefHashRing<A, E, R>,
-): RefSubject.Computed<boolean, E, R> => RefSubject.map(ref, (ring) => ring.nodes.size === 0);
-
-/**
- * Get the node which should handle a given input string as a Computed.
- * Returns undefined if the ring is empty.
- * @since 1.18.0
- * @category computed
- */
-export const getNode: {
-  (
-    input: string,
-  ): <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-  ) => RefSubject.Computed<A | undefined, E, R>;
-  <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    input: string,
-  ): RefSubject.Computed<A | undefined, E, R>;
-} = dual(2, function getNode<
-  A extends PrimaryKey.PrimaryKey,
-  E,
-  R,
->(ref: RefHashRing<A, E, R>, input: string) {
-  return RefSubject.map(ref, (ring) => HashRing.get(ring, input));
-});
-
-/**
- * Get shard distribution across nodes.
- * @since 1.18.0
- * @category computed
- */
-export const getShards: {
-  (
-    count: number,
-  ): <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-  ) => RefSubject.Computed<Array<A> | undefined, E, R>;
-  <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    count: number,
-  ): RefSubject.Computed<Array<A> | undefined, E, R>;
-} = dual(2, function getShards<
-  A extends PrimaryKey.PrimaryKey,
-  E,
-  R,
->(ref: RefHashRing<A, E, R>, count: number) {
-  return RefSubject.map(ref, (ring) => HashRing.getShards(ring, count));
-});
-
-/**
- * Get all nodes as an array.
- * @since 1.18.0
- * @category computed
- */
-export const values = <A extends PrimaryKey.PrimaryKey, E, R>(
-  ref: RefHashRing<A, E, R>,
-): RefSubject.Computed<Array<A>, E, R> => RefSubject.map(ref, (ring) => Array.from(ring));
-
-// ========================================
-// Filtered
-// ========================================
-
-/**
- * Get the node which should handle a given input string as a Filtered.
- * Fails if the ring is empty.
- * @since 1.18.0
- * @category filtered
- */
-export const get: {
-  (
-    input: string,
-  ): <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-  ) => RefSubject.Filtered<A, E, R>;
-  <A extends PrimaryKey.PrimaryKey, E, R>(
-    ref: RefHashRing<A, E, R>,
-    input: string,
-  ): RefSubject.Filtered<A, E, R>;
-} = dual(2, function get<
-  A extends PrimaryKey.PrimaryKey,
-  E,
-  R,
->(ref: RefHashRing<A, E, R>, input: string) {
-  return RefSubject.filterMap(ref, (ring) => Option.fromUndefinedOr(HashRing.get(ring, input)));
-});

package/src/RefSubject/RefHashSet.ts

@@ -1,308 +0,0 @@
-/**
- * Extensions to RefSubject for working with HashSet values
- * @since 1.18.0
- */
-
-import type * as Effect from "effect/Effect";
-import { equals } from "effect/Equal";
-import { dual } from "effect/Function";
-import * as HashSet from "effect/HashSet";
-import type * as Scope from "effect/Scope";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-/**
- * A RefHashSet is a RefSubject specialized over a HashSet.
- * @since 1.18.0
- * @category models
- */
-export interface RefHashSet<
-  in out V,
-  in out E = never,
-  out R = never,
-> extends RefSubject.RefSubject<HashSet.HashSet<V>, E, R> {}
-
-/**
- * Creates a new `RefHashSet` from a HashSet, `Effect`, or `Fx`.
- * @since 1.18.0
- * @category constructors
- */
-export function make<V, E, R>(
-  initial:
-    | HashSet.HashSet<V>
-    | Effect.Effect<HashSet.HashSet<V>, E, R>
-    | Fx.Fx<HashSet.HashSet<V>, E, R>,
-): Effect.Effect<RefHashSet<V, E>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq: equals });
-}
-
-// ========================================
-// Combinators
-// ========================================
-
-/**
- * Add a value to the RefHashSet.
- * @since 1.18.0
- * @category combinators
- */
-export const add: {
-  <V>(value: V): <E, R>(ref: RefHashSet<V, E, R>) => Effect.Effect<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(ref: RefHashSet<V, E, R>, value: V): Effect.Effect<HashSet.HashSet<V>, E, R>;
-} = dual(2, function add<V, E, R>(ref: RefHashSet<V, E, R>, value: V) {
-  return RefSubject.update(ref, HashSet.add(value));
-});
-
-/**
- * Remove a value from the RefHashSet.
- * @since 1.18.0
- * @category combinators
- */
-export const remove: {
-  <V>(value: V): <E, R>(ref: RefHashSet<V, E, R>) => Effect.Effect<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(ref: RefHashSet<V, E, R>, value: V): Effect.Effect<HashSet.HashSet<V>, E, R>;
-} = dual(2, function remove<V, E, R>(ref: RefHashSet<V, E, R>, value: V) {
-  return RefSubject.update(ref, HashSet.remove(value));
-});
-
-/**
- * Clear all values from the RefHashSet.
- * @since 1.18.0
- * @category combinators
- */
-export const clear = <V, E, R>(ref: RefHashSet<V, E, R>): Effect.Effect<HashSet.HashSet<V>, E, R> =>
-  RefSubject.update(ref, () => HashSet.empty());
-
-/**
- * Compute the union with another HashSet.
- * @since 1.18.0
- * @category combinators
- */
-export const union: {
-  <V>(
-    that: HashSet.HashSet<V>,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => Effect.Effect<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(
-    ref: RefHashSet<V, E, R>,
-    that: HashSet.HashSet<V>,
-  ): Effect.Effect<HashSet.HashSet<V>, E, R>;
-} = dual(2, function union<V, E, R>(ref: RefHashSet<V, E, R>, that: HashSet.HashSet<V>) {
-  return RefSubject.update(ref, HashSet.union(that));
-});
-
-/**
- * Compute the intersection with another HashSet.
- * @since 1.18.0
- * @category combinators
- */
-export const intersection: {
-  <V>(
-    that: HashSet.HashSet<V>,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => Effect.Effect<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(
-    ref: RefHashSet<V, E, R>,
-    that: HashSet.HashSet<V>,
-  ): Effect.Effect<HashSet.HashSet<V>, E, R>;
-} = dual(2, function intersection<V, E, R>(ref: RefHashSet<V, E, R>, that: HashSet.HashSet<V>) {
-  return RefSubject.update(ref, HashSet.intersection(that));
-});
-
-/**
- * Compute the difference with another HashSet.
- * @since 1.18.0
- * @category combinators
- */
-export const difference: {
-  <V>(
-    that: HashSet.HashSet<V>,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => Effect.Effect<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(
-    ref: RefHashSet<V, E, R>,
-    that: HashSet.HashSet<V>,
-  ): Effect.Effect<HashSet.HashSet<V>, E, R>;
-} = dual(2, function difference<V, E, R>(ref: RefHashSet<V, E, R>, that: HashSet.HashSet<V>) {
-  return RefSubject.update(ref, HashSet.difference(that));
-});
-
-/**
- * Filter values in place.
- * @since 1.18.0
- * @category combinators
- */
-export const filter: {
-  <V>(
-    predicate: (value: V) => boolean,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => Effect.Effect<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(
-    ref: RefHashSet<V, E, R>,
-    predicate: (value: V) => boolean,
-  ): Effect.Effect<HashSet.HashSet<V>, E, R>;
-} = dual(2, function filter<V, E, R>(ref: RefHashSet<V, E, R>, predicate: (value: V) => boolean) {
-  return RefSubject.update(ref, HashSet.filter(predicate));
-});
-
-/**
- * Map values in place (endomorphic).
- * @since 1.18.0
- * @category combinators
- */
-export const map: {
-  <V>(
-    f: (value: V) => V,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => Effect.Effect<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(ref: RefHashSet<V, E, R>, f: (value: V) => V): Effect.Effect<HashSet.HashSet<V>, E, R>;
-} = dual(2, function map<V, E, R>(ref: RefHashSet<V, E, R>, f: (value: V) => V) {
-  return RefSubject.update(ref, HashSet.map(f));
-});
-
-// ========================================
-// Computed
-// ========================================
-
-/**
- * Get the current size of the RefHashSet.
- * @since 1.18.0
- * @category computed
- */
-export const size = <V, E, R>(ref: RefHashSet<V, E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, HashSet.size);
-
-/**
- * Check if the RefHashSet is empty.
- * @since 1.18.0
- * @category computed
- */
-export const isEmpty = <V, E, R>(ref: RefHashSet<V, E, R>): RefSubject.Computed<boolean, E, R> =>
-  RefSubject.map(ref, HashSet.isEmpty);
-
-/**
- * Check if the RefHashSet is non-empty.
- * @since 1.18.0
- * @category computed
- */
-export const isNonEmpty = <V, E, R>(ref: RefHashSet<V, E, R>): RefSubject.Computed<boolean, E, R> =>
-  RefSubject.map(ref, (s) => !HashSet.isEmpty(s));
-
-/**
- * Check if a value exists in the RefHashSet.
- * @since 1.18.0
- * @category computed
- */
-export const has: {
-  <V>(value: V): <E, R>(ref: RefHashSet<V, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <V, E, R>(ref: RefHashSet<V, E, R>, value: V): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function has<V, E, R>(ref: RefHashSet<V, E, R>, value: V) {
-  return RefSubject.map(ref, HashSet.has(value));
-});
-
-/**
- * Check if any value satisfies a predicate.
- * @since 1.18.0
- * @category computed
- */
-export const some: {
-  <V>(
-    predicate: (value: V) => boolean,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <V, E, R>(
-    ref: RefHashSet<V, E, R>,
-    predicate: (value: V) => boolean,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function some<V, E, R>(ref: RefHashSet<V, E, R>, predicate: (value: V) => boolean) {
-  return RefSubject.map(ref, HashSet.some(predicate));
-});
-
-/**
- * Check if all values satisfy a predicate.
- * @since 1.18.0
- * @category computed
- */
-export const every: {
-  <V>(
-    predicate: (value: V) => boolean,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <V, E, R>(
-    ref: RefHashSet<V, E, R>,
-    predicate: (value: V) => boolean,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function every<V, E, R>(ref: RefHashSet<V, E, R>, predicate: (value: V) => boolean) {
-  return RefSubject.map(ref, HashSet.every(predicate));
-});
-
-/**
- * Check if this set is a subset of another.
- * @since 1.18.0
- * @category computed
- */
-export const isSubset: {
-  <V>(
-    that: HashSet.HashSet<V>,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <V, E, R>(ref: RefHashSet<V, E, R>, that: HashSet.HashSet<V>): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function isSubset<V, E, R>(ref: RefHashSet<V, E, R>, that: HashSet.HashSet<V>) {
-  return RefSubject.map(ref, HashSet.isSubset(that));
-});
-
-/**
- * Map values to a different type.
- * @since 1.18.0
- * @category computed
- */
-export const mapValues: {
-  <V, B>(
-    f: (value: V) => B,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => RefSubject.Computed<HashSet.HashSet<B>, E, R>;
-  <V, E, R, B>(
-    ref: RefHashSet<V, E, R>,
-    f: (value: V) => B,
-  ): RefSubject.Computed<HashSet.HashSet<B>, E, R>;
-} = dual(2, function mapValues<V, E, R, B>(ref: RefHashSet<V, E, R>, f: (value: V) => B) {
-  return RefSubject.map(ref, HashSet.map(f));
-});
-
-/**
- * Filter values creating a Computed value.
- * @since 1.18.0
- * @category computed
- */
-export const filterValues: {
-  <V>(
-    predicate: (value: V) => boolean,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => RefSubject.Computed<HashSet.HashSet<V>, E, R>;
-  <V, E, R>(
-    ref: RefHashSet<V, E, R>,
-    predicate: (value: V) => boolean,
-  ): RefSubject.Computed<HashSet.HashSet<V>, E, R>;
-} = dual(2, function filterValues<
-  V,
-  E,
-  R,
->(ref: RefHashSet<V, E, R>, predicate: (value: V) => boolean) {
-  return RefSubject.map(ref, HashSet.filter(predicate));
-});
-
-/**
- * Reduce the values to a single value.
- * @since 1.18.0
- * @category computed
- */
-export const reduce: {
-  <V, B>(
-    b: B,
-    f: (b: B, value: V) => B,
-  ): <E, R>(ref: RefHashSet<V, E, R>) => RefSubject.Computed<B, E, R>;
-  <V, E, R, B>(
-    ref: RefHashSet<V, E, R>,
-    b: B,
-    f: (b: B, value: V) => B,
-  ): RefSubject.Computed<B, E, R>;
-} = dual(3, function reduce<V, E, R, B>(ref: RefHashSet<V, E, R>, b: B, f: (b: B, value: V) => B) {
-  return RefSubject.map(ref, HashSet.reduce(b, f));
-});
-
-/**
- * Get all values as an array.
- * @since 1.18.0
- * @category computed
- */
-export const values = <V, E, R>(ref: RefHashSet<V, E, R>): RefSubject.Computed<Array<V>, E, R> =>
-  RefSubject.map(ref, (s) => Array.from(s));