@typed/fx 1.17.4 → 1.18.0

package/src/RefHashMap.ts

@@ -0,0 +1,319 @@
+/**
+ * @since 1.18.0
+ */
+
+import type { IdentifierConstructor, IdentifierOf } from "@typed/context"
+import { HashSet, type Scope } from "effect"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import * as HashMap from "effect/HashMap"
+import type { Option } from "effect/Option"
+import type { Computed } from "./Computed"
+import type { Filtered } from "./Filtered"
+import type * as Fx from "./Fx"
+import * as RefSubject from "./RefSubject"
+
+/**
+ * A RefHashMap is a RefSubject that is specialized over a HashMap of values.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefHashMap<R, E, K, V> extends RefSubject.RefSubject<R, E, HashMap.HashMap<K, V>> {}
+
+/**
+ * Construct a new RefHashMap with the given initial value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<R, E, K, V>(
+  initial: Effect.Effect<R, E, HashMap.HashMap<K, V>>
+): Effect.Effect<R | Scope.Scope, never, RefHashMap<never, E, K, V>>
+export function make<R, E, K, V>(
+  initial: Fx.Fx<R, E, HashMap.HashMap<K, V>>
+): Effect.Effect<R | Scope.Scope, never, RefHashMap<never, E, K, V>>
+
+export function make<R, E, K, V>(
+  initial: Fx.FxInput<R, E, HashMap.HashMap<K, V>>
+): Effect.Effect<R | Scope.Scope, never, RefHashMap<never, E, K, V>> {
+  return RefSubject.make(initial)
+}
+
+/**
+ * Create a Tagged RefHashMap
+ * @since 1.18.0
+ * @category constructors
+ */
+export const tagged: <K, V>() => {
+  <const I extends IdentifierConstructor<any>>(
+    identifier: (id: <const T>(uniqueIdentifier: T) => IdentifierConstructor<T>) => I
+  ): RefSubject.RefSubject.Tagged<IdentifierOf<I>, never, HashMap.HashMap<K, V>>
+
+  <const I>(identifier: I): RefSubject.RefSubject.Tagged<IdentifierOf<I>, never, HashMap.HashMap<K, V>>
+} = <E, A>() => RefSubject.tagged<never, HashMap.HashMap<E, A>>()
+
+/**
+ * This function creates a new RefHashMap from a given HashMap.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function of<K, V>(
+  map: HashMap.HashMap<K, V>
+): Effect.Effect<Scope.Scope, never, RefHashMap<never, never, K, V>> {
+  return make(Effect.succeed(map))
+}
+
+/**
+ * Check if a key is available withing a HashMap
+ * @since 1.18.0
+ * @category computed
+ */
+export const has: {
+  <K>(key: K): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Computed<R, E, boolean>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): Computed<R, E, boolean>
+} = dual(2, function has<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): Computed<R, E, boolean> {
+  return refHashMap.map(HashMap.has(key))
+})
+
+/**
+ * Check if a key is available withing a HashMap
+ * @since 1.18.0
+ * @category computed
+ */
+export const hasHash: {
+  <K>(key: K, hash: number): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Computed<R, E, boolean>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, hash: number): Computed<R, E, boolean>
+} = dual(
+  3,
+  function hasHash<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, hash: number): Computed<R, E, boolean> {
+    return refHashMap.map(HashMap.hasHash(key, hash))
+  }
+)
+
+/**
+ * Check if HashMap is empty
+ * @since 1.18.0
+ * @category computed
+ */
+export function isEmpty<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed<R, E, boolean> {
+  return refHashMap.map(HashMap.isEmpty)
+}
+
+/**
+ * Get the keys as a HashSet
+ * @since 1.18.0
+ * @category computed
+ */
+export function keySet<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed<R, E, HashSet.HashSet<K>> {
+  return refHashMap.map(HashMap.keySet)
+}
+
+/**
+ * Get the keys as an Iterable
+ * @since 1.18.0
+ * @category computed
+ */
+export function keys<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed<R, E, Iterable<K>> {
+  return refHashMap.map(HashMap.keys)
+}
+
+/**
+ * Map the values within the HashMap
+ * @since 1.18.0
+ * @category combinators
+ */
+export const map: {
+  <K, V>(
+    f: (v: V, k: K) => V
+  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, f: (v: V, k: K) => V): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+} = dual(2, function map<R, E, K, V>(
+  refHashMap: RefHashMap<R, E, K, V>,
+  f: (v: V, k: K) => V
+): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+  return refHashMap.update(HashMap.map(f))
+})
+
+/**
+ * Map the values within the HashMap
+ * @since 1.18.0
+ * @category combinators
+ */
+export const modify: {
+  <K, V>(
+    key: K,
+    f: (v: V) => V
+  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <R, E, K, V>(
+    refHashMap: RefHashMap<R, E, K, V>,
+    key: K,
+    f: (v: V) => V
+  ): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+} = dual(3, function map<R, E, K, V>(
+  refHashMap: RefHashMap<R, E, K, V>,
+  key: K,
+  f: (v: V) => V
+): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+  return refHashMap.update(HashMap.modify(key, f))
+})
+
+/**
+ * Map the values within the HashMap
+ * @since 1.18.0
+ * @category combinators
+ */
+export const modifyAt: {
+  <K, V>(
+    key: K,
+    f: HashMap.HashMap.UpdateFn<V>
+  ): <R, E>(self: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <R, E, K, V>(
+    self: RefHashMap<R, E, K, V>,
+    key: K,
+    f: HashMap.HashMap.UpdateFn<V>
+  ): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+} = dual(3, function modifyAt<R, E, K, V>(
+  self: RefHashMap<R, E, K, V>,
+  key: K,
+  f: HashMap.HashMap.UpdateFn<V>
+): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+  return self.update(HashMap.modifyAt(key, f))
+})
+
+/**
+ * Map the values within the HashMap
+ * @since 1.18.0
+ * @category combinators
+ */
+export const modifyHash: {
+  <K, V>(
+    key: K,
+    hash: number,
+    f: HashMap.HashMap.UpdateFn<V>
+  ): <R, E>(self: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <R, E, K, V>(
+    self: RefHashMap<R, E, K, V>,
+    key: K,
+    hash: number,
+    f: HashMap.HashMap.UpdateFn<V>
+  ): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+} = dual(4, function modifyAt<R, E, K, V>(
+  self: RefHashMap<R, E, K, V>,
+  key: K,
+  hash: number,
+  f: HashMap.HashMap.UpdateFn<V>
+): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+  return self.update(HashMap.modifyHash(key, hash, f))
+})
+
+/**
+ * Get the keys as an Iterable
+ * @since 1.18.0
+ * @category computed
+ */
+export const reduce: {
+  <K, V, B>(seed: B, f: (acc: B, a: V, k: K) => B): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Computed<R, E, B>
+  <R, E, K, V, B>(refHashMap: RefHashMap<R, E, K, V>, seed: B, f: (acc: B, a: V, k: K) => B): Computed<R, E, B>
+} = dual(3, function reduce<R, E, K, V, B>(
+  refHashMap: RefHashMap<R, E, K, V>,
+  seed: B,
+  f: (acc: B, a: V, k: K) => B
+): Computed<R, E, B> {
+  return refHashMap.map(HashMap.reduce(seed, f))
+})
+
+/**
+ * Remove a value at key from the HashMap
+ * @since 1.18.0
+ * @category combinators
+ */
+export const remove: {
+  <K>(key: K): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+} = dual(2, function remove<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K) {
+  return refHashMap.update(HashMap.remove(key))
+})
+
+/**
+ * Remove a value at key from the HashMap
+ * @since 1.18.0
+ * @category combinators
+ */
+export const removeMany: {
+  <K>(key: Iterable<K>): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: Iterable<K>): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+} = dual(2, function removeMany<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: Iterable<K>) {
+  return refHashMap.update(HashMap.removeMany(key))
+})
+
+/**
+ * Set a value at a particular key in the HashMap
+ * @since 1.18.0
+ * @category combinators
+ */
+export const set: {
+  <K, V>(
+    key: K,
+    value: V
+  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, value: V): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+} = dual(3, function set<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, value: V) {
+  return refHashMap.update(HashMap.set(key, value))
+})
+
+/**
+ * Check the size of the HashMap
+ * @since 1.18.0
+ * @category computed
+ */
+export function size<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed<R, E, number> {
+  return refHashMap.map(HashMap.size)
+}
+
+/**
+ * Get the values as an Iterable
+ * @since 1.18.0
+ * @category computed
+ */
+export function values<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed<R, E, Iterable<V>> {
+  return refHashMap.map(HashMap.values)
+}
+
+/**
+ * Get the values as an HashSet
+ * @since 1.18.0
+ * @category computed
+ */
+export function valuesSet<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed<R, E, HashSet.HashSet<V>> {
+  return values(refHashMap).map(HashSet.fromIterable)
+}
+
+/**
+ * Create a projection of available values
+ * @since 1.18.0
+ * @category computed
+ */
+export function compact<R, E, K, V>(refHashMap: RefHashMap<R, E, K, Option<V>>): Computed<R, E, HashMap.HashMap<K, V>> {
+  return refHashMap.map(HashMap.compact)
+}
+
+/**
+ * @since 1.18.0
+ * @category filtered
+ */
+export const get: {
+  <K>(key: K): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Filtered<R, E, V>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): Filtered<R, E, V>
+} = dual(2, function get<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K) {
+  return refHashMap.filterMap(HashMap.get(key))
+})
+
+/**
+ * @since 1.18.0
+ * @category filtered
+ */
+export const getHash: {
+  <K>(key: K, hash: number): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Filtered<R, E, V>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, hash: number): Filtered<R, E, V>
+} = dual(2, function get<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K) {
+  return refHashMap.filterMap(HashMap.get(key))
+})

package/src/RefHashSet.ts

@@ -0,0 +1,188 @@
+/**
+ * Extensions to RefSubject for working with arrays of values
+ * @since 1.18.0
+ */
+
+import type { IdentifierConstructor, IdentifierOf } from "@typed/context"
+import type * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import * as HashSet from "effect/HashSet"
+import type * as Scope from "effect/Scope"
+import type * as Computed from "./Computed"
+import type * as Fx from "./Fx"
+import * as RefSubject from "./RefSubject"
+
+/**
+ * A RefHashSet is a RefSubject that is specialized over an HashSet of values.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefHashSet<R, E, A> extends RefSubject.RefSubject<R, E, HashSet.HashSet<A>> {}
+
+/**
+ * Construct a new RefHashSet with the given initial value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<R, E, A>(
+  initial: Effect.Effect<R, E, HashSet.HashSet<A>>
+): Effect.Effect<R | Scope.Scope, never, RefHashSet<never, E, A>>
+export function make<R, E, A>(
+  initial: Fx.Fx<R, E, HashSet.HashSet<A>>
+): Effect.Effect<R | Scope.Scope, never, RefHashSet<never, E, A>>
+
+export function make<R, E, A>(
+  initial: Fx.FxInput<R, E, HashSet.HashSet<A>>
+): Effect.Effect<R | Scope.Scope, never, RefHashSet<never, E, A>> {
+  return RefSubject.make(
+    initial
+  )
+}
+
+/**
+ * Create a Tagged RefHashSet
+ * @since 1.18.0
+ * @category constructors
+ */
+export const tagged: <A>() => {
+  <const I extends IdentifierConstructor<any>>(
+    identifier: (id: <const T>(uniqueIdentifier: T) => IdentifierConstructor<T>) => I
+  ): RefSubject.RefSubject.Tagged<IdentifierOf<I>, never, HashSet.HashSet<A>>
+
+  <const I>(identifier: I): RefSubject.RefSubject.Tagged<IdentifierOf<I>, never, HashSet.HashSet<A>>
+} = <A>() => RefSubject.tagged<never, HashSet.HashSet<A>>()
+
+/**
+ * Add a value to the current state of a RefHashSet.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const add: {
+  <A>(value: A): <R, E>(ref: RefHashSet<R, E, A>) => Effect.Effect<R, E, HashSet.HashSet<A>>
+  <R, E, A>(ref: RefHashSet<R, E, A>, value: A): Effect.Effect<R, E, HashSet.HashSet<A>>
+} = dual(2, function add<R, E, A>(ref: RefHashSet<R, E, A>, value: A) {
+  return ref.update(HashSet.add(value))
+})
+
+/**
+ * Append an iterable of values to the current state of a RefHashSet.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const appendAll: {
+  <A>(
+    value: Iterable<A>
+  ): <R, E>(ref: RefHashSet<R, E, A>) => Effect.Effect<R, E, HashSet.HashSet<A>>
+  <R, E, A>(ref: RefHashSet<R, E, A>, value: Iterable<A>): Effect.Effect<R, E, HashSet.HashSet<A>>
+} = dual(2, function appendAll<R, E, A>(ref: RefHashSet<R, E, A>, value: Iterable<A>) {
+  return ref.update((set) =>
+    HashSet.mutate(set, (set) => {
+      for (const a of value) {
+        HashSet.add(set, a)
+      }
+    })
+  )
+})
+
+/**
+ * Filter the values of a RefHashSet using a predicate creating a Computed value.
+ * @since 1.18.0
+ * @category computed
+ */
+export const filterValues: {
+  <A>(
+    predicate: (a: A) => boolean
+  ): <R, E>(ref: RefHashSet<R, E, A>) => Computed.Computed<R, E, HashSet.HashSet<A>>
+  <R, E, A>(
+    ref: RefHashSet<R, E, A>,
+    predicate: (a: A) => boolean
+  ): Computed.Computed<R, E, HashSet.HashSet<A>>
+} = dual(2, function filterValues<R, E, A>(ref: RefHashSet<R, E, A>, predicate: (a: A) => boolean) {
+  return ref.map(HashSet.filter(predicate))
+})
+
+/**
+ * Get the current length of a RefHashSet.
+ * @since 1.18.0
+ * @category computed
+ */
+export const size = <R, E, A>(ref: RefHashSet<R, E, A>): Computed.Computed<R, E, number> => ref.map(HashSet.size)
+
+/**
+ * Map (Endomorphic) the values of a RefHashSet.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const map: {
+  <A>(
+    f: (a: A) => A
+  ): <R, E>(ref: RefHashSet<R, E, A>) => Computed.Computed<R, E, HashSet.HashSet<A>>
+  <R, E, A>(
+    ref: RefHashSet<R, E, A>,
+    f: (a: A) => A
+  ): Computed.Computed<R, E, HashSet.HashSet<A>>
+} = dual(2, function mapValues<R, E, A>(ref: RefHashSet<R, E, A>, f: (a: A) => A) {
+  return ref.update(HashSet.map(f))
+})
+
+/**
+ * Map the values with their indexes of a RefHashSet.
+ * @since 1.18.0
+ * @category computed
+ */
+export const mapValues: {
+  <A, B>(
+    f: (a: A) => B
+  ): <R, E>(ref: RefHashSet<R, E, A>) => Computed.Computed<R, E, ReadonlyArray<B>>
+  <R, E, A, B>(
+    ref: RefHashSet<R, E, A>,
+    f: (a: A) => B
+  ): Computed.Computed<R, E, ReadonlyArray<B>>
+} = dual(
+  2,
+  function mapValues<R, E, A, B>(ref: RefHashSet<R, E, A>, f: (a: A) => B) {
+    return ref.map(HashSet.map(f))
+  }
+)
+
+/**
+ * Partition the values of a RefHashSet using a predicate.
+ * @since 1.18.0
+ * @category computed
+ */
+export const partition: {
+  <A, B extends A>(
+    predicate: (a: A) => a is B
+  ): <R, E>(
+    ref: RefHashSet<R, E, A>
+  ) => Computed.Computed<R, E, readonly [ReadonlyArray<B>, HashSet.HashSet<A>]>
+  <R, E, A>(ref: RefHashSet<R, E, A>, predicate: (a: A) => boolean): Computed.Computed<
+    never,
+    E,
+    readonly [HashSet.HashSet<A>, HashSet.HashSet<A>]
+  >
+} = dual(2, function partition<R, E, A>(ref: RefHashSet<R, E, A>, predicate: (a: A) => boolean) {
+  return ref.map(HashSet.partition(predicate))
+})
+
+/**
+ * Reduce the values of a RefHashSet to a single value.
+ * @since 1.18.0
+ * @category computed
+ */
+export const reduce: {
+  <A, B>(
+    b: B,
+    f: (b: B, a: A) => B
+  ): <R, E>(ref: RefHashSet<R, E, A>) => Computed.Computed<R, E, B>
+  <R, E, A, B>(
+    ref: RefHashSet<R, E, A>,
+    b: B,
+    f: (b: B, a: A) => B
+  ): Computed.Computed<R, E, B>
+} = dual(
+  3,
+  function reduce<R, E, A, B>(ref: RefHashSet<R, E, A>, b: B, f: (b: B, a: A) => B) {
+    return ref.map(HashSet.reduce(b, f))
+  }
+)

package/src/RefNumber.ts

@@ -0,0 +1,77 @@
+/**
+ * @since 1.18.0
+ */
+
+import type { IdentifierConstructor, IdentifierOf } from "@typed/context/Identifier"
+import type { Effect } from "effect"
+import { strict } from "effect/Equivalence"
+import type { Scope } from "effect/Scope"
+import type * as Fx from "./Fx"
+import * as RefSubject from "./RefSubject"
+
+const add = (x: number): number => x + 1
+const sub = (x: number): number => x - 1
+
+/**
+ * A RefSubject holding a number values
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefNumber<R, E> extends RefSubject.RefSubject<R, E, number> {}
+
+/**
+ * Construct a new RefArray with the given initial value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<R, E>(
+  initial: Effect.Effect<R, E, number>
+): Effect.Effect<R | Scope, never, RefNumber<never, E>>
+export function make<R, E>(
+  initial: Fx.Fx<R, E, number>
+): Effect.Effect<R | Scope, never, RefNumber<never, E>>
+
+export function make<R, E>(
+  initial: Fx.FxInput<R, E, number>
+): Effect.Effect<R | Scope, never, RefNumber<never, E>> {
+  return RefSubject.make(initial, strict())
+}
+
+/**
+ * Construct a new RefArray with the given initial value.
+ * @since 1.18.0
+ * @category constructors
+ */
+export function of(
+  initial: number
+): Effect.Effect<Scope, never, RefNumber<never, never>> {
+  return RefSubject.of(initial, strict())
+}
+
+/**
+ * Create a Tagged RefNumber
+ * @since 1.18.0
+ * @category constructors
+ */
+export const tagged: {
+  <const I extends IdentifierConstructor<any>>(
+    identifier: I
+  ): RefSubject.RefSubject.Tagged<IdentifierOf<I>, never, number>
+  <const I>(identifier: I): RefSubject.RefSubject.Tagged<IdentifierOf<I>, never, number>
+} = RefSubject.tagged<never, number>(strict())
+
+/**
+ * Set the value to true
+ * @since 1.18.0
+ */
+export const increment: <R, E>(ref: RefNumber<R, E>) => Effect.Effect<R, E, number> = <R, E>(
+  ref: RefNumber<R, E>
+) => ref.update(add)
+
+/**
+ * Set the value to false
+ * @since 1.18.0
+ */
+export const decrement: <R, E>(ref: RefNumber<R, E>) => Effect.Effect<R, E, number> = <R, E>(
+  ref: RefNumber<R, E>
+) => ref.update(sub)