effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/Exit.ts

@@ -857,10 +857,12 @@ export const map: {
  * **Example** (Mapping over an error)
  *
  * ```ts
- * import { Exit } from "effect"
+ * import { Data, Exit } from "effect"
+ *
+ * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
  *
  * const exit = Exit.fail("bad input")
- * const mapped = Exit.mapError(exit, (e) => new Error(e))
+ * const mapped = Exit.mapError(exit, (e) => new ExitError({ input: e }))
  * console.log(Exit.isFailure(mapped)) // true
  * ```
  *
@@ -884,10 +886,12 @@ export const mapError: {
    * **Example** (Mapping over an error)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.fail("bad input")
-   * const mapped = Exit.mapError(exit, (e) => new Error(e))
+   * const mapped = Exit.mapError(exit, (e) => new ExitError({ input: e }))
    * console.log(Exit.isFailure(mapped)) // true
    * ```
    *
@@ -911,10 +915,12 @@ export const mapError: {
    * **Example** (Mapping over an error)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.fail("bad input")
-   * const mapped = Exit.mapError(exit, (e) => new Error(e))
+   * const mapped = Exit.mapError(exit, (e) => new ExitError({ input: e }))
    * console.log(Exit.isFailure(mapped)) // true
    * ```
    *
@@ -941,12 +947,14 @@ export const mapError: {
  * **Example** (Mapping both channels)
  *
  * ```ts
- * import { Exit } from "effect"
+ * import { Data, Exit } from "effect"
+ *
+ * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
  *
  * const exit = Exit.succeed(42)
  * const mapped = Exit.mapBoth(exit, {
  *   onSuccess: (x) => String(x),
- *   onFailure: (e: string) => new Error(e)
+ *   onFailure: (e: string) => new ExitError({ input: e })
  * })
  * console.log(Exit.isSuccess(mapped) && mapped.value) // "42"
  * ```
@@ -972,12 +980,14 @@ export const mapBoth: {
    * **Example** (Mapping both channels)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.succeed(42)
    * const mapped = Exit.mapBoth(exit, {
    *   onSuccess: (x) => String(x),
-   *   onFailure: (e: string) => new Error(e)
+   *   onFailure: (e: string) => new ExitError({ input: e })
    * })
    * console.log(Exit.isSuccess(mapped) && mapped.value) // "42"
    * ```
@@ -1005,12 +1015,14 @@ export const mapBoth: {
    * **Example** (Mapping both channels)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.succeed(42)
    * const mapped = Exit.mapBoth(exit, {
    *   onSuccess: (x) => String(x),
-   *   onFailure: (e: string) => new Error(e)
+   *   onFailure: (e: string) => new ExitError({ input: e })
    * })
    * console.log(Exit.isSuccess(mapped) && mapped.value) // "42"
    * ```

package/src/Fiber.ts

@@ -81,7 +81,7 @@ import type { LogLevel } from "./LogLevel.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import type { StackFrame } from "./References.ts"
-import type { Scheduler } from "./Scheduler.ts"
+import type { Scheduler, SchedulerDispatcher } from "./Scheduler.ts"
 import type { Scope } from "./Scope.ts"
 import type * as ServiceMap from "./ServiceMap.ts"
 import type { AnySpan } from "./Tracer.ts"
@@ -123,11 +123,13 @@ export interface Fiber<out A, out E = never> extends Pipeable {
   readonly services: ServiceMap.ServiceMap<never>
   setServices(services: ServiceMap.ServiceMap<never>): void
   readonly currentScheduler: Scheduler
+  readonly currentDispatcher: SchedulerDispatcher
   readonly currentSpan?: AnySpan | undefined
   readonly currentLogLevel: LogLevel
   readonly minimumLogLevel: LogLevel
   readonly currentStackFrame?: StackFrame | undefined
   readonly maxOpsBeforeYield: number
+  readonly currentPreventYield: boolean
   readonly addObserver: (cb: (exit: Exit<A, E>) => void) => () => void
   readonly interruptUnsafe: (
     fiberId?: number | undefined,
@@ -338,7 +340,10 @@ export const interruptAs: {
    * @since 2.0.0
    * @category interruption
    */
-  (fiberId: number): <A, E>(self: Fiber<A, E>) => Effect<void>
+  (
+    fiberId: number | undefined,
+    annotations?: ServiceMap.ServiceMap<never> | undefined
+  ): <A, E>(self: Fiber<A, E>) => Effect<void>
   /**
    * Interrupts a fiber with a specific fiber ID as the interruptor. This allows
    * tracking which fiber initiated the interruption.
@@ -361,7 +366,11 @@ export const interruptAs: {
    * @since 2.0.0
    * @category interruption
    */
-  <A, E>(self: Fiber<A, E>, fiberId: number): Effect<void>
+  <A, E>(
+    self: Fiber<A, E>,
+    fiberId: number | undefined,
+    annotations?: ServiceMap.ServiceMap<never> | undefined
+  ): Effect<void>
 } = effect.fiberInterruptAs
 
 /**

package/src/FiberHandle.ts

@@ -10,6 +10,7 @@ import * as Filter from "./Filter.ts"
 import { dual } from "./Function.ts"
 import type * as Inspectable from "./Inspectable.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
+import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type { Scheduler } from "./Scheduler.ts"
@@ -467,20 +468,20 @@ export const set: {
  *
  *   // No fiber initially
  *   const emptyFiber = FiberHandle.getUnsafe(handle)
- *   console.log(emptyFiber === undefined) // true
+ *   console.log(emptyFiber._tag === "None") // true
  *
  *   // Add a fiber
  *   yield* FiberHandle.run(handle, Effect.succeed("hello"))
  *   const fiber = FiberHandle.getUnsafe(handle)
- *   console.log(fiber !== undefined) // true
+ *   console.log(fiber._tag === "Some") // true
  * })
  * ```
  *
  * @since 2.0.0
  * @category combinators
  */
-export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | undefined {
-  return self.state._tag === "Closed" ? undefined : self.state.fiber
+export function getUnsafe<A, E>(self: FiberHandle<A, E>): Option.Option<Fiber.Fiber<A, E>> {
+  return self.state._tag === "Closed" ? Option.none() : Option.fromUndefinedOr(self.state.fiber)
 }
 
 /**
@@ -496,10 +497,10 @@ export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | un
  *   // Add a fiber
  *   yield* FiberHandle.run(handle, Effect.succeed("hello"))
  *
- *   // Get the fiber (fails if no fiber)
+ *   // Get the current fiber if present
  *   const fiber = yield* FiberHandle.get(handle)
- *   if (fiber) {
- *     const result = yield* Fiber.await(fiber)
+ *   if (fiber._tag === "Some") {
+ *     const result = yield* Fiber.await(fiber.value)
  *     console.log(result) // "hello"
  *   }
  * })
@@ -508,7 +509,7 @@ export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | un
  * @since 2.0.0
  * @category combinators
  */
-export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.Fiber<A, E> | undefined> {
+export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>> {
   return Effect.suspend(() => Effect.succeed(getUnsafe(self)))
 }
 
@@ -528,7 +529,7 @@ export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.Fiber<A,
  *
  *   // The handle is now empty
  *   const fiber = FiberHandle.getUnsafe(handle)
- *   console.log(fiber) // undefined
+ *   console.log(fiber) // Option.none()
  * })
  * ```
  *

package/src/FiberMap.ts

@@ -500,8 +500,8 @@ export const set: {
  *
  *   // Retrieve the fiber
  *   const retrieved = FiberMap.getUnsafe(map, "greeting")
- *   if (retrieved) {
- *     const result = yield* Fiber.await(retrieved)
+ *   if (retrieved._tag === "Some") {
+ *     const result = yield* Fiber.await(retrieved.value)
  *     console.log(result) // "Hello"
  *   }
  * })
@@ -527,8 +527,8 @@ export const getUnsafe: {
    *
    *   // Retrieve the fiber
    *   const retrieved = FiberMap.getUnsafe(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -537,7 +537,7 @@ export const getUnsafe: {
    * @since 2.0.0
    * @category combinators
    */
-  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Fiber.Fiber<A, E> | undefined
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Option.Option<Fiber.Fiber<A, E>>
   /**
    * Retrieve a fiber from the FiberMap.
    *
@@ -554,8 +554,8 @@ export const getUnsafe: {
    *
    *   // Retrieve the fiber
    *   const retrieved = FiberMap.getUnsafe(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -564,18 +564,18 @@ export const getUnsafe: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Fiber.Fiber<A, E> | undefined
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.Fiber<A, E>>
 } = dual(
   2,
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Fiber.Fiber<A, E> | undefined => {
-    return self.state._tag === "Closed" ? undefined : Option.getOrUndefined(MutableHashMap.get(self.state.backing, key))
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.Fiber<A, E>> => {
+    return self.state._tag === "Closed" ? Option.none() : MutableHashMap.get(self.state.backing, key)
   }
 )
 
 /**
  * Retrieve a fiber from the FiberMap.
  *
- * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+ * Returns an `Option` wrapped in `Effect`.
  *
  * @example
  * ```ts
@@ -590,8 +590,8 @@ export const getUnsafe: {
  *
  *   // Retrieve the fiber with error handling
  *   const retrieved = yield* FiberMap.get(map, "greeting")
- *   if (retrieved) {
- *     const result = yield* Fiber.await(retrieved)
+ *   if (retrieved._tag === "Some") {
+ *     const result = yield* Fiber.await(retrieved.value)
  *     console.log(result) // "Hello"
  *   }
  * })
@@ -604,7 +604,7 @@ export const get: {
   /**
    * Retrieve a fiber from the FiberMap.
    *
-   * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+   * Returns an `Option` wrapped in `Effect`.
    *
    * @example
    * ```ts
@@ -619,8 +619,8 @@ export const get: {
    *
    *   // Retrieve the fiber with error handling
    *   const retrieved = yield* FiberMap.get(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -629,11 +629,11 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Fiber.Fiber<A, E> | undefined>
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>
   /**
    * Retrieve a fiber from the FiberMap.
    *
-   * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+   * Returns an `Option` wrapped in `Effect`.
    *
    * @example
    * ```ts
@@ -648,8 +648,8 @@ export const get: {
    *
    *   // Retrieve the fiber with error handling
    *   const retrieved = yield* FiberMap.get(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -658,10 +658,10 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Fiber.Fiber<A, E> | undefined>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>
 } = dual(
   2,
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Fiber.Fiber<A, E> | undefined> =>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>> =>
     Effect.suspend(() => Effect.succeed(getUnsafe(self, key)))
 )
 

package/src/FileSystem.ts

@@ -41,7 +41,9 @@ import * as Cause from "./Cause.ts"
 import * as Effect from "./Effect.ts"
 import { pipe } from "./Function.ts"
 import * as Layer from "./Layer.ts"
+import * as Option from "./Option.ts"
 import { badArgument, type PlatformError, systemError } from "./PlatformError.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Pull from "./Pull.ts"
 import type { Scope } from "./Scope.ts"
 import * as ServiceMap from "./ServiceMap.ts"
@@ -733,8 +735,7 @@ export const make = (
         Effect.as(true),
         Effect.catchTag(
           "PlatformError",
-          (e) =>
-            e.reason._tag === "SystemError" && e.reason.kind === "NotFound" ? Effect.succeed(false) : Effect.fail(e)
+          (e) => e.reason._tag === "NotFound" ? Effect.succeed(false) : Effect.fail(e)
         )
       ),
     readFileString: (path, encoding) =>
@@ -757,22 +758,24 @@ export const make = (
       const bytesToRead = options?.bytesToRead !== undefined ? Size(options.bytesToRead) : undefined
       let totalBytesRead = BigInt(0)
       const chunkSize = Size(options?.chunkSize ?? 64 * 1024)
+      const readChunk = file.readAlloc(chunkSize)
       return Stream.fromPull(Effect.succeed(
         Effect.flatMap(
-          Effect.suspend((): Pull.Pull<Uint8Array | undefined, PlatformError> => {
+          Effect.suspend((): Pull.Pull<Option.Option<Uint8Array>, PlatformError> => {
             if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
               return Cause.done()
             }
-            const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
-              ? bytesToRead - totalBytesRead
-              : chunkSize
-            return file.readAlloc(toRead)
+            return bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
+              ? file.readAlloc(bytesToRead - totalBytesRead)
+              : readChunk
           }),
-          (buf) => {
-            if (!buf) return Cause.done()
-            totalBytesRead += BigInt(buf.length)
-            return Effect.succeed(Arr.of(buf))
-          }
+          Option.match({
+            onNone: () => Cause.done(),
+            onSome: (buf) => {
+              totalBytesRead += BigInt(buf.length)
+              return Effect.succeed(Arr.of(buf))
+            }
+          })
         )
       ))
     }, Stream.unwrap),
@@ -802,7 +805,7 @@ const notFound = (method: string, path: string) =>
   systemError({
     module: "FileSystem",
     method,
-    kind: "NotFound",
+    _tag: "NotFound",
     description: "No such file or directory",
     pathOrDescriptor: path
   })
@@ -829,9 +832,9 @@ const notFound = (method: string, path: string) =>
  *     }
  *     return Effect.fail(
  *       PlatformError.systemError({
+ *         _tag: "NotFound",
  *         module: "FileSystem",
  *         method: "readFileString",
- *         kind: "NotFound",
  *         description: "File not found",
  *         pathOrDescriptor: path
  *       })
@@ -997,7 +1000,7 @@ export const FileTypeId = "~effect/platform/FileSystem/File"
  * @since 4.0.0
  * @category File
  */
-export const isFile = (u: unknown): u is File => typeof u === "object" && u !== null && FileTypeId in u
+export const isFile = (u: unknown): u is File => hasProperty(u, FileTypeId)
 
 /**
  * Interface representing an open file handle.
@@ -1047,7 +1050,7 @@ export interface File {
   readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
   readonly sync: Effect.Effect<void, PlatformError>
   readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError>
-  readonly readAlloc: (size: SizeInput) => Effect.Effect<Uint8Array | undefined, PlatformError>
+  readonly readAlloc: (size: SizeInput) => Effect.Effect<Option.Option<Uint8Array>, PlatformError>
   readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError>
   readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError>
   readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError>
@@ -1097,7 +1100,7 @@ export declare namespace File {
    *
    * @example
    * ```ts
-   * import { Console, Effect, FileSystem } from "effect"
+   * import { Console, Effect, FileSystem, Option } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   const fs = yield* FileSystem.FileSystem
@@ -1109,7 +1112,7 @@ export declare namespace File {
    *   yield* Console.log(`Mode: ${info.mode.toString(8)}`) // Octal permissions
    *
    *   // Handle optional timestamps
-   *   const mtime = info.mtime ?? new Date(0)
+   *   const mtime = Option.getOrElse(info.mtime, () => new Date(0))
    *   yield* Console.log(`Modified: ${mtime.toISOString()}`)
    *
    *   // Check if it's a regular file
@@ -1124,19 +1127,19 @@ export declare namespace File {
    */
   export interface Info {
     readonly type: Type
-    readonly mtime: Date | undefined
-    readonly atime: Date | undefined
-    readonly birthtime: Date | undefined
+    readonly mtime: Option.Option<Date>
+    readonly atime: Option.Option<Date>
+    readonly birthtime: Option.Option<Date>
     readonly dev: number
-    readonly ino: number | undefined
+    readonly ino: Option.Option<number>
     readonly mode: number
-    readonly nlink: number | undefined
-    readonly uid: number | undefined
-    readonly gid: number | undefined
-    readonly rdev: number | undefined
+    readonly nlink: Option.Option<number>
+    readonly uid: Option.Option<number>
+    readonly gid: Option.Option<number>
+    readonly rdev: Option.Option<number>
     readonly size: Size
-    readonly blksize: Size | undefined
-    readonly blocks: number | undefined
+    readonly blksize: Option.Option<Size>
+    readonly blocks: Option.Option<number>
   }
 }
 
@@ -1227,13 +1230,13 @@ export declare namespace WatchEvent {
  *
  * @example
  * ```ts
- * import { Effect, FileSystem, Stream } from "effect"
+ * import { Effect, FileSystem, Option, Stream } from "effect"
  *
  * // Custom watch backend implementation
  * const customWatchBackend = {
  *   register: (path: string, stat: FileSystem.File.Info) => {
  *     // Implementation would depend on platform
- *     return Stream.empty // Placeholder implementation
+ *     return Option.some(Stream.empty) // Placeholder implementation
  *   }
  * }
  *
@@ -1256,5 +1259,5 @@ export declare namespace WatchEvent {
  * @category file watcher
  */
 export class WatchBackend extends ServiceMap.Service<WatchBackend, {
-  readonly register: (path: string, stat: File.Info) => Stream.Stream<WatchEvent, PlatformError> | undefined
+  readonly register: (path: string, stat: File.Info) => Option.Option<Stream.Stream<WatchEvent, PlatformError>>
 }>()("effect/platform/FileSystem/WatchBackend") {}

package/src/Filter.ts

@@ -7,7 +7,7 @@ import { dual } from "./Function.ts"
 import * as Option from "./Option.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
-import type { EqualsWith, ExcludeTag, ExtractTag, Tags } from "./Types.ts"
+import type { EqualsWith, ExcludeTag, ExtractReason, ExtractTag, ReasonTags, Tags } from "./Types.ts"
 
 /**
  * Represents a filter function that can transform inputs to outputs or filter them out.
@@ -29,8 +29,8 @@ import type { EqualsWith, ExcludeTag, ExtractTag, Tags } from "./Types.ts"
  * @since 4.0.0
  * @category Models
  */
-export interface Filter<in Input, out Pass = Input, out Fail = Input, in Args extends ReadonlyArray<any> = []> {
-  (input: Input, ...args: Args): Result.Result<Pass, Fail>
+export interface Filter<in Input, out Pass = Input, out Fail = Input> {
+  (input: Input): Result.Result<Pass, Fail>
 }
 
 /**
@@ -68,67 +68,9 @@ export interface FilterEffect<
   out Pass,
   out Fail,
   out E = never,
-  out R = never,
-  in Args extends Array<any> = []
+  out R = never
 > {
-  (input: Input, ...args: Args): Effect<Result.Result<Pass, Fail>, E, R>
-}
-
-// -------------------------------------------------------------------------------------
-// apply
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type OrPredicate<A, R extends boolean | Result.Result<any, any>, Args extends ReadonlyArray<any> = []> = (
-  input: A,
-  ...args: Args
-) => R
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type ResultOrBool<Out = any> = boolean | Result.Result<any, Out>
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type Pass<A, R extends boolean | Result.Result<any, any>> = [R] extends [Result.Result<infer _P, infer _F>] ? _P
-  : A
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type Fail<A, R extends boolean | Result.Result<any, any>> = [R] extends [Result.Result<infer _P, infer _F>] ? _F
-  : A
-
-/**
- * @since 4.0.0
- * @category Apply
- */
-export type ApplyResult<A, R extends boolean | Result.Result<any, any>> = Result.Result<Pass<A, R>, Fail<A, R>>
-
-/**
- * Applies a filter, predicate, or refinement to an input and returns a boxed
- * result. Extra arguments are forwarded to the function.
- *
- * @since 4.0.0
- * @category Apply
- */
-export const apply = <In, R extends ResultOrBool>(
-  filter: (input: In, ...args: Array<any>) => R,
-  input: In,
-  ...args: Array<any>
-): ApplyResult<In, R> => {
-  const result = filter(input, ...args)
-  if (result === true) return Result.succeed(input) as any
-  if (result === false) return Result.fail(input) as any
-  return result as any
+  (input: Input): Effect<Result.Result<Pass, Fail>, E, R>
 }
 
 // -------------------------------------------------------------------------------------
@@ -456,6 +398,53 @@ const taggedImpl =
   <Input>(input: Input): Result.Result<ExtractTag<Input, Tag>, ExcludeTag<Input, Tag>> =>
     Predicate.isTagged(input, tag) ? Result.succeed(input as any) : Result.fail(input as ExcludeTag<Input, Tag>)
 
+/**
+ * Creates a filter that extracts a reason from a tagged error.
+ *
+ * @since 4.0.0
+ * @category Constructors
+ */
+export const reason: {
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <Input>(): <const Tag extends Tags<Input>, const ReasonTag extends ReasonTags<ExtractTag<Input, Tag>>>(
+    tag: Tag,
+    reasonTag: ReasonTag
+  ) => Filter<Input, ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <Input, const Tag extends Tags<Input>, const ReasonTag extends ReasonTags<ExtractTag<Input, Tag>>>(tag: Tag, reasonTag: ReasonTag): Filter<Input, ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+  /**
+   * Creates a filter that extracts a reason from a tagged error.
+   *
+   * @since 4.0.0
+   * @category Constructors
+   */
+  <const Tag extends string, const ReasonTag extends string>(tag: Tag, reasonTag: ReasonTag): <Input>(input: Input) => Result.Result<ExtractReason<ExtractTag<Input, Tag>, ReasonTag>, Input>
+} = function() {
+  return arguments.length === 0 ? reasonImpl : reasonImpl(arguments[0] as any, arguments[1] as any)
+} as any
+
+const reasonImpl =
+  <const Tag extends string, const ReasonTag extends string>(tag: Tag, reasonTag: ReasonTag) =>
+  <Input>(input: Input): Result.Result<ExtractTag<Input, Tag>, ExcludeTag<Input, Tag>> => {
+    if (
+      Predicate.isTagged(input, tag) && Predicate.hasProperty(input, "reason") &&
+      Predicate.isTagged(input.reason, reasonTag)
+    ) {
+      return Result.succeed(input.reason as any)
+    }
+    return Result.fail(input as any)
+  }
+
 /**
  * Creates a filter that only passes values equal to the specified value using structural equality.
  *