effect 3.10.18 → 3.11.0

package/src/FiberSet.ts

@@ -95,6 +95,7 @@ const unsafeMake = <A, E>(
  * be automatically removed from the FiberSet when they complete.
  *
  * @example
+ * ```ts
  * import { Effect, FiberSet } from "effect"
  *
  * Effect.gen(function*(_) {
@@ -108,6 +109,7 @@ const unsafeMake = <A, E>(
  * }).pipe(
  *   Effect.scoped // The fibers will be interrupted when the scope is closed
  * )
+ * ```
  *
  * @since 2.0.0
  * @categories constructors
@@ -360,6 +362,7 @@ export const run: {
  * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet.
  *
  * @example
+ * ```ts
  * import { Context, Effect, FiberSet } from "effect"
  *
  * interface Users {
@@ -378,6 +381,7 @@ export const run: {
  * }).pipe(
  *   Effect.scoped // The fibers will be interrupted when the scope is closed
  * )
+ * ```
  *
  * @since 2.0.0
  * @categories combinators
@@ -425,6 +429,7 @@ export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> =>
  * @since 2.0.0
  * @categories combinators
  * @example
+ * ```ts
  * import { Effect, FiberSet } from "effect";
  *
  * Effect.gen(function* (_) {
@@ -434,6 +439,7 @@ export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> =>
  *   // parent fiber will fail with "error"
  *   yield* _(FiberSet.join(set));
  * });
+ * ```
  */
 export const join = <A, E>(self: FiberSet<A, E>): Effect.Effect<void, E> =>
   Deferred.await(self.deferred as Deferred.Deferred<void, E>)

package/src/Function.ts

@@ -17,10 +17,12 @@ export interface FunctionTypeLambda extends TypeLambda {
  * @param input - The value to test.
  *
  * @example
+ * ```ts
  * import { isFunction } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isFunction(isFunction), true)
  * assert.deepStrictEqual(isFunction("function"), false)
+ * ```
  *
  * @category guards
  * @since 2.0.0
@@ -46,6 +48,7 @@ export const isFunction = (input: unknown): input is Function => typeof input ==
  * @param body - The definition of the uncurried function.
  *
  * @example
+ * ```ts
  * import { dual, pipe } from "effect/Function"
  *
  * // Exampe using arity to determine data-first or data-last style
@@ -65,6 +68,7 @@ export const isFunction = (input: unknown): input is Function => typeof input ==
  *
  * assert.deepStrictEqual(sum(2, 3), 5)
  * assert.deepStrictEqual(pipe(2, sum(3)), 5)
+ * ```
  *
  * @since 2.0.0
  */
@@ -88,6 +92,7 @@ export const dual: {
    * @param body - The definition of the uncurried function.
    *
    * @example
+   * ```ts
    * import { dual, pipe } from "effect/Function"
    *
    * // Exampe using arity to determine data-first or data-last style
@@ -107,6 +112,7 @@ export const dual: {
    *
    * assert.deepStrictEqual(sum(2, 3), 5)
    * assert.deepStrictEqual(pipe(2, sum(3)), 5)
+   * ```
    *
    * @since 2.0.0
    */
@@ -133,6 +139,7 @@ export const dual: {
    * @param body - The definition of the uncurried function.
    *
    * @example
+   * ```ts
    * import { dual, pipe } from "effect/Function"
    *
    * // Exampe using arity to determine data-first or data-last style
@@ -152,6 +159,7 @@ export const dual: {
    *
    * assert.deepStrictEqual(sum(2, 3), 5)
    * assert.deepStrictEqual(pipe(2, sum(3)), 5)
+   * ```
    *
    * @since 2.0.0
    */
@@ -235,10 +243,12 @@ export const dual: {
  * @param self - The function to be applied to a value.
  *
  * @example
+ * ```ts
  * import { pipe, apply } from "effect/Function"
  * import { length } from "effect/String"
  *
  * assert.deepStrictEqual(pipe(length, apply("hello")), 5)
+ * ```
  *
  * @since 2.0.0
  */
@@ -248,9 +258,11 @@ export const apply = <A>(a: A) => <B>(self: (a: A) => B): B => self(a)
  * A lazy argument.
  *
  * @example
+ * ```ts
  * import { LazyArg, constant } from "effect/Function"
  *
  * const constNull: LazyArg<null> = constant(null)
+ * ```
  *
  * @since 2.0.0
  */
@@ -260,9 +272,11 @@ export interface LazyArg<A> {
 
 /**
  * @example
+ * ```ts
  * import { FunctionN } from "effect/Function"
  *
  * const sum: FunctionN<[number, number], number> = (a, b) => a + b
+ * ```
  *
  * @since 2.0.0
  */
@@ -276,9 +290,11 @@ export interface FunctionN<A extends ReadonlyArray<unknown>, B> {
  * @param a - The input argument.
  *
  * @example
+ * ```ts
  * import { identity } from "effect/Function"
  *
  * assert.deepStrictEqual(identity(5), 5)
+ * ```
  *
  * @since 2.0.0
  */
@@ -289,6 +305,7 @@ export const identity = <A>(a: A): A => a
  * without changing the resulting type of that expression.
  *
  * @example
+ * ```ts
  * import { satisfies } from "effect/Function"
  *
  * const test1 = satisfies<number>()(5 as const)
@@ -298,6 +315,7 @@ export const identity = <A>(a: A): A => a
  *     //^? Argument of type 'number' is not assignable to parameter of type 'string'
  *
  * assert.deepStrictEqual(satisfies<number>()(5), 5)
+ * ```
  *
  * @since 2.0.0
  */
@@ -309,9 +327,11 @@ export const satisfies = <A>() => <B extends A>(b: B) => b
  * @param a - The value to be casted to the target type.
  *
  * @example
+ * ```ts
  * import { unsafeCoerce, identity } from "effect/Function"
  *
  * assert.deepStrictEqual(unsafeCoerce, identity)
+ * ```
  *
  * @since 2.0.0
  */
@@ -326,12 +346,14 @@ export const unsafeCoerce: <A, B>(a: A) => B = identity as any
  * @param value - The constant value to be returned.
  *
  * @example
+ * ```ts
  * import { constant } from "effect/Function"
  *
  * const constNull = constant(null)
  *
  * assert.deepStrictEqual(constNull(), null)
  * assert.deepStrictEqual(constNull(), null)
+ * ```
  *
  * @since 2.0.0
  */
@@ -341,9 +363,11 @@ export const constant = <A>(value: A): LazyArg<A> => () => value
  * A thunk that returns always `true`.
  *
  * @example
+ * ```ts
  * import { constTrue } from "effect/Function"
  *
  * assert.deepStrictEqual(constTrue(), true)
+ * ```
  *
  * @since 2.0.0
  */
@@ -353,9 +377,11 @@ export const constTrue: LazyArg<boolean> = constant(true)
  * A thunk that returns always `false`.
  *
  * @example
+ * ```ts
  * import { constFalse } from "effect/Function"
  *
  * assert.deepStrictEqual(constFalse(), false)
+ * ```
  *
  * @since 2.0.0
  */
@@ -365,9 +391,11 @@ export const constFalse: LazyArg<boolean> = constant(false)
  * A thunk that returns always `null`.
  *
  * @example
+ * ```ts
  * import { constNull } from "effect/Function"
  *
  * assert.deepStrictEqual(constNull(), null)
+ * ```
  *
  * @since 2.0.0
  */
@@ -377,9 +405,11 @@ export const constNull: LazyArg<null> = constant(null)
  * A thunk that returns always `undefined`.
  *
  * @example
+ * ```ts
  * import { constUndefined } from "effect/Function"
  *
  * assert.deepStrictEqual(constUndefined(), undefined)
+ * ```
  *
  * @since 2.0.0
  */
@@ -389,9 +419,11 @@ export const constUndefined: LazyArg<undefined> = constant(undefined)
  * A thunk that returns always `void`.
  *
  * @example
+ * ```ts
  * import { constVoid } from "effect/Function"
  *
  * assert.deepStrictEqual(constVoid(), undefined)
+ * ```
  *
  * @since 2.0.0
  */
@@ -403,11 +435,13 @@ export const constVoid: LazyArg<void> = constUndefined
  * @param f - A curried function that takes multiple arguments.
  *
  * @example
+ * ```ts
  * import { flip } from "effect/Function"
  *
  * const f = (a: number) => (b: string) => a - b.length
  *
  * assert.deepStrictEqual(flip(f)('aaa')(2), -1)
+ * ```
  *
  * @since 2.0.0
  */
@@ -425,12 +459,14 @@ export const flip = <A extends Array<unknown>, B extends Array<unknown>, C>(
  * @param bc - A function that maps from `B` to `C`.
  *
  * @example
+ * ```ts
  * import { compose } from "effect/Function"
  *
  * const increment = (n: number) => n + 1;
  * const square = (n: number) => n * n;
  *
  * assert.strictEqual(compose(increment, square)(2), 9);
+ * ```
  *
  * @since 2.0.0
  */
@@ -443,12 +479,14 @@ export const compose: {
    * @param bc - A function that maps from `B` to `C`.
    *
    * @example
+   * ```ts
    * import { compose } from "effect/Function"
    *
    * const increment = (n: number) => n + 1;
    * const square = (n: number) => n * n;
    *
    * assert.strictEqual(compose(increment, square)(2), 9);
+   * ```
    *
    * @since 2.0.0
    */
@@ -461,12 +499,14 @@ export const compose: {
    * @param bc - A function that maps from `B` to `C`.
    *
    * @example
+   * ```ts
    * import { compose } from "effect/Function"
    *
    * const increment = (n: number) => n + 1;
    * const square = (n: number) => n * n;
    *
    * assert.strictEqual(compose(increment, square)(2), 9);
+   * ```
    *
    * @since 2.0.0
    */
@@ -489,11 +529,13 @@ export const absurd = <A>(_: never): A => {
  * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
  *
  * @example
+ * ```ts
  * import { tupled } from "effect/Function"
  *
  * const sumTupled = tupled((x: number, y: number): number => x + y)
  *
  * assert.deepStrictEqual(sumTupled([1, 2]), 3)
+ * ```
  *
  * @since 2.0.0
  */
@@ -503,11 +545,13 @@ export const tupled = <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B):
  * Inverse function of `tupled`
  *
  * @example
+ * ```ts
  * import { untupled } from "effect/Function"
  *
  * const getFirst = untupled(<A, B>(tuple: [A, B]): A => tuple[0])
  *
  * assert.deepStrictEqual(getFirst(1, 2), 1)
+ * ```
  *
  * @since 2.0.0
  */
@@ -563,6 +607,7 @@ export const untupled = <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (
  * argument** because they are only called with a single argument.
  *
  * @example
+ * ```ts
  * // Example: Chaining Arithmetic Operations
  * import { pipe } from "effect"
  *
@@ -576,6 +621,7 @@ export const untupled = <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (
  *
  * console.log(result)
  * // Output: 2
+ * ```
  *
  * @since 2.0.0
  */
@@ -1073,6 +1119,7 @@ export function pipe(
  * See also [`pipe`](#pipe).
  *
  * @example
+ * ```ts
  * import { flow } from "effect/Function"
  *
  * const len = (s: string): number => s.length
@@ -1081,6 +1128,7 @@ export function pipe(
  * const f = flow(len, double)
  *
  * assert.strictEqual(f('aaa'), 6)
+ * ```
  *
  * @since 2.0.0
  */
@@ -1266,9 +1314,11 @@ export const hole: <T>() => T = unsafeCoerce(absurd)
  * @param b - The second argument to be returned.
  *
  * @example
+ * ```ts
  * import { SK } from "effect/Function";
  *
  * assert.deepStrictEqual(SK(0, "hello"), "hello")
+ * ```
  *
  * @since 2.0.0
  */

package/src/GlobalValue.ts

@@ -32,6 +32,7 @@ const globalStore = (globalThis as any)[globalStoreId] as Map<unknown, any>
  * thereafter.
  *
  * @example
+ * ```ts
  * import { globalValue } from "effect/GlobalValue"
  *
  * // This cache will persist as long as the module is running,
@@ -40,6 +41,7 @@ const globalStore = (globalThis as any)[globalStoreId] as Map<unknown, any>
  *   Symbol.for("myCache"),
  *   () => new WeakMap<object, number>()
  * )
+ * ```
  *
  * @since 2.0.0
  */

package/src/HashMap.ts

@@ -40,6 +40,7 @@ export declare namespace HashMap {
    * This type-level utility extracts the key type `K` from a `HashMap<K, V>` type.
    *
    * @example
+   * ```ts
    * import { HashMap } from "effect"
    *
    * declare const hm: HashMap.HashMap<string, number>
@@ -47,6 +48,7 @@ export declare namespace HashMap {
    * // $ExpectType string
    * type K = HashMap.HashMap.Key<typeof hm>
    *
+   * ```
    * @since 2.0.0
    * @category type-level
    */
@@ -55,6 +57,7 @@ export declare namespace HashMap {
    * This type-level utility extracts the value type `V` from a `HashMap<K, V>` type.
    *
    * @example
+   * ```ts
    * import { HashMap } from "effect"
    *
    * declare const hm: HashMap.HashMap<string, number>
@@ -62,6 +65,7 @@ export declare namespace HashMap {
    * // $ExpectType number
    * type V = HashMap.HashMap.Value<typeof hm>
    *
+   * ```
    * @since 2.0.0
    * @category type-level
    */
@@ -71,6 +75,7 @@ export declare namespace HashMap {
    * This type-level utility extracts the entry type `[K, V]` from a `HashMap<K, V>` type.
    *
    * @example
+   * ```ts
    * import { HashMap } from "effect"
    *
    * declare const hm: HashMap.HashMap<string, number>
@@ -78,6 +83,7 @@ export declare namespace HashMap {
    * // $ExpectType [string, number]
    * type V = HashMap.HashMap.Entry<typeof hm>
    *
+   * ```
    * @since 3.9.0
    * @category type-level
    */

package/src/Inspectable.ts

@@ -32,13 +32,17 @@ export interface Inspectable {
  * @since 2.0.0
  */
 export const toJSON = (x: unknown): unknown => {
-  if (
-    hasProperty(x, "toJSON") && isFunction(x["toJSON"]) &&
-    x["toJSON"].length === 0
-  ) {
-    return x.toJSON()
-  } else if (Array.isArray(x)) {
-    return x.map(toJSON)
+  try {
+    if (
+      hasProperty(x, "toJSON") && isFunction(x["toJSON"]) &&
+      x["toJSON"].length === 0
+    ) {
+      return x.toJSON()
+    } else if (Array.isArray(x)) {
+      return x.map(toJSON)
+    }
+  } catch (_) {
+    return {}
   }
   return redact(x)
 }

package/src/Iterable.ts

@@ -24,9 +24,11 @@ import type { NoInfer } from "./Types.js"
  * **Note**. `length` is normalized to an integer >= 1.
  *
  * @example
+ * ```ts
  * import { makeBy } from "effect/Iterable"
  *
  * assert.deepStrictEqual(Array.from(makeBy(n => n * 2, { length: 5 })), [0, 2, 4, 6, 8])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -56,9 +58,11 @@ export const makeBy = <A>(f: (i: number) => A, options?: {
  * If `end` is omitted, the range will not have an upper bound.
  *
  * @example
+ * ```ts
  * import { range } from "effect/Iterable"
  *
  * assert.deepStrictEqual(Array.from(range(1, 3)), [1, 2, 3])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -78,9 +82,11 @@ export const range = (start: number, end?: number): Iterable<number> => {
  * **Note**. `n` is normalized to an integer >= 1.
  *
  * @example
+ * ```ts
  * import { replicate } from "effect/Iterable"
  *
  * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -92,9 +98,11 @@ export const replicate: {
    * **Note**. `n` is normalized to an integer >= 1.
    *
    * @example
+   * ```ts
    * import { replicate } from "effect/Iterable"
    *
    * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"])
+   * ```
    *
    * @category constructors
    * @since 2.0.0
@@ -106,9 +114,11 @@ export const replicate: {
    * **Note**. `n` is normalized to an integer >= 1.
    *
    * @example
+   * ```ts
    * import { replicate } from "effect/Iterable"
    *
    * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"])
+   * ```
    *
    * @category constructors
    * @since 2.0.0
@@ -122,10 +132,12 @@ export const replicate: {
  * @param self - The record to transform.
  *
  * @example
+ * ```ts
  * import { fromRecord } from "effect/Iterable"
  *
  * const x = { a: 1, b: 2, c: 3 }
  * assert.deepStrictEqual(Array.from(fromRecord(x)), [["a", 1], ["b", 2], ["c", 3]])
+ * ```
  *
  * @category conversions
  * @since 2.0.0
@@ -167,12 +179,14 @@ export const prepend: {
  * Prepends the specified prefix iterable to the beginning of the specified iterable.
  *
  * @example
+ * ```ts
  * import { Iterable } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.from(Iterable.prependAll([1, 2], ["a", "b"])),
  *   ["a", "b", 1, 2]
  * )
+ * ```
  *
  * @category concatenating
  * @since 2.0.0
@@ -182,12 +196,14 @@ export const prependAll: {
    * Prepends the specified prefix iterable to the beginning of the specified iterable.
    *
    * @example
+   * ```ts
    * import { Iterable } from "effect"
    *
    * assert.deepStrictEqual(
    *   Array.from(Iterable.prependAll([1, 2], ["a", "b"])),
    *   ["a", "b", 1, 2]
    * )
+   * ```
    *
    * @category concatenating
    * @since 2.0.0
@@ -197,12 +213,14 @@ export const prependAll: {
    * Prepends the specified prefix iterable to the beginning of the specified iterable.
    *
    * @example
+   * ```ts
    * import { Iterable } from "effect"
    *
    * assert.deepStrictEqual(
    *   Array.from(Iterable.prependAll([1, 2], ["a", "b"])),
    *   ["a", "b", 1, 2]
    * )
+   * ```
    *
    * @category concatenating
    * @since 2.0.0
@@ -327,10 +345,12 @@ export const scan: {
  * Determine if an `Iterable` is empty
  *
  * @example
+ * ```ts
  * import { isEmpty } from "effect/Iterable"
  *
  * assert.deepStrictEqual(isEmpty([]), true);
  * assert.deepStrictEqual(isEmpty([1, 2, 3]), false);
+ * ```
  *
  * @category guards
  * @since 2.0.0
@@ -1181,12 +1201,14 @@ export const filterMapWhile: {
  * Retrieves the `Some` values from an `Iterable` of `Option`s.
  *
  * @example
+ * ```ts
  * import { Iterable, Option } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.from(Iterable.getSomes([Option.some(1), Option.none(), Option.some(2)])),
  *   [1, 2]
  * )
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1197,12 +1219,14 @@ export const getSomes: <A>(self: Iterable<Option<A>>) => Iterable<A> = filterMap
  * Retrieves the `Left` values from an `Iterable` of `Either`s.
  *
  * @example
+ * ```ts
  * import { Iterable, Either } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.from(Iterable.getLefts([Either.right(1), Either.left("err"), Either.right(2)])),
  *   ["err"]
  * )
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1213,12 +1237,14 @@ export const getLefts = <R, L>(self: Iterable<Either<R, L>>): Iterable<L> => fil
  * Retrieves the `Right` values from an `Iterable` of `Either`s.
  *
  * @example
+ * ```ts
  * import { Iterable, Either } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.from(Iterable.getRights([Either.right(1), Either.left("err"), Either.right(2)])),
  *   [1, 2]
  * )
+ * ```
  *
  * @category filtering
  * @since 2.0.0

package/src/JSONSchema.ts

@@ -85,6 +85,7 @@ export interface JsonSchema7String extends JsonSchemaAnnotations {
   minLength?: number
   maxLength?: number
   pattern?: string
+  format?: string
 }
 
 /**