effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/BigInt.ts

@@ -8,6 +8,7 @@
 import * as Combiner from "./Combiner.ts"
 import * as Equ from "./Equivalence.ts"
 import { dual } from "./Function.ts"
+import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
 import type { Ordering } from "./Ordering.ts"
 import * as predicate from "./Predicate.ts"
@@ -200,15 +201,17 @@ export const subtract: {
  * If the dividend is not a multiple of the divisor the result will be a `bigint` value
  * which represents the integer division rounded down to the nearest integer.
  *
- * Returns `undefined` if the divisor is `0n`.
+ * Returns `Option.none()` if the divisor is `0n`.
  *
  * @example
  * ```ts
  * import { divide } from "effect/BigInt"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(divide(6n, 3n), 2n)
- * assert.deepStrictEqual(divide(6n, 0n), undefined)
+ * import { Option } from "effect"
+ *
+ * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(divide(6n, 0n), Option.none())
  * ```
  *
  * @category math
@@ -221,45 +224,49 @@ export const divide: {
    * If the dividend is not a multiple of the divisor the result will be a `bigint` value
    * which represents the integer division rounded down to the nearest integer.
    *
-   * Returns `undefined` if the divisor is `0n`.
+   * Returns `Option.none()` if the divisor is `0n`.
    *
    * @example
    * ```ts
    * import { divide } from "effect/BigInt"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(divide(6n, 3n), 2n)
-   * assert.deepStrictEqual(divide(6n, 0n), undefined)
+   * import { Option } from "effect"
+   *
+   * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
+   * assert.deepStrictEqual(divide(6n, 0n), Option.none())
    * ```
    *
    * @category math
    * @since 2.0.0
    */
-  (that: bigint): (self: bigint) => bigint | undefined
+  (that: bigint): (self: bigint) => Option.Option<bigint>
   /**
    * Provides a division operation on `bigint`s.
    *
    * If the dividend is not a multiple of the divisor the result will be a `bigint` value
    * which represents the integer division rounded down to the nearest integer.
    *
-   * Returns `undefined` if the divisor is `0n`.
+   * Returns `Option.none()` if the divisor is `0n`.
    *
    * @example
    * ```ts
    * import { divide } from "effect/BigInt"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(divide(6n, 3n), 2n)
-   * assert.deepStrictEqual(divide(6n, 0n), undefined)
+   * import { Option } from "effect"
+   *
+   * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
+   * assert.deepStrictEqual(divide(6n, 0n), Option.none())
    * ```
    *
    * @category math
    * @since 2.0.0
    */
-  (self: bigint, that: bigint): bigint | undefined
+  (self: bigint, that: bigint): Option.Option<bigint>
 } = dual(
   2,
-  (self: bigint, that: bigint): bigint | undefined => that === bigint0 ? undefined : self / that
+  (self: bigint, that: bigint): Option.Option<bigint> => that === bigint0 ? Option.none() : Option.some(self / that)
 )
 
 /**
@@ -1034,7 +1041,7 @@ export const sqrtUnsafe = (n: bigint): bigint => {
 }
 
 /**
- * Determines the square root of a given `bigint` safely. Returns `undefined` if
+ * Determines the square root of a given `bigint` safely. Returns `Option.none()` if
  * the given `bigint` is negative.
  *
  * **Example**
@@ -1042,16 +1049,17 @@ export const sqrtUnsafe = (n: bigint): bigint => {
  * ```ts
  * import { BigInt } from "effect"
  *
- * BigInt.sqrt(4n) // 2n
- * BigInt.sqrt(9n) // 3n
- * BigInt.sqrt(16n) // 4n
- * BigInt.sqrt(-1n) // undefined
+ * BigInt.sqrt(4n) // Option.some(2n)
+ * BigInt.sqrt(9n) // Option.some(3n)
+ * BigInt.sqrt(16n) // Option.some(4n)
+ * BigInt.sqrt(-1n) // Option.none()
  * ```
  *
  * @category math
  * @since 2.0.0
  */
-export const sqrt = (n: bigint): bigint | undefined => isGreaterThanOrEqualTo(n, bigint0) ? sqrtUnsafe(n) : undefined
+export const sqrt = (n: bigint): Option.Option<bigint> =>
+  isGreaterThanOrEqualTo(n, bigint0) ? Option.some(sqrtUnsafe(n)) : Option.none()
 
 /**
  * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint
@@ -1104,52 +1112,52 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  * Converts a `bigint` to a `number`.
  *
  * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
- * and `Number.MIN_SAFE_INTEGER`), it returns `undefined`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`.
  *
  * @example
  * ```ts
  * import { BigInt as BI } from "effect"
  *
- * BI.toNumber(42n) // 42
- * BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + 1n) // undefined
- * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // undefined
+ * BI.toNumber(42n) // Option.some(42)
+ * BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + 1n) // Option.none()
+ * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // Option.none()
  * ```
  *
  * @category conversions
  * @since 2.0.0
  */
-export const toNumber = (b: bigint): number | undefined => {
+export const toNumber = (b: bigint): Option.Option<number> => {
   if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
-    return undefined
+    return Option.none()
   }
-  return Number(b)
+  return Option.some(Number(b))
 }
 
 /**
  * Converts a string to a `bigint`.
  *
  * If the string is empty or contains characters that cannot be converted into a
- * `bigint`, it returns `undefined`.
+ * `bigint`, it returns `Option.none()`.
  *
  * @example
  * ```ts
  * import { BigInt } from "effect"
  *
- * BigInt.fromString("42") // 42n
- * BigInt.fromString(" ") // undefined
- * BigInt.fromString("a") // undefined
+ * BigInt.fromString("42") // Option.some(42n)
+ * BigInt.fromString(" ") // Option.none()
+ * BigInt.fromString("a") // Option.none()
  * ```
  *
  * @category conversions
  * @since 2.4.12
  */
-export const fromString = (s: string): bigint | undefined => {
+export const fromString = (s: string): Option.Option<bigint> => {
   try {
     return s.trim() === ""
-      ? undefined
-      : BigInt(s)
+      ? Option.none()
+      : Option.some(BigInt(s))
   } catch {
-    return undefined
+    return Option.none()
   }
 }
 
@@ -1158,30 +1166,30 @@ export const fromString = (s: string): bigint | undefined => {
  *
  * If the number is outside the safe integer range for JavaScript
  * (`Number.MAX_SAFE_INTEGER` and `Number.MIN_SAFE_INTEGER`) or if the number is
- * not a valid `bigint`, it returns `undefined`.
+ * not a valid `bigint`, it returns `Option.none()`.
  *
  * @example
  * ```ts
  * import { BigInt } from "effect"
  *
- * BigInt.fromNumber(42) // 42n
+ * BigInt.fromNumber(42) // Option.some(42n)
  *
- * BigInt.fromNumber(Number.MAX_SAFE_INTEGER + 1) // undefined
- * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // undefined
+ * BigInt.fromNumber(Number.MAX_SAFE_INTEGER + 1) // Option.none()
+ * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // Option.none()
  * ```
  *
  * @category conversions
  * @since 2.4.12
  */
-export function fromNumber(n: number): bigint | undefined {
+export function fromNumber(n: number): Option.Option<bigint> {
   if (n > Number.MAX_SAFE_INTEGER || n < Number.MIN_SAFE_INTEGER) {
-    return undefined
+    return Option.none()
   }
 
   try {
-    return BigInt(n)
+    return Option.some(BigInt(n))
   } catch {
-    return undefined
+    return Option.none()
   }
 }
 

package/src/Brand.ts

@@ -12,7 +12,7 @@ import * as AST from "./SchemaAST.ts"
 import type * as Issue from "./SchemaIssue.ts"
 import type * as Types from "./Types.ts"
 
-const TypeId = "~effect/data/Brand"
+const TypeId = "~effect/Brand"
 
 /**
  * A generic interface that defines a branded type.

package/src/Cache.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Duration from "./Duration.ts"
 import type * as Effect from "./Effect.ts"
@@ -15,7 +16,7 @@ import * as MutableHashMap from "./MutableHashMap.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import type { Predicate } from "./Predicate.ts"
-import * as ServiceMap from "./ServiceMap.ts"
+import * as Result from "./Result.ts"
 
 const TypeId = "~effect/Cache"
 
@@ -119,48 +120,21 @@ export interface Entry<A, E> {
  * ```ts
  * import { Cache, Effect, Exit } from "effect"
  *
- * // Cache with different TTL for success vs failure
- * const program = Effect.gen(function*() {
- *   const cache = yield* Cache.makeWith<string, number, string>({
- *     capacity: 100,
- *     lookup: (key) =>
- *       key === "fail"
- *         ? Effect.fail("error")
- *         : Effect.succeed(key.length),
- *     timeToLive: (exit, key) => {
- *       if (Exit.isFailure(exit)) return "1 minute" // Short TTL for errors
- *       return key.startsWith("temp") ? "5 minutes" : "1 hour"
- *     }
- *   })
- *
- *   // Get values with different TTL policies
- *   const result1 = yield* Cache.get(cache, "hello")
- *   const result2 = yield* Cache.get(cache, "temp_data")
- *   console.log({ result1, result2 }) // { result1: 5, result2: 9 }
- * })
- * ```
- *
- * @example
- * ```ts
- * import { Cache, Effect, Exit } from "effect"
- *
  * // Cache with TTL based on computed value
  * const userCache = Effect.gen(function*() {
- *   const cache = yield* Cache.makeWith<
- *     number,
- *     { id: number; active: boolean },
- *     never
- *   >({
- *     capacity: 1000,
- *     lookup: (id) => Effect.succeed({ id, active: id % 2 === 0 }),
- *     timeToLive: (exit) => {
- *       if (Exit.isSuccess(exit)) {
- *         const user = exit.value
- *         return user.active ? "1 hour" : "5 minutes"
+ *   const cache = yield* Cache.makeWith(
+ *     (id: number) => Effect.succeed({ id, active: id % 2 === 0 }),
+ *     {
+ *       capacity: 1000,
+ *       timeToLive(exit) {
+ *         if (Exit.isSuccess(exit)) {
+ *           const user = exit.value
+ *           return user.active ? "1 hour" : "5 minutes"
+ *         }
+ *         return "30 seconds"
  *       }
- *       return "30 seconds"
  *     }
- *   })
+ *   )
  *
  *   return cache
  * })
@@ -175,27 +149,26 @@ export const makeWith = <
   E = never,
   R = never,
   ServiceMode extends "lookup" | "construction" = never
->(options: {
-  readonly lookup: (key: Key) => Effect.Effect<A, E, R>
+>(lookup: (key: Key) => Effect.Effect<A, E, R>, options: {
   readonly capacity: number
-  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Exit.Exit<A, E>, key: Key) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   Cache<Key, A, E, "lookup" extends ServiceMode ? R : never>,
   never,
   "lookup" extends ServiceMode ? never : R
 > =>
-  effect.servicesWith((services: ServiceMap.ServiceMap<any>) => {
+  effect.contextWith((context: Context.Context<any>) => {
     const self = Object.create(Proto)
     self.lookup = (key: Key): Effect.Effect<A, E> =>
-      effect.updateServices(
-        options.lookup(key),
-        (input) => ServiceMap.merge(services, input)
+      effect.updateContext(
+        lookup(key),
+        (input) => Context.merge(context, input)
       )
     self.map = MutableHashMap.make()
     self.capacity = options.capacity
     self.timeToLive = options.timeToLive
-      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromDurationInputUnsafe(options.timeToLive!(exit, key))
+      ? (exit: Exit.Exit<A, E>, key: Key) => Duration.fromInputUnsafe(options.timeToLive!(exit, key))
       : defaultTimeToLive
     return effect.succeed(self as Cache<Key, A, E>)
   })
@@ -263,7 +236,7 @@ export const make = <
   options: {
     readonly lookup: (key: Key) => Effect.Effect<A, E, R>
     readonly capacity: number
-    readonly timeToLive?: Duration.DurationInput | undefined
+    readonly timeToLive?: Duration.Input | undefined
     readonly requireServicesAt?: ServiceMode | undefined
   }
 ): Effect.Effect<
@@ -271,7 +244,7 @@ export const make = <
   never,
   "lookup" extends ServiceMode ? never : R
 > =>
-  makeWith<Key, A, E, R, ServiceMode>({
+  makeWith<Key, A, E, R, ServiceMode>(options.lookup, {
     ...options,
     timeToLive: options.timeToLive ? () => options.timeToLive! : defaultTimeToLive
   })
@@ -2786,10 +2759,10 @@ export const keys = <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<Ite
     const now = fiber.getRef(effect.ClockRef).currentTimeMillisUnsafe()
     return effect.succeed(Iterable.filterMap(self.map, ([key, entry]) => {
       if (entry.expiresAt === undefined || entry.expiresAt > now) {
-        return Option.some(key)
+        return Result.succeed(key)
       }
       MutableHashMap.remove(self.map, key)
-      return Option.none()
+      return Result.failVoid
     }))
   })
 
@@ -2841,10 +2814,10 @@ export const entries = <Key, A, E, R>(self: Cache<Key, A, E, R>): Effect.Effect<
       if (entry.expiresAt === undefined || entry.expiresAt > now) {
         const exit = entry.deferred.effect
         return !core.isExit(exit) || effect.exitIsFailure(exit)
-          ? Option.none()
-          : Option.some([key, exit.value as A])
+          ? Result.failVoid
+          : Result.succeed([key, exit.value as A])
       }
       MutableHashMap.remove(self.map, key)
-      return Option.none()
+      return Result.failVoid
     }))
   })

package/src/Cause.ts

@@ -77,8 +77,10 @@
  *
  * @since 2.0.0
  */
+import * as Context from "./Context.ts"
 import type * as Effect from "./Effect.ts"
 import type { Equal } from "./Equal.ts"
+import type { Fiber } from "./Fiber.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as core from "./internal/core.ts"
 import * as effect from "./internal/effect.ts"
@@ -86,7 +88,6 @@ import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import type { StackFrame } from "./References.ts"
 import type * as Result from "./Result.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import type * as Types from "./Types.ts"
 
 /**
@@ -318,7 +319,7 @@ export declare namespace Cause {
     readonly [ReasonTypeId]: typeof ReasonTypeId
     readonly _tag: Tag
     readonly annotations: ReadonlyMap<string, unknown>
-    annotate(annotations: ServiceMap.ServiceMap<never> | ReadonlyMap<string, unknown>, options?: {
+    annotate(annotations: Context.Context<never> | ReadonlyMap<string, unknown>, options?: {
       readonly overwrite?: boolean | undefined
     }): this
   }
@@ -1175,14 +1176,14 @@ export const pretty: <E>(cause: Cause<E>) => string = effect.causePretty
  * const error = new Cause.NoSuchElementError("not found")
  *
  * const program = Effect.gen(function*() {
- *   yield* error // fails the effect with NoSuchElementError
+ *   return yield* error // fails the effect with NoSuchElementError
  * })
  * ```
  *
  * @since 2.0.0
  * @category errors
  */
-export interface YieldableError extends Error {
+export interface YieldableError extends Error, Pipeable {
   [Symbol.iterator](): Effect.EffectIterator<this>
   asEffect(): Effect.Effect<never, this, never>
 }
@@ -1565,6 +1566,40 @@ export interface ExceededCapacityError extends YieldableError {
  */
 export const ExceededCapacityError: new(message?: string) => ExceededCapacityError = effect.ExceededCapacityError
 
+/**
+ * Unique brand for {@link AsyncFiberError}.
+ *
+ * @since 4.0.0
+ * @category symbols
+ */
+export const AsyncFiberErrorTypeId: "~effect/Cause/AsyncFiberError" = effect.AsyncFiberErrorTypeId
+
+/**
+ * @category guards
+ * @since 4.0.0
+ */
+export const isAsyncFiberError: (u: unknown) => u is AsyncFiberError = effect.isAsyncFiberError
+
+/**
+ * An error that occurs when trying to run an async fiber with Effect.runSync.
+ *
+ * @since 4.0.0
+ * @category errors
+ */
+export interface AsyncFiberError extends YieldableError {
+  readonly [AsyncFiberErrorTypeId]: typeof AsyncFiberErrorTypeId
+  readonly _tag: "AsyncFiberError"
+  readonly fiber: Fiber<unknown, unknown>
+}
+
+/**
+ * An error that occurs when trying to run an async fiber with Effect.runSync.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const AsyncFiberError: new(fiber: Fiber<unknown, unknown>) => AsyncFiberError = effect.AsyncFiberError
+
 /**
  * Unique brand for {@link UnknownError}.
  *
@@ -1639,7 +1674,7 @@ export const UnknownError: new(cause: unknown, message?: string) => UnknownError
 /**
  * Attaches metadata to every reason in a {@link Cause}.
  *
- * Annotations are stored as a `ServiceMap` on each reason and can be
+ * Annotations are stored as a `Context` on each reason and can be
  * retrieved later via {@link reasonAnnotations} or {@link annotations}.
  * The runtime uses this to attach stack traces and spans.
  *
@@ -1650,10 +1685,10 @@ export const UnknownError: new(cause: unknown, message?: string) => UnknownError
  * **Example** (annotating a cause)
  *
  * ```ts
- * import { Cause, ServiceMap } from "effect"
+ * import { Cause, Context } from "effect"
  *
  * const cause = Cause.fail("error")
- * const annotated = Cause.annotate(cause, ServiceMap.empty())
+ * const annotated = Cause.annotate(cause, Context.empty())
  * ```
  *
  * @see {@link annotations} — read merged annotations from a cause
@@ -1666,7 +1701,7 @@ export const annotate: {
   /**
    * Attaches metadata to every reason in a {@link Cause}.
    *
-   * Annotations are stored as a `ServiceMap` on each reason and can be
+   * Annotations are stored as a `Context` on each reason and can be
    * retrieved later via {@link reasonAnnotations} or {@link annotations}.
    * The runtime uses this to attach stack traces and spans.
    *
@@ -1677,10 +1712,10 @@ export const annotate: {
    * **Example** (annotating a cause)
    *
    * ```ts
-   * import { Cause, ServiceMap } from "effect"
+   * import { Cause, Context } from "effect"
    *
    * const cause = Cause.fail("error")
-   * const annotated = Cause.annotate(cause, ServiceMap.empty())
+   * const annotated = Cause.annotate(cause, Context.empty())
    * ```
    *
    * @see {@link annotations} — read merged annotations from a cause
@@ -1690,13 +1725,13 @@ export const annotate: {
    * @since 4.0.0
    */
   (
-   annotations: ServiceMap.ServiceMap<never>,
+   annotations: Context.Context<never>,
    options?: { readonly overwrite?: boolean | undefined }
   ): <E>(self: Cause<E>) => Cause<E>
   /**
    * Attaches metadata to every reason in a {@link Cause}.
    *
-   * Annotations are stored as a `ServiceMap` on each reason and can be
+   * Annotations are stored as a `Context` on each reason and can be
    * retrieved later via {@link reasonAnnotations} or {@link annotations}.
    * The runtime uses this to attach stack traces and spans.
    *
@@ -1707,10 +1742,10 @@ export const annotate: {
    * **Example** (annotating a cause)
    *
    * ```ts
-   * import { Cause, ServiceMap } from "effect"
+   * import { Cause, Context } from "effect"
    *
    * const cause = Cause.fail("error")
-   * const annotated = Cause.annotate(cause, ServiceMap.empty())
+   * const annotated = Cause.annotate(cause, Context.empty())
    * ```
    *
    * @see {@link annotations} — read merged annotations from a cause
@@ -1721,13 +1756,13 @@ export const annotate: {
    */
   <E>(
    self: Cause<E>,
-   annotations: ServiceMap.ServiceMap<never>,
+   annotations: Context.Context<never>,
    options?: { readonly overwrite?: boolean | undefined }
   ): Cause<E>
 } = core.causeAnnotate
 
 /**
- * Reads the annotations from a single {@link Reason} as a `ServiceMap`.
+ * Reads the annotations from a single {@link Reason} as a `Context`.
  *
  * Use this when you need tracing metadata (e.g. {@link StackTrace}) from
  * a specific reason rather than the whole cause.
@@ -1738,7 +1773,7 @@ export const annotate: {
  * @category annotations
  * @since 4.0.0
  */
-export const reasonAnnotations: <E>(self: Reason<E>) => ServiceMap.ServiceMap<never> = effect.reasonAnnotations
+export const reasonAnnotations: <E>(self: Reason<E>) => Context.Context<never> = effect.reasonAnnotations
 
 /**
  * Reads the merged annotations from all reasons in a {@link Cause}.
@@ -1751,22 +1786,22 @@ export const reasonAnnotations: <E>(self: Reason<E>) => ServiceMap.ServiceMap<ne
  * @category annotations
  * @since 4.0.0
  */
-export const annotations: <E>(self: Cause<E>) => ServiceMap.ServiceMap<never> = effect.causeAnnotations
+export const annotations: <E>(self: Cause<E>) => Context.Context<never> = effect.causeAnnotations
 
 /**
- * `ServiceMap` key for the stack frame captured at the point of failure.
+ * `Context` key for the stack frame captured at the point of failure.
  *
  * The runtime annotates every reason with this when a stack frame is
  * available. Retrieve it via
- * `ServiceMap.get(Cause.reasonAnnotations(reason), Cause.StackTrace)`.
+ * `Context.get(Cause.reasonAnnotations(reason), Cause.StackTrace)`.
  *
  * @category annotations
  * @since 4.0.0
  */
-export class StackTrace extends ServiceMap.Service<StackTrace, StackFrame>()("effect/Cause/StackTrace") {}
+export class StackTrace extends Context.Service<StackTrace, StackFrame>()("effect/Cause/StackTrace") {}
 
 /**
- * `ServiceMap` key for the stack frame captured at the point of
+ * `Context` key for the stack frame captured at the point of
  * interruption.
  *
  * Similar to {@link StackTrace} but specific to {@link Interrupt} reasons.
@@ -1775,5 +1810,5 @@ export class StackTrace extends ServiceMap.Service<StackTrace, StackFrame>()("ef
  * @since 4.0.0
  */
 export class InterruptorStackTrace
-  extends ServiceMap.Service<InterruptorStackTrace, StackFrame>()("effect/Cause/InterruptorStackTrace")
+  extends Context.Service<InterruptorStackTrace, StackFrame>()("effect/Cause/InterruptorStackTrace")
 {}