effect 2.3.7 → 2.4.0

package/src/SingleProducerAsyncInput.ts

@@ -30,7 +30,7 @@ export interface SingleProducerAsyncInput<in out Err, in out Elem, in out Done>
   extends AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done>
 {
   readonly close: Effect.Effect<unknown>
-  readonly take: Effect.Effect<Exit.Exit<Elem, Either.Either<Err, Done>>>
+  readonly take: Effect.Effect<Exit.Exit<Elem, Either.Either<Done, Err>>>
 }
 
 /**

package/src/Sink.ts

@@ -378,12 +378,12 @@ export const dimap: {
  * @category mapping
  */
 export const dimapEffect: {
-  <In0, R2, E2, In, A, R3, E3, A2>(
+  <In0, In, E2, R2, A, A2, E3, R3>(
     options: {
       readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>
       readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ): <R, E, L>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>
+  ): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>
   <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
     self: Sink<A, In, L, E, R>,
     options: {
@@ -423,7 +423,7 @@ export const dimapChunksEffect: {
       readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
       readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ): <R, E, L>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>
+  ): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>
   <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
     self: Sink<A, In, L, E, R>,
     options: {
@@ -494,10 +494,10 @@ export const dropWhileEffect: <In, E, R>(
  * @category finalization
  */
 export const ensuring: {
-  <_, R2>(
-    finalizer: Effect.Effect<_, never, R2>
+  <X, R2>(
+    finalizer: Effect.Effect<X, never, R2>
   ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
-  <A, In, L, E, R, _, R2>(self: Sink<A, In, L, E, R>, finalizer: Effect.Effect<_, never, R2>): Sink<A, In, L, E, R | R2>
+  <A, In, L, E, R, X, R2>(self: Sink<A, In, L, E, R>, finalizer: Effect.Effect<X, never, R2>): Sink<A, In, L, E, R | R2>
 } = internal.ensuring
 
 /**
@@ -509,12 +509,12 @@ export const ensuring: {
  * @category finalization
  */
 export const ensuringWith: {
-  <A, E, _, R2>(
-    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>
+  <A, E, X, R2>(
+    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>
   ): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>
-  <A, In, L, E, R, _, R2>(
+  <A, In, L, E, R, X, R2>(
     self: Sink<A, In, L, E, R>,
-    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>
+    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>
   ): Sink<A, In, L, E, R | R2>
 } = internal.ensuringWith
 
@@ -908,7 +908,7 @@ export const foldWeightedEffect: <S, In, E, R, E2, R2>(
  * @since 2.0.0
  * @category constructors
  */
-export const forEach: <In, _, E, R>(f: (input: In) => Effect.Effect<_, E, R>) => Sink<void, In, never, E, R> =
+export const forEach: <In, X, E, R>(f: (input: In) => Effect.Effect<X, E, R>) => Sink<void, In, never, E, R> =
   internal.forEach
 
 /**
@@ -918,8 +918,8 @@ export const forEach: <In, _, E, R>(f: (input: In) => Effect.Effect<_, E, R>) =>
  * @since 2.0.0
  * @category constructors
  */
-export const forEachChunk: <In, _, E, R>(
-  f: (input: Chunk.Chunk<In>) => Effect.Effect<_, E, R>
+export const forEachChunk: <In, X, E, R>(
+  f: (input: Chunk.Chunk<In>) => Effect.Effect<X, E, R>
 ) => Sink<void, In, never, E, R> = internal.forEachChunk
 
 /**
@@ -1012,13 +1012,13 @@ export const fromPubSub: <In>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromPush: <In, E, A, L, R>(
+export const fromPush: <In, L0, R0, L, R>(
   push: Effect.Effect<
-    (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<void, readonly [Either.Either<E, A>, Chunk.Chunk<L>], R>,
+    (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<void, readonly [Either.Either<R0, L0>, Chunk.Chunk<L>], R>,
     never,
     R
   >
-) => Sink<A, In, L, E, Exclude<R, Scope.Scope>> = internal.fromPush
+) => Sink<R0, In, L, L0, Exclude<R, Scope.Scope>> = internal.fromPush
 
 /**
  * Create a sink which enqueues each element into the specified queue.
@@ -1171,7 +1171,7 @@ export const provideContext: {
 export const race: {
   <R1, E1, In1, L1, A1>(
     that: Sink<A1, In1, L1, E1, R1>
-  ): <R, E, In, L, A>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>
+  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>
   <A, In, L, E, R, A1, In1, L1, E1, R1>(
     self: Sink<A, In, L, E, R>,
     that: Sink<A1, In1, L1, E1, R1>
@@ -1189,12 +1189,12 @@ export const raceBoth: {
   <A1, In1, L1, E1, R1>(
     that: Sink<A1, In1, L1, E1, R1>,
     options?: { readonly capacity?: number | undefined } | undefined
-  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Either.Either<A, A1>, In & In1, L1 | L, E1 | E, R1 | R>
+  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Either.Either<A1, A>, In & In1, L1 | L, E1 | E, R1 | R>
   <A, In, L, E, R, A1, In1, L1, E1, R1>(
     self: Sink<A, In, L, E, R>,
     that: Sink<A1, In1, L1, E1, R1>,
     options?: { readonly capacity?: number | undefined } | undefined
-  ): Sink<Either.Either<A, A1>, In & In1, L | L1, E | E1, R | R1>
+  ): Sink<Either.Either<A1, A>, In & In1, L | L1, E | E1, R | R1>
 } = internal.raceBoth
 
 /**

package/src/SortedMap.ts

@@ -41,7 +41,11 @@ const SortedMapProto: Omit<SortedMap<unknown, unknown>, "tree"> = {
     _V: (_: never) => _
   },
   [Hash.symbol]<K, V>(this: SortedMap<K, V>): number {
-    return pipe(Hash.hash(this.tree), Hash.combine(Hash.hash("effect/SortedMap")))
+    return pipe(
+      Hash.hash(this.tree),
+      Hash.combine(Hash.hash("effect/SortedMap")),
+      Hash.cached(this)
+    )
   },
   [Equal.symbol]<K, V>(this: SortedMap<K, V>, that: unknown): boolean {
     return isSortedMap(that) && Equal.equals(this.tree, that.tree)

package/src/SortedSet.ts

@@ -40,7 +40,11 @@ const SortedSetProto: Omit<SortedSet<unknown>, "keyTree"> = {
     _A: (_: any) => _
   },
   [Hash.symbol]<A>(this: SortedSet<A>): number {
-    return pipe(Hash.hash(this.keyTree), Hash.combine(Hash.hash(TypeId)))
+    return pipe(
+      Hash.hash(this.keyTree),
+      Hash.combine(Hash.hash(TypeId)),
+      Hash.cached(this)
+    )
   },
   [Equal.symbol]<A>(this: SortedSet<A>, that: unknown): boolean {
     return isSortedSet(that) && Equal.equals(this.keyTree, that.keyTree)