effect 2.3.7 → 2.4.0

package/src/internal/fiberId.ts

@@ -71,12 +71,8 @@ class Runtime implements FiberId.Runtime {
     readonly id: number,
     readonly startTimeMillis: number
   ) {}
-  _hash: number | undefined;
   [Hash.symbol](): number {
-    if (this._hash == undefined) {
-      this._hash = Hash.string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`)
-    }
-    return this._hash
+    return Hash.cached(this, Hash.string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`))
   }
   [Equal.symbol](that: unknown): boolean {
     return isFiberId(that) &&
@@ -111,14 +107,12 @@ class Composite implements FiberId.Composite {
   }
   _hash: number | undefined;
   [Hash.symbol](): number {
-    if (this._hash == undefined) {
-      this._hash = pipe(
-        Hash.string(`${FiberIdSymbolKey}-${this._tag}`),
-        Hash.combine(Hash.hash(this.left)),
-        Hash.combine(Hash.hash(this.right))
-      )
-    }
-    return this._hash
+    return pipe(
+      Hash.string(`${FiberIdSymbolKey}-${this._tag}`),
+      Hash.combine(Hash.hash(this.left)),
+      Hash.combine(Hash.hash(this.right)),
+      Hash.cached(this)
+    )
   }
   [Equal.symbol](that: unknown): boolean {
     return isFiberId(that) &&

package/src/internal/fiberRuntime.ts

@@ -1915,9 +1915,9 @@ export const forEachParUnbounded = <A, B, E, R>(
   })
 
 /** @internal */
-export const forEachConcurrentDiscard = <A, _, E, R>(
+export const forEachConcurrentDiscard = <A, X, E, R>(
   self: Iterable<A>,
-  f: (a: A, i: number) => Effect.Effect<_, E, R>,
+  f: (a: A, i: number) => Effect.Effect<X, E, R>,
   batching: boolean,
   processAll: boolean,
   n?: number
@@ -1933,7 +1933,7 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
         let counter = 0
         let interrupted = false
         const fibersCount = n ? Math.min(todos.length, n) : todos.length
-        const fibers = new Set<FiberRuntime<Exit.Exit<_, E> | Effect.Blocked<_, E>>>()
+        const fibers = new Set<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
         const results = new Array()
         const interruptAll = () =>
           fibers.forEach((fiber) => {
@@ -1941,8 +1941,8 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
               fiber.unsafeInterruptAsFork(parent.id())
             }, 0)
           })
-        const startOrder = new Array<FiberRuntime<Exit.Exit<_, E> | Effect.Blocked<_, E>>>()
-        const joinOrder = new Array<FiberRuntime<Exit.Exit<_, E> | Effect.Blocked<_, E>>>()
+        const startOrder = new Array<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
+        const joinOrder = new Array<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
         const residual = new Array<core.Blocked>()
         const collectExits = () => {
           const exits: Array<Exit.Exit<any, E>> = results
@@ -1978,7 +1978,7 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
         const stepOrExit = batching ? core.step : core.exit
         const processingFiber = runFiber(
           core.async<any, any, any>((resume) => {
-            const pushResult = <_, E>(res: Exit.Exit<_, E> | Effect.Blocked<_, E>, index: number) => {
+            const pushResult = <X, E>(res: Exit.Exit<X, E> | Effect.Blocked<X, E>, index: number) => {
               if (res._op === "Blocked") {
                 residual.push(res as core.Blocked)
               } else {
@@ -2002,8 +2002,8 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
                     ))
                 }
                 const onRes = (
-                  res: Exit.Exit<_, E> | Effect.Blocked<_, E>
-                ): Effect.Effect<Exit.Exit<_, E> | Effect.Blocked<_, E>, never, R> => {
+                  res: Exit.Exit<X, E> | Effect.Blocked<X, E>
+                ): Effect.Effect<Exit.Exit<X, E> | Effect.Blocked<X, E>, never, R> => {
                   if (todos.length > 0) {
                     pushResult(res, index)
                     if (todos.length > 0) {
@@ -3315,7 +3315,7 @@ export const raceFibersWith = dual<
     }, FiberId.combine(leftFiber.id(), rightFiber.id()))
   }))
 
-const completeRace = <R, R1, R2, E2, A2, R3, E3, A3>(
+const completeRace = <A2, A3, E2, E3, R, R1, R2, R3>(
   winner: Fiber.RuntimeFiber<any, any>,
   loser: Fiber.RuntimeFiber<any, any>,
   cont: (winner: Fiber.RuntimeFiber<any, any>, loser: Fiber.RuntimeFiber<any, any>) => Effect.Effect<any, any, any>,

package/src/internal/fiberStatus.ts

@@ -31,15 +31,14 @@ export const OP_SUSPENDED = "Suspended" as const
 /** @internal */
 export type OP_SUSPENDED = typeof OP_SUSPENDED
 
+const DoneHash = Hash.string(`${FiberStatusSymbolKey}-${OP_DONE}`)
+
 /** @internal */
 class Done implements FiberStatus.Done {
   readonly [FiberStatusTypeId]: FiberStatus.FiberStatusTypeId = FiberStatusTypeId
   readonly _tag = OP_DONE;
   [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(FiberStatusSymbolKey),
-      Hash.combine(Hash.hash(this._tag))
-    )
+    return DoneHash
   }
   [Equal.symbol](that: unknown): boolean {
     return isFiberStatus(that) && that._tag === OP_DONE
@@ -55,7 +54,8 @@ class Running implements FiberStatus.Running {
     return pipe(
       Hash.hash(FiberStatusSymbolKey),
       Hash.combine(Hash.hash(this._tag)),
-      Hash.combine(Hash.hash(this.runtimeFlags))
+      Hash.combine(Hash.hash(this.runtimeFlags)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {
@@ -80,7 +80,8 @@ class Suspended implements FiberStatus.Suspended {
       Hash.hash(FiberStatusSymbolKey),
       Hash.combine(Hash.hash(this._tag)),
       Hash.combine(Hash.hash(this.runtimeFlags)),
-      Hash.combine(Hash.hash(this.blockingOn))
+      Hash.combine(Hash.hash(this.blockingOn)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {

package/src/internal/groupBy.ts

@@ -13,7 +13,7 @@ import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
 import type * as Stream from "../Stream.js"
 import type * as Take from "../Take.js"
-import type { NoInfer } from "../Types.js"
+import type { MergeRecord, NoInfer } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as core from "./core-stream.js"
@@ -45,14 +45,14 @@ export const isGroupBy = (u: unknown): u is GroupBy.GroupBy<unknown, unknown, un
 
 /** @internal */
 export const evaluate = dual<
-  <K, E, V, R2, E2, A>(
+  <K, V, E, A, E2, R2>(
     f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => <R>(self: GroupBy.GroupBy<R, E, K, V>) => Stream.Stream<A, E | E2, R2 | R>,
-  <R, K, E, V, R2, E2, A>(
-    self: GroupBy.GroupBy<R, E, K, V>,
+  ) => <R>(self: GroupBy.GroupBy<K, V, E, R>) => Stream.Stream<A, E | E2, R2 | R>,
+  <K, V, E, R, A, E2, R2>(
+    self: GroupBy.GroupBy<K, V, E, R>,
     f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
@@ -60,8 +60,8 @@ export const evaluate = dual<
   ) => Stream.Stream<A, E | E2, R2 | R>
 >(
   (args) => isGroupBy(args[0]),
-  <R, K, E, V, R2, E2, A>(
-    self: GroupBy.GroupBy<R, E, K, V>,
+  <K, V, E, R, A, E2, R2>(
+    self: GroupBy.GroupBy<K, V, E, R>,
     f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
@@ -76,9 +76,9 @@ export const evaluate = dual<
 
 /** @internal */
 export const filter = dual<
-  <K>(predicate: Predicate<NoInfer<K>>) => <R, E, V>(self: GroupBy.GroupBy<R, E, K, V>) => GroupBy.GroupBy<R, E, K, V>,
-  <R, E, V, K>(self: GroupBy.GroupBy<R, E, K, V>, predicate: Predicate<K>) => GroupBy.GroupBy<R, E, K, V>
->(2, <R, E, V, K>(self: GroupBy.GroupBy<R, E, K, V>, predicate: Predicate<K>): GroupBy.GroupBy<R, E, K, V> =>
+  <K>(predicate: Predicate<NoInfer<K>>) => <V, E, R>(self: GroupBy.GroupBy<K, V, E, R>) => GroupBy.GroupBy<K, V, E, R>,
+  <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, predicate: Predicate<K>) => GroupBy.GroupBy<K, V, E, R>
+>(2, <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, predicate: Predicate<K>): GroupBy.GroupBy<K, V, E, R> =>
   make(
     pipe(
       self.grouped,
@@ -93,9 +93,9 @@ export const filter = dual<
 
 /** @internal */
 export const first = dual<
-  (n: number) => <R, E, K, V>(self: GroupBy.GroupBy<R, E, K, V>) => GroupBy.GroupBy<R, E, K, V>,
-  <R, E, K, V>(self: GroupBy.GroupBy<R, E, K, V>, n: number) => GroupBy.GroupBy<R, E, K, V>
->(2, <R, E, K, V>(self: GroupBy.GroupBy<R, E, K, V>, n: number): GroupBy.GroupBy<R, E, K, V> =>
+  (n: number) => <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>) => GroupBy.GroupBy<K, V, E, R>,
+  <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, n: number) => GroupBy.GroupBy<K, V, E, R>
+>(2, <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, n: number): GroupBy.GroupBy<K, V, E, R> =>
   make(
     pipe(
       stream.zipWithIndex(self.grouped),
@@ -112,9 +112,9 @@ export const first = dual<
   ))
 
 /** @internal */
-export const make = <R, E, K, V>(
+export const make = <K, V, E, R>(
   grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
-): GroupBy.GroupBy<R, E, K, V> => ({
+): GroupBy.GroupBy<K, V, E, R> => ({
   [GroupByTypeId]: groupByVariance,
   pipe() {
     return pipeArguments(this, arguments)
@@ -126,28 +126,28 @@ export const make = <R, E, K, V>(
 
 /** @internal */
 export const groupBy = dual<
-  <A, R2, E2, K, V>(
+  <A, K, V, E2, R2>(
     f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>,
-  <R, E, A, R2, E2, K, V>(
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<K, V, E2 | E, R2 | R>,
+  <A, E, R, K, V, E2, R2>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>
+  ) => GroupBy.GroupBy<K, V, E2 | E, R2 | R>
 >(
   (args) => stream.isStream(args[0]),
-  <R, E, A, R2, E2, K, V>(
+  <A, E, R, K, V, E2, R2>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ): GroupBy.GroupBy<R | R2, E | E2, K, V> =>
+  ): GroupBy.GroupBy<K, V, E | E2, R | R2> =>
     make(
       stream.unwrapScoped(
         Effect.gen(function*($) {
@@ -209,23 +209,23 @@ export const groupBy = dual<
 /** @internal */
 export const mapEffectOptions = dual<
   {
-    <A, R2, E2, A2>(
+    <A, A2, E2, R2>(
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options?: {
         readonly concurrency?: number | "unbounded" | undefined
         readonly unordered?: boolean | undefined
       }
-    ): <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
-    <A, R2, E2, A2, K>(
+    ): <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
+    <A, A2, E2, R2, K>(
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options: {
         readonly key: (a: A) => K
         readonly bufferSize?: number | undefined
       }
-    ): <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
+    ): <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
   },
   {
-    <R, E, A, R2, E2, A2>(
+    <A, E, R, A2, E2, R2>(
       self: Stream.Stream<A, E, R>,
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options?: {
@@ -233,7 +233,7 @@ export const mapEffectOptions = dual<
         readonly unordered?: boolean | undefined
       }
     ): Stream.Stream<A2, E2 | E, R2 | R>
-    <R, E, A, R2, E2, A2, K>(
+    <A, E, R, A2, E2, R2, K>(
       self: Stream.Stream<A, E, R>,
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options: {
@@ -244,7 +244,7 @@ export const mapEffectOptions = dual<
   }
 >(
   (args) => typeof args[0] !== "function",
-  (<R, E, A, R2, E2, A2, K>(
+  (<A, E, R, A2, E2, R2, K>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<A2, E2, R2>,
     options?: {
@@ -274,19 +274,19 @@ export const mapEffectOptions = dual<
 
 /** @internal */
 export const bindEffect = dual<
-  <N extends string, K, R2, E2, A>(
+  <N extends string, K, A, E2, R2>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => Effect.Effect<A, E2, R2>,
     options?: {
       readonly concurrency?: number | "unbounded" | undefined
       readonly bufferSize?: number | undefined
     }
-  ) => <R, E>(self: Stream.Stream<K, E, R>) => Stream.Stream<
-    Effect.MergeRecord<K, { [k in N]: A }>,
+  ) => <E, R>(self: Stream.Stream<K, E, R>) => Stream.Stream<
+    MergeRecord<K, { [k in N]: A }>,
     E | E2,
     R | R2
   >,
-  <R, E, N extends string, K, R2, E2, A>(
+  <K, E, R, N extends string, A, E2, R2>(
     self: Stream.Stream<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => Effect.Effect<A, E2, R2>,
@@ -295,11 +295,11 @@ export const bindEffect = dual<
       readonly unordered?: boolean | undefined
     }
   ) => Stream.Stream<
-    Effect.MergeRecord<K, { [k in N]: A }>,
+    MergeRecord<K, { [k in N]: A }>,
     E | E2,
     R | R2
   >
->((args) => typeof args[0] !== "string", <R, E, N extends string, K, R2, E2, A>(
+>((args) => typeof args[0] !== "string", <K, E, R, N extends string, A, E2, R2>(
   self: Stream.Stream<K, E, R>,
   tag: Exclude<N, keyof K>,
   f: (_: K) => Effect.Effect<A, E2, R2>,
@@ -311,7 +311,7 @@ export const bindEffect = dual<
   mapEffectOptions(self, (k) =>
     Effect.map(
       f(k),
-      (a): Effect.MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
+      (a): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
     ), options))
 
 const mapDequeue = <A, B>(dequeue: Queue.Dequeue<A>, f: (a: A) => B): Queue.Dequeue<B> => new MapDequeue(dequeue, f)
@@ -399,23 +399,23 @@ export const groupByKey = dual<
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<R, E, K, A>,
-  <R, E, A, K>(
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<K, A, E, R>,
+  <A, E, R, K>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => K,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => GroupBy.GroupBy<R, E, K, A>
+  ) => GroupBy.GroupBy<K, A, E, R>
 >(
   (args) => typeof args[0] !== "function",
-  <R, E, A, K>(
+  <A, E, R, K>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => K,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ): GroupBy.GroupBy<R, E, K, A> => {
+  ): GroupBy.GroupBy<K, A, E, R> => {
     const loop = (
       map: Map<K, Queue.Queue<Take.Take<A, E>>>,
       outerQueue: Queue.Queue<Take.Take<readonly [K, Queue.Queue<Take.Take<A, E>>], E>>

package/src/internal/hashMap.ts

@@ -47,12 +47,12 @@ const HashMapProto: HM.HashMap<unknown, unknown> = {
   [Symbol.iterator]<K, V>(this: HashMapImpl<K, V>): Iterator<[K, V]> {
     return new HashMapIterator(this, (k, v) => [k, v])
   },
-  [Hash.symbol](): number {
+  [Hash.symbol](this: HM.HashMap<unknown, unknown>): number {
     let hash = Hash.hash(HashMapSymbolKey)
     for (const item of this) {
       hash ^= pipe(Hash.hash(item[0]), Hash.combine(Hash.hash(item[1])))
     }
-    return hash
+    return Hash.cached(this, hash)
   },
   [Equal.symbol]<K, V>(this: HashMapImpl<K, V>, that: unknown): boolean {
     if (isHashMap(that)) {

package/src/internal/hashSet.ts

@@ -26,7 +26,10 @@ const HashSetProto: Omit<HashSetImpl<unknown>, "_keyMap"> = {
     return HM.keys(this._keyMap)
   },
   [Hash.symbol]<A>(this: HashSetImpl<A>): number {
-    return Hash.combine(Hash.hash(this._keyMap))(Hash.hash(HashSetSymbolKey))
+    return Hash.cached(
+      this,
+      Hash.combine(Hash.hash(this._keyMap))(Hash.hash(HashSetSymbolKey))
+    )
   },
   [Equal.symbol]<A>(this: HashSetImpl<A>, that: unknown): boolean {
     if (isHashSet(that)) {

package/src/internal/keyedPool.ts

@@ -62,7 +62,8 @@ class Complete<in out A, out E> implements Equal.Equal {
   [Hash.symbol](): number {
     return pipe(
       Hash.string("effect/KeyedPool/Complete"),
-      Hash.combine(Hash.hash(this.pool))
+      Hash.combine(Hash.hash(this.pool)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](u: unknown): boolean {
@@ -80,7 +81,8 @@ class Pending<in out A, in out E> implements Equal.Equal {
   [Hash.symbol](): number {
     return pipe(
       Hash.string("effect/KeyedPool/Pending"),
-      Hash.combine(Hash.hash(this.deferred))
+      Hash.combine(Hash.hash(this.deferred)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](u: unknown): boolean {

package/src/internal/layer/circular.ts

@@ -81,10 +81,10 @@ export const replaceLogger = dual<
 
 /** @internal */
 export const replaceLoggerEffect = dual<
-  <R, E, B>(
+  <B, E, R>(
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => <A>(self: Logger.Logger<unknown, A>) => Layer.Layer<never, E, R>,
-  <A, R, E, B>(
+  <A, B, E, R>(
     self: Logger.Logger<unknown, A>,
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => Layer.Layer<never, E, R>
@@ -92,10 +92,10 @@ export const replaceLoggerEffect = dual<
 
 /** @internal */
 export const replaceLoggerScoped = dual<
-  <R, E, B>(
+  <B, E, R>(
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => <A>(self: Logger.Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>,
-  <A, R, E, B>(
+  <A, B, E, R>(
     self: Logger.Logger<unknown, A>,
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => Layer.Layer<never, E, Exclude<R, Scope>>