effect 3.14.22 → 3.15.1

package/src/Either.ts

@@ -1614,3 +1614,110 @@ export const transposeOption = <A = never, E = never>(
 ): Either<Option<A>, E> => {
   return option_.isNone(self) ? right(option_.none) : map(self.value, option_.some)
 }
+
+/**
+ * Applies an `Either` on an `Option` and transposes the result.
+ *
+ * **Details**
+ *
+ * If the `Option` is `None`, the resulting `Either` will immediately succeed with a `Right` value of `None`.
+ * If the `Option` is `Some`, the transformation function will be applied to the inner value, and its result wrapped in a `Some`.
+ *
+ * @example
+ * ```ts
+ * import { Either, Option, pipe } from "effect"
+ *
+ * //          ┌─── Either<Option<number>, never>>
+ * //          ▼
+ * const noneResult = pipe(
+ *   Option.none(),
+ *   Either.transposeMapOption(() => Either.right(42)) // will not be executed
+ * )
+ * console.log(noneResult)
+ * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'None' } }
+ *
+ * //          ┌─── Either<Option<number>, never>>
+ * //          ▼
+ * const someRightResult = pipe(
+ *   Option.some(42),
+ *   Either.transposeMapOption((value) => Either.right(value * 2))
+ * )
+ * console.log(someRightResult)
+ * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'Some', value: 84 } }
+ * ```
+ *
+ * @since 3.15.0
+ * @category Optional Wrapping & Unwrapping
+ */
+export const transposeMapOption = dual<
+  /**
+   * Applies an `Either` on an `Option` and transposes the result.
+   *
+   * **Details**
+   *
+   * If the `Option` is `None`, the resulting `Either` will immediately succeed with a `Right` value of `None`.
+   * If the `Option` is `Some`, the transformation function will be applied to the inner value, and its result wrapped in a `Some`.
+   *
+   * @example
+   * ```ts
+   * import { Either, Option, pipe } from "effect"
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const noneResult = pipe(
+   *   Option.none(),
+   *   Either.transposeMapOption(() => Either.right(42)) // will not be executed
+   * )
+   * console.log(noneResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'None' } }
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const someRightResult = pipe(
+   *   Option.some(42),
+   *   Either.transposeMapOption((value) => Either.right(value * 2))
+   * )
+   * console.log(someRightResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'Some', value: 84 } }
+   * ```
+   *
+   * @since 3.15.0
+   * @category Optional Wrapping & Unwrapping
+   */
+  <A, B, E = never>(f: (self: A) => Either<B, E>) => (self: Option<A>) => Either<Option<B>, E>,
+  /**
+   * Applies an `Either` on an `Option` and transposes the result.
+   *
+   * **Details**
+   *
+   * If the `Option` is `None`, the resulting `Either` will immediately succeed with a `Right` value of `None`.
+   * If the `Option` is `Some`, the transformation function will be applied to the inner value, and its result wrapped in a `Some`.
+   *
+   * @example
+   * ```ts
+   * import { Either, Option, pipe } from "effect"
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const noneResult = pipe(
+   *   Option.none(),
+   *   Either.transposeMapOption(() => Either.right(42)) // will not be executed
+   * )
+   * console.log(noneResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'None' } }
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const someRightResult = pipe(
+   *   Option.some(42),
+   *   Either.transposeMapOption((value) => Either.right(value * 2))
+   * )
+   * console.log(someRightResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'Some', value: 84 } }
+   * ```
+   *
+   * @since 3.15.0
+   * @category Optional Wrapping & Unwrapping
+   */
+  <A, B, E = never>(self: Option<A>, f: (self: A) => Either<B, E>) => Either<Option<B>, E>
+>(2, (self, f) => option_.isNone(self) ? right(option_.none) : map(f(self.value), option_.some))

package/src/Function.ts

@@ -293,7 +293,7 @@ export const dual: {
   }
 }
 /**
- * Apply a function to a given value.
+ * Apply a function to given values.
  *
  * @example
  * ```ts
@@ -306,7 +306,7 @@ export const dual: {
  *
  * @since 2.0.0
  */
-export const apply = <A>(a: A) => <B>(self: (a: A) => B): B => self(a)
+export const apply = <A extends ReadonlyArray<unknown>>(...a: A) => <B>(self: (...a: A) => B): B => self(...a)
 
 /**
  * A lazy argument.

package/src/Layer.ts

@@ -32,9 +32,11 @@ import * as fiberRuntime from "./internal/fiberRuntime.js"
 import * as internal from "./internal/layer.js"
 import * as circularLayer from "./internal/layer/circular.js"
 import * as query from "./internal/query.js"
+import { randomTag } from "./internal/random.js"
 import type { LogLevel } from "./LogLevel.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Random from "./Random.js"
 import type * as Request from "./Request.js"
 import type * as Runtime from "./Runtime.js"
 import type * as Schedule from "./Schedule.js"
@@ -1280,6 +1282,15 @@ export const setConfigProvider: (configProvider: ConfigProvider) => Layer<never>
  */
 export const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSpan> = circularLayer.parentSpan
 
+/**
+ * @since 3.15.0
+ * @category Random
+ */
+export const setRandom = <A extends Random.Random>(random: A): Layer<never> =>
+  scopedDiscard(
+    fiberRuntime.fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(randomTag, random))
+  )
+
 /**
  * @since 2.0.0
  * @category requests & batching

package/src/MutableHashMap.ts

@@ -102,7 +102,7 @@ class BucketIterator<K, V> implements Iterator<[K, V]> {
  * @since 2.0.0
  * @category constructors
  */
-export const empty = <K, V>(): MutableHashMap<K, V> => {
+export const empty = <K = never, V = never>(): MutableHashMap<K, V> => {
   const self = Object.create(MutableHashMapProto)
   self.referential = new Map()
   self.buckets = new Map()

package/src/MutableList.ts

@@ -97,7 +97,7 @@ const makeNode = <T>(value: T): LinkedListNode<T> => ({
  * @since 2.0.0
  * @category constructors
  */
-export const empty = <A>(): MutableList<A> => {
+export const empty = <A = never>(): MutableList<A> => {
   const list = Object.create(MutableListProto)
   list.head = undefined
   list.tail = undefined

package/src/Pipeable.ts

@@ -2,9 +2,11 @@
  * @since 2.0.0
  */
 
+import type { Ctor } from "./Types.js"
+
 /**
  * @since 2.0.0
- * @category models
+ * @category Models
  */
 export interface Pipeable {
   pipe<A>(this: A): A
@@ -522,3 +524,51 @@ export const pipeArguments = <A>(self: A, args: IArguments): unknown => {
     }
   }
 }
+
+/**
+ * @since 3.15.0
+ * @category Models
+ */
+export interface PipeableConstructor {
+  new(...args: Array<any>): Pipeable
+}
+
+/**
+ * @since 3.15.0
+ * @category Prototypes
+ */
+export const Prototype: Pipeable = {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const Base: PipeableConstructor = (function() {
+  function PipeableBase() {}
+  PipeableBase.prototype = Prototype
+  return PipeableBase as any
+})()
+
+/**
+ * @since 3.15.0
+ * @category Constructors
+ */
+export const Class: {
+  /**
+   * @since 3.15.0
+   * @category Constructors
+   */
+  (): PipeableConstructor
+  /**
+   * @since 3.15.0
+   * @category Constructors
+   */
+  <TBase extends Ctor>(klass: TBase): TBase & PipeableConstructor
+} = (klass?: Ctor) =>
+  klass ?
+    class extends klass {
+      pipe() {
+        return pipeArguments(this, arguments)
+      }
+    }
+    : Base

package/src/Record.ts

@@ -1883,3 +1883,123 @@ export const getEquivalence = <K extends string, A>(
 export const singleton = <K extends string | symbol, A>(key: K, value: A): Record<K, A> => ({
   [key]: value
 } as any)
+
+/**
+ * Returns the first entry that satisfies the specified
+ * predicate, or `None` if no such entry exists.
+ *
+ * @example
+ * ```ts
+ * import { Record, Option } from "effect"
+ *
+ * const record = { a: 1, b: 2, c: 3 }
+ * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+ * console.log(result) // Option.Some(["c", 3])
+ * ```
+ *
+ * @category elements
+ * @since 3.14.0
+ */
+export const findFirst: {
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V, V2 extends V>(refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2): (self: Record<K, V>) => Option.Option<[K, V2]>
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: Record<K, V>) => Option.Option<[K, V]>
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V, V2 extends V>(
+    self: Record<K, V>,
+    refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2
+  ): Option.Option<[K, V2]>
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V>(
+    self: Record<K, V>,
+    predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean
+  ): Option.Option<[K, V]>
+} = dual(
+  2,
+  <K extends string | symbol, V>(self: Record<K, V>, f: (value: V, key: K) => boolean) => {
+    for (const a of Object.entries</**
+     * Returns the first entry that satisfies the specified
+     * predicate, or `None` if no such entry exists.
+     *
+     * @example
+     * ```ts
+     * import { Record, Option } from "effect"
+     *
+     * const record = { a: 1, b: 2, c: 3 }
+     * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+     * console.log(result) // Option.Some(["c", 3])
+     * ```
+     *
+     * @category elements
+     * @since 3.14.0
+     */
+    V>(self)) {
+      const o = f(a[1], a[0] as K)
+      if (o) {
+        return Option.some(a)
+      }
+    }
+    return Option.none()
+  }
+)

package/src/Stream.ts

@@ -9651,6 +9651,46 @@ export const toReadableStreamRuntime: {
   ): ReadableStream<A>
 } = internal.toReadableStreamRuntime
 
+/**
+ * Converts the stream to a `AsyncIterable` using the provided runtime.
+ *
+ * @since 3.15.0
+ * @category destructors
+ */
+export const toAsyncIterableRuntime: {
+  /**
+   * Converts the stream to a `AsyncIterable` using the provided runtime.
+   *
+   * @since 3.15.0
+   * @category destructors
+   */
+  <A, XR>(runtime: Runtime<XR>): <E, R extends XR>(self: Stream<A, E, R>) => AsyncIterable<A>
+  /**
+   * Converts the stream to a `AsyncIterable` using the provided runtime.
+   *
+   * @since 3.15.0
+   * @category destructors
+   */
+  <A, E, XR, R extends XR>(self: Stream<A, E, R>, runtime: Runtime<XR>): AsyncIterable<A>
+} = internal.toAsyncIterableRuntime
+
+/**
+ * Converts the stream to a `AsyncIterable` capturing the required dependencies.
+ *
+ * @since 3.15.0
+ * @category destructors
+ */
+export const toAsyncIterableEffect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<AsyncIterable<A>, never, R> =
+  internal.toAsyncIterableEffect
+
+/**
+ * Converts the stream to a `AsyncIterable`.
+ *
+ * @since 3.15.0
+ * @category destructors
+ */
+export const toAsyncIterable: <A, E>(self: Stream<A, E>) => AsyncIterable<A> = internal.toAsyncIterable
+
 /**
  * Applies the transducer to the stream and emits its outputs.
  *

package/src/Types.ts

@@ -144,6 +144,14 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
 >() => T extends Y ? 1 : 2 ? true
   : false
 
+/**
+ * Determines if two types are equal, allowing to specify the return types.
+ *
+ * @since 3.15.0
+ * @category models
+ */
+export type EqualsWith<A, B, Y, N> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Y : N
+
 /**
  * Determines if a record contains any of the given keys.
  *
@@ -336,3 +344,8 @@ export type NotFunction<T> = T extends Function ? never : T
  * @since 3.9.0
  */
 export type NoExcessProperties<T, U> = T & { readonly [K in Exclude<keyof U, keyof T>]: never }
+
+/**
+ * @since 3.15.0
+ */
+export type Ctor<T = {}> = new(...args: Array<any>) => T

package/src/internal/configError.ts

@@ -32,6 +32,12 @@ export const And = (self: ConfigError.ConfigError, that: ConfigError.ConfigError
       return `${this.left} and ${this.right}`
     }
   })
+  Object.defineProperty(error, "message", {
+    enumerable: false,
+    get(this: ConfigError.And) {
+      return this.toString()
+    }
+  })
   return error
 }
 
@@ -47,6 +53,12 @@ export const Or = (self: ConfigError.ConfigError, that: ConfigError.ConfigError)
       return `${this.left} or ${this.right}`
     }
   })
+  Object.defineProperty(error, "message", {
+    enumerable: false,
+    get(this: ConfigError.Or) {
+      return this.toString()
+    }
+  })
   return error
 }
 

package/src/internal/core-effect.ts

@@ -237,21 +237,36 @@ export const catchSomeDefect = dual<
 
 /* @internal */
 export const catchTag = dual<
-  <K extends (E extends { _tag: string } ? E["_tag"] : never), E, A1, E1, R1>(
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A1, Exclude<E, { _tag: K }> | E1, R | R1>,
-  <A, E, R, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1, A1>(
+  <E, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, A1, E1, R1>(
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>,
+  <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
     self: Effect.Effect<A, E, R>,
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ) => Effect.Effect<A | A1, Exclude<E, { _tag: K }> | E1, R | R1>
->(3, <A, E, R, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1, A1>(
-  self: Effect.Effect<A, E, R>,
-  k: K,
-  f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-): Effect.Effect<A | A1, Exclude<E, { _tag: K }> | E1, R | R1> =>
-  core.catchIf(self, Predicate.isTagged(k) as Predicate.Refinement<E, Extract<E, { _tag: K }>>, f) as any)
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
+>(
+  (args: any) => core.isEffect(args[0]),
+  <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
+    self: Effect.Effect<A, E, R>,
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ): Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1> => {
+    const f = args[args.length - 1] as any
+    let predicate: Predicate.Predicate<E>
+    if (args.length === 2) {
+      predicate = Predicate.isTagged(args[0] as string)
+    } else {
+      predicate = (e) => {
+        const tag = Predicate.hasProperty(e, "_tag") ? e["_tag"] : undefined
+        if (!tag) return false
+        for (let i = 0; i < args.length - 1; i++) {
+          if (args[i] === tag) return true
+        }
+        return false
+      }
+    }
+    return core.catchIf(self, predicate as Predicate.Refinement<E, Extract<E, { _tag: K[number] }>>, f) as any
+  }
+)
 
 /** @internal */
 export const catchTags: {
@@ -507,7 +522,7 @@ export const filterMap = dual<
 export const filterOrDie: {
   <A, B extends A>(
     refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-    orDieWith: (a: Types.NoInfer<A>) => unknown
+    orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
   <A>(
     predicate: Predicate.Predicate<Types.NoInfer<A>>,
@@ -516,7 +531,7 @@ export const filterOrDie: {
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<A, B>,
-    orDieWith: (a: A) => unknown
+    orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): Effect.Effect<B, E, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
@@ -547,7 +562,11 @@ export const filterOrDieMessage: {
     refinement: Predicate.Refinement<A, B>,
     message: string
   ): Effect.Effect<B, E, R>
-  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<A>, message: string): Effect.Effect<A, E, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    message: string
+  ): Effect.Effect<A, E, R>
 } = dual(
   3,
   <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<A>, message: string): Effect.Effect<A, E, R> =>
@@ -556,24 +575,24 @@ export const filterOrDieMessage: {
 
 /* @internal */
 export const filterOrElse: {
-  <A, B extends A, C, E2, R2>(
+  <A, C, E2, R2, B extends A>(
     refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-    orElse: (a: Types.NoInfer<A>) => Effect.Effect<C, E2, R2>
+    orElse: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => Effect.Effect<C, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
-  <A, B, E2, R2>(
+  <A, C, E2, R2>(
     predicate: Predicate.Predicate<Types.NoInfer<A>>,
-    orElse: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | B, E2 | E, R2 | R>
-  <A, E, R, B extends A, C, E2, R2>(
+    orElse: (a: Types.NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | C, E2 | E, R2 | R>
+  <A, E, R, C, E2, R2, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<A, B>,
-    orElse: (a: A) => Effect.Effect<C, E2, R2>
+    orElse: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => Effect.Effect<C, E2, R2>
   ): Effect.Effect<B | C, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(
+  <A, E, R, C, E2, R2>(
     self: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<A>,
-    orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, E | E2, R | R2>
+    orElse: (a: A) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<A | C, E | E2, R | R2>
 } = dual(3, <A, E, R, B, E2, R2>(
   self: Effect.Effect<A, E, R>,
   predicate: Predicate.Predicate<A>,
@@ -586,63 +605,51 @@ export const filterOrElse: {
 
 /** @internal */
 export const liftPredicate = dual<
-  {
-    <A, B extends A, E>(
-      refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-      orFailWith: (a: Types.NoInfer<A>) => E
-    ): (a: A) => Effect.Effect<B, E>
-    <A, E>(
-      predicate: Predicate.Predicate<Types.NoInfer<A>>,
-      orFailWith: (a: Types.NoInfer<A>) => E
-    ): (a: A) => Effect.Effect<A, E>
-  },
-  {
-    <A, E, B extends A>(
-      self: A,
-      refinement: Predicate.Refinement<A, B>,
-      orFailWith: (a: A) => E
-    ): Effect.Effect<B, E>
-    <A, E>(
-      self: A,
-      predicate: Predicate.Predicate<Types.NoInfer<A>>,
-      orFailWith: (a: Types.NoInfer<A>) => E
-    ): Effect.Effect<A, E>
-  }
+  <T extends A, E, B extends T = T, A = T>(
+    predicate: Predicate.Refinement<T, B> | Predicate.Predicate<T>,
+    orFailWith: (a: Types.EqualsWith<T, B, A, Exclude<A, B>>) => E
+  ) => (a: A) => Effect.Effect<Types.EqualsWith<T, B, A, B>, E>,
+  <A, E, B extends A = A>(
+    self: A,
+    predicate: Predicate.Refinement<A, B> | Predicate.Predicate<A>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E
+  ) => Effect.Effect<B, E>
 >(
   3,
-  <A, E>(
+  <A, E, B extends A = A>(
     self: A,
-    predicate: Predicate.Predicate<Types.NoInfer<A>>,
-    orFailWith: (a: Types.NoInfer<A>) => E
-  ): Effect.Effect<A, E> => core.suspend(() => predicate(self) ? core.succeed(self) : core.fail(orFailWith(self)))
+    predicate: Predicate.Refinement<A, B> | Predicate.Predicate<A>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E
+  ): Effect.Effect<B, E> =>
+    core.suspend(() => predicate(self) ? core.succeed(self as B) : core.fail(orFailWith(self as any)))
 )
 
 /* @internal */
 export const filterOrFail: {
-  <A, B extends A, E2>(
+  <A, E2, B extends A>(
     refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-    orFailWith: (a: Types.NoInfer<A>) => E2
+    orFailWith: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
   <A, E2>(
     predicate: Predicate.Predicate<Types.NoInfer<A>>,
     orFailWith: (a: Types.NoInfer<A>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
-  <A, B extends A>(
-    refinement: Predicate.Refinement<Types.NoInfer<A>, B>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementException | E, R>
-  <A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementException | E, R>
-  <A, E, R, B extends A, E2>(
+  <A, E, R, E2, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<A, B>,
-    orFailWith: (a: A) => E2
-  ): Effect.Effect<B, E | E2, R>
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E2
+  ): Effect.Effect<B, E2 | E, R>
   <A, E, R, E2>(
     self: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
-  ): Effect.Effect<A, E | E2, R>
+  ): Effect.Effect<A, E2 | E, R>
+  <A, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementException | E, R>
+  <A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementException | E, R>
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<A, B>