@typed/fx 1.18.4 → 1.20.0

package/src/RefHashMap.ts

@@ -3,13 +3,12 @@
  */
 
 import type { IdentifierConstructor, IdentifierOf } from "@typed/context"
-import { HashSet, type Scope } from "effect"
+import type { Scope } from "effect"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as HashMap from "effect/HashMap"
+import * as HashSet from "effect/HashSet"
 import type { Option } from "effect/Option"
-import type { Computed } from "./Computed.js"
-import type { Filtered } from "./Filtered.js"
 import type * as Fx from "./Fx.js"
 import * as RefSubject from "./RefSubject.js"
 
@@ -33,7 +32,7 @@ export function make<R, E, 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>>
+  initial: Effect.Effect<R, E, HashMap.HashMap<K, V>> | Fx.Fx<R, E, HashMap.HashMap<K, V>>
 ): Effect.Effect<R | Scope.Scope, never, RefHashMap<never, E, K, V>> {
   return RefSubject.make(initial)
 }
@@ -68,10 +67,10 @@ export function of<K, V>(
  * @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))
+  <K>(key: K): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => RefSubject.Computed<R, E, boolean>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): RefSubject.Computed<R, E, boolean>
+} = dual(2, function has<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): RefSubject.Computed<R, E, boolean> {
+  return RefSubject.map(refHashMap, HashMap.has(key))
 })
 
 /**
@@ -80,12 +79,16 @@ export const has: {
  * @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>
+  <K>(key: K, hash: number): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => RefSubject.Computed<R, E, boolean>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, hash: number): RefSubject.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))
+  function hasHash<R, E, K, V>(
+    refHashMap: RefHashMap<R, E, K, V>,
+    key: K,
+    hash: number
+  ): RefSubject.Computed<R, E, boolean> {
+    return RefSubject.map(refHashMap, HashMap.hasHash(key, hash))
   }
 )
 
@@ -94,8 +97,8 @@ export const hasHash: {
  * @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)
+export function isEmpty<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): RefSubject.Computed<R, E, boolean> {
+  return RefSubject.map(refHashMap, HashMap.isEmpty)
 }
 
 /**
@@ -103,8 +106,8 @@ export function isEmpty<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Compute
  * @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)
+export function keySet<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): RefSubject.Computed<R, E, HashSet.HashSet<K>> {
+  return RefSubject.map(refHashMap, HashMap.keySet)
 }
 
 /**
@@ -112,8 +115,8 @@ export function keySet<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed
  * @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)
+export function keys<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): RefSubject.Computed<R, E, Iterable<K>> {
+  return RefSubject.map(refHashMap, HashMap.keys)
 }
 
 /**
@@ -130,7 +133,7 @@ export const map: {
   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))
+  return RefSubject.update(refHashMap, HashMap.map(f))
 })
 
 /**
@@ -153,7 +156,7 @@ export const modify: {
   key: K,
   f: (v: V) => V
 ): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
-  return refHashMap.update(HashMap.modify(key, f))
+  return RefSubject.update(refHashMap, HashMap.modify(key, f))
 })
 
 /**
@@ -176,7 +179,7 @@ export const modifyAt: {
   key: K,
   f: HashMap.HashMap.UpdateFn<V>
 ): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
-  return self.update(HashMap.modifyAt(key, f))
+  return RefSubject.update(self, HashMap.modifyAt(key, f))
 })
 
 /**
@@ -202,7 +205,7 @@ export const modifyHash: {
   hash: number,
   f: HashMap.HashMap.UpdateFn<V>
 ): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
-  return self.update(HashMap.modifyHash(key, hash, f))
+  return RefSubject.update(self, HashMap.modifyHash(key, hash, f))
 })
 
 /**
@@ -211,14 +214,21 @@ export const modifyHash: {
  * @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>
+  <K, V, B>(
+    seed: B,
+    f: (acc: B, a: V, k: K) => B
+  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => RefSubject.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
+  ): RefSubject.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))
+): RefSubject.Computed<R, E, B> {
+  return RefSubject.map(refHashMap, HashMap.reduce(seed, f))
 })
 
 /**
@@ -230,7 +240,7 @@ 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))
+  return RefSubject.update(refHashMap, HashMap.remove(key))
 })
 
 /**
@@ -242,7 +252,7 @@ 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))
+  return RefSubject.update(refHashMap, HashMap.removeMany(key))
 })
 
 /**
@@ -257,7 +267,7 @@ export const set: {
   ): <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))
+  return RefSubject.update(refHashMap, HashMap.set(key, value))
 })
 
 /**
@@ -265,8 +275,8 @@ export const set: {
  * @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)
+export function size<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): RefSubject.Computed<R, E, number> {
+  return RefSubject.map(refHashMap, HashMap.size)
 }
 
 /**
@@ -274,8 +284,8 @@ export function size<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed<R
  * @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)
+export function values<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): RefSubject.Computed<R, E, Iterable<V>> {
+  return RefSubject.map(refHashMap, HashMap.values)
 }
 
 /**
@@ -283,8 +293,10 @@ export function values<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Computed
  * @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)
+export function valuesSet<R, E, K, V>(
+  refHashMap: RefHashMap<R, E, K, V>
+): RefSubject.Computed<R, E, HashSet.HashSet<V>> {
+  return RefSubject.map(values(refHashMap), HashSet.fromIterable)
 }
 
 /**
@@ -292,8 +304,10 @@ export function valuesSet<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): Compu
  * @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)
+export function compact<R, E, K, V>(
+  refHashMap: RefHashMap<R, E, K, Option<V>>
+): RefSubject.Computed<R, E, HashMap.HashMap<K, V>> {
+  return RefSubject.map(refHashMap, HashMap.compact)
 }
 
 /**
@@ -301,10 +315,10 @@ export function compact<R, E, K, V>(refHashMap: RefHashMap<R, E, K, Option<V>>):
  * @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>
+  <K>(key: K): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => RefSubject.Filtered<R, E, V>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): RefSubject.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))
+  return RefSubject.filterMap(refHashMap, HashMap.get(key))
 })
 
 /**
@@ -312,8 +326,8 @@ export const get: {
  * @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>
+  <K>(key: K, hash: number): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => RefSubject.Filtered<R, E, V>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, hash: number): RefSubject.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))
+  return RefSubject.filterMap(refHashMap, HashMap.get(key))
 })

package/src/RefHashSet.ts

@@ -8,7 +8,6 @@ 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.js"
 import type * as Fx from "./Fx.js"
 import * as RefSubject from "./RefSubject.js"
 
@@ -20,19 +19,10 @@ import * as RefSubject from "./RefSubject.js"
 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>>
+  initial: Effect.Effect<R, E, HashSet.HashSet<A>> | Fx.Fx<R, E, HashSet.HashSet<A>>
 ): Effect.Effect<R | Scope.Scope, never, RefHashSet<never, E, A>> {
   return RefSubject.make(
     initial
@@ -61,7 +51,7 @@ 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))
+  return RefSubject.update(ref, HashSet.add(value))
 })
 
 /**
@@ -75,13 +65,12 @@ export const appendAll: {
   ): <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) =>
+  return RefSubject.update(ref, (set) =>
     HashSet.mutate(set, (set) => {
       for (const a of value) {
         HashSet.add(set, a)
       }
-    })
-  )
+    }))
 })
 
 /**
@@ -92,13 +81,13 @@ export const appendAll: {
 export const filterValues: {
   <A>(
     predicate: (a: A) => boolean
-  ): <R, E>(ref: RefHashSet<R, E, A>) => Computed.Computed<R, E, HashSet.HashSet<A>>
+  ): <R, E>(ref: RefHashSet<R, E, A>) => RefSubject.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>>
+  ): RefSubject.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))
+  return RefSubject.map(ref, HashSet.filter(predicate))
 })
 
 /**
@@ -106,7 +95,8 @@ export const filterValues: {
  * @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)
+export const size = <R, E, A>(ref: RefHashSet<R, E, A>): RefSubject.Computed<R, E, number> =>
+  RefSubject.map(ref, HashSet.size)
 
 /**
  * Map (Endomorphic) the values of a RefHashSet.
@@ -116,13 +106,13 @@ export const size = <R, E, A>(ref: RefHashSet<R, E, A>): Computed.Computed<R, E,
 export const map: {
   <A>(
     f: (a: A) => A
-  ): <R, E>(ref: RefHashSet<R, E, A>) => Computed.Computed<R, E, HashSet.HashSet<A>>
+  ): <R, E>(ref: RefHashSet<R, E, A>) => RefSubject.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>>
+  ): RefSubject.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))
+  return RefSubject.update(ref, HashSet.map(f))
 })
 
 /**
@@ -133,15 +123,15 @@ export const map: {
 export const mapValues: {
   <A, B>(
     f: (a: A) => B
-  ): <R, E>(ref: RefHashSet<R, E, A>) => Computed.Computed<R, E, ReadonlyArray<B>>
+  ): <R, E>(ref: RefHashSet<R, E, A>) => RefSubject.Computed<R, E, ReadonlyArray<B>>
   <R, E, A, B>(
     ref: RefHashSet<R, E, A>,
     f: (a: A) => B
-  ): Computed.Computed<R, E, ReadonlyArray<B>>
+  ): RefSubject.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))
+    return RefSubject.map(ref, HashSet.map(f))
   }
 )
 
@@ -155,14 +145,14 @@ export const partition: {
     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<
+  ) => RefSubject.Computed<R, E, readonly [ReadonlyArray<B>, HashSet.HashSet<A>]>
+  <R, E, A>(ref: RefHashSet<R, E, A>, predicate: (a: A) => boolean): RefSubject.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))
+  return RefSubject.map(ref, HashSet.partition(predicate))
 })
 
 /**
@@ -174,15 +164,15 @@ 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>(ref: RefHashSet<R, E, A>) => RefSubject.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>
+  ): RefSubject.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))
+    return RefSubject.map(ref, HashSet.reduce(b, f))
   }
 )