effect 2.1.2 → 2.2.1

package/src/Stream.ts

@@ -29,7 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -115,9 +115,9 @@ export declare namespace Stream {
    */
   export interface Variance<out R, out E, out A> {
     readonly [StreamTypeId]: {
-      _R: Types.Covariant<R>
-      _E: Types.Covariant<E>
-      _A: Types.Covariant<A>
+      _R: Covariant<R>
+      _E: Covariant<E>
+      _A: Covariant<A>
     }
   }
 
@@ -995,7 +995,7 @@ export const dropRight: {
  * @category utils
  */
 export const dropUntil: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.dropUntil
 
@@ -1007,12 +1007,12 @@ export const dropUntil: {
  * @category utils
  */
 export const dropUntilEffect: {
-  <A, X extends A, R2, E2>(
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.dropUntilEffect
 
@@ -1024,7 +1024,7 @@ export const dropUntilEffect: {
  * @category utils
  */
 export const dropWhile: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.dropWhile
 
@@ -1036,12 +1036,12 @@ export const dropWhile: {
  * @category utils
  */
 export const dropWhileEffect: {
-  <A, X extends A, R2, E2>(
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.dropWhileEffect
 
@@ -1175,8 +1175,8 @@ export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<nev
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.filter
@@ -1188,12 +1188,12 @@ export const filter: {
  * @category filtering
  */
 export const filterEffect: {
-  <A, X extends A, R2, E2>(
-    f: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    f: (a: X) => Effect.Effect<R2, E2, boolean>
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.filterEffect
 
@@ -1270,8 +1270,8 @@ export const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) => Stream<
  * @category elements
  */
 export const find: {
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.find
@@ -1284,12 +1284,12 @@ export const find: {
  * @category elements
  */
 export const findEffect: {
-  <A, X extends A, R2, E2>(
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.findEffect
 
@@ -2480,7 +2480,7 @@ export const paginateEffect: <S, R, E, A>(
  */
 export const partition: {
   <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>,
+    refinement: Refinement<NoInfer<A>, B>,
     options?: {
       bufferSize?: number | undefined
     }
@@ -2520,7 +2520,7 @@ export const partition: {
  */
 export const partitionEither: {
   <A, R2, E2, A2, A3>(
-    predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
     options?: {
       readonly bufferSize?: number | undefined
     }
@@ -3527,7 +3527,7 @@ export const someOrFail: {
  * @category utils
  */
 export const split: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, Chunk.Chunk<B>>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>
 } = internal.split
 
@@ -3605,7 +3605,7 @@ export const takeRight: {
  * @category utils
  */
 export const takeUntil: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.takeUntil
 
@@ -3618,7 +3618,7 @@ export const takeUntil: {
  */
 export const takeUntilEffect: {
   <A, R2, E2>(
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
   <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
@@ -3634,8 +3634,8 @@ export const takeUntilEffect: {
  * @category utils
  */
 export const takeWhile: {
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.takeWhile
@@ -3647,12 +3647,12 @@ export const takeWhile: {
  * @category sequencing
  */
 export const tap: {
-  <A, X extends A, R2, E2, _>(
-    f: (a: X) => Effect.Effect<R2, E2, _>
+  <A, R2, E2, _>(
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2, _>(
+  <R, E, A, R2, E2, _>(
     self: Stream<R, E, A>,
-    f: (a: X) => Effect.Effect<R2, E2, _>
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>
   ): Stream<R | R2, E | E2, A>
 } = internal.tap
 
@@ -3664,17 +3664,17 @@ export const tap: {
  * @category sequencing
  */
 export const tapBoth: {
-  <E, XE extends E, A, XA extends A, R2, E2, X, R3, E3, X1>(
+  <E, R2, E2, X1, A, R3, E3, X2>(
     options: {
-      readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>
-      readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>
+      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>
+      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>
     }
   ): <R>(self: Stream<R, E, A>) => Stream<R | R2 | R3, E | E2 | E3, A>
-  <R, E, A, XE extends E, XA extends A, R2, E2, X, R3, E3, X1>(
+  <R, E, A, R2, E2, X1, R3, E3, X2>(
     self: Stream<R, E, A>,
     options: {
-      readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>
-      readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>
+      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>
+      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>
     }
   ): Stream<R | R2 | R3, E | E2 | E3, A>
 } = internal.tapBoth
@@ -3686,12 +3686,12 @@ export const tapBoth: {
  * @category sequencing
  */
 export const tapError: {
-  <E, X extends E, R2, E2, _>(
-    f: (error: X) => Effect.Effect<R2, E2, _>
+  <E, R2, E2, _>(
+    f: (error: NoInfer<E>) => Effect.Effect<R2, E2, _>
   ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>
-  <R, A, E, X extends E, R2, E2, _>(
+  <R, A, E, R2, E2, _>(
     self: Stream<R, E, A>,
-    f: (error: X) => Effect.Effect<R2, E2, _>
+    f: (error: E) => Effect.Effect<R2, E2, _>
   ): Stream<R | R2, E | E2, A>
 } = internal.tapError
 
@@ -3703,12 +3703,12 @@ export const tapError: {
  * @category utils
  */
 export const tapErrorCause: {
-  <E, X extends E, R2, E2, _>(
-    f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>
+  <E, R2, E2, _>(
+    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<R2, E2, _>
   ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>
-  <R, A, E, X extends E, R2, E2, _>(
+  <R, A, E, R2, E2, _>(
     self: Stream<R, E, A>,
-    f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>
+    f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, _>
   ): Stream<R | R2, E | E2, A>
 } = internal.tapErrorCause
 

package/src/Trie.ts

@@ -20,7 +20,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as TR from "./internal/trie.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = TR.TrieTypeId as TypeId
 
@@ -36,7 +36,7 @@ export type TypeId = typeof TypeId
  */
 export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _Value: Types.Covariant<Value>
+    readonly _Value: Covariant<Value>
   }
 }
 
@@ -589,8 +589,8 @@ export const map: {
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(f: (a: A, k: string) => a is B): (self: Trie<A>) => Trie<B>
-  <B extends A, A = B>(f: (a: A, k: string) => boolean): (self: Trie<B>) => Trie<B>
+  <A, B extends A>(f: (a: NoInfer<A>, k: string) => a is B): (self: Trie<A>) => Trie<B>
+  <A>(f: (a: NoInfer<A>, k: string) => boolean): (self: Trie<A>) => Trie<A>
   <A, B extends A>(self: Trie<A>, f: (a: A, k: string) => a is B): Trie<B>
   <A>(self: Trie<A>, f: (a: A, k: string) => boolean): Trie<A>
 } = TR.filter

package/src/internal/cause.ts

@@ -9,11 +9,12 @@ import * as HashSet from "../HashSet.js"
 import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isFunction, type Predicate } from "../Predicate.js"
+import { hasProperty, isFunction } from "../Predicate.js"
+import type { Predicate, Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
-import * as OpCodes from "./opCodes/cause.js"
-
 import type { ParentSpan, Span } from "../Tracer.js"
+import type { NoInfer } from "../Types.js"
+import * as OpCodes from "./opCodes/cause.js"
 
 // -----------------------------------------------------------------------------
 // Models
@@ -643,10 +644,18 @@ export const find = dual<
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const filter = dual<
-  <E>(predicate: Predicate<Cause.Cause<E>>) => (self: Cause.Cause<E>) => Cause.Cause<E>,
-  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>) => Cause.Cause<E>
->(2, (self, predicate) => reduceWithContext(self, void 0, FilterCauseReducer(predicate)))
+export const filter: {
+  <E, EB extends E>(
+    refinement: Refinement<Cause.Cause<NoInfer<E>>, Cause.Cause<EB>>
+  ): (self: Cause.Cause<E>) => Cause.Cause<EB>
+  <E>(predicate: Predicate<Cause.Cause<NoInfer<E>>>): (self: Cause.Cause<E>) => Cause.Cause<E>
+  <E, EB extends E>(self: Cause.Cause<E>, refinement: Refinement<Cause.Cause<E>, Cause.Cause<EB>>): Cause.Cause<EB>
+  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>): Cause.Cause<E>
+} = dual(
+  2,
+  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>): Cause.Cause<E> =>
+    reduceWithContext(self, void 0, FilterCauseReducer(predicate))
+)
 
 // -----------------------------------------------------------------------------
 // Evaluation