diff --git a/backend/node_modules/effect/dist/dts/Arbitrary.d.ts b/backend/node_modules/effect/dist/dts/Arbitrary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3d506c177067ddc4dccc0591daa23f51a05ea0ca --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Arbitrary.d.ts @@ -0,0 +1,69 @@ +/** + * @since 3.10.0 + */ +import * as FastCheck from "./FastCheck.js"; +import type * as Schema from "./Schema.js"; +/** + * @category model + * @since 3.10.0 + */ +export interface LazyArbitrary { + (fc: typeof FastCheck): FastCheck.Arbitrary; +} +/** + * @category annotations + * @since 3.10.0 + */ +export interface ArbitraryGenerationContext { + readonly maxDepth: number; + readonly depthIdentifier?: string; + readonly constraints?: StringConstraints | NumberConstraints | BigIntConstraints | DateConstraints | ArrayConstraints; +} +/** + * @category annotations + * @since 3.10.0 + */ +export type ArbitraryAnnotation = readonly []> = (...arbitraries: [ + ...{ + readonly [K in keyof TypeParameters]: LazyArbitrary; + }, + ctx: ArbitraryGenerationContext +]) => LazyArbitrary; +/** + * Returns a LazyArbitrary for the `A` type of the provided schema. + * + * @category arbitrary + * @since 3.10.0 + */ +export declare const makeLazy: (schema: Schema.Schema) => LazyArbitrary; +/** + * Returns a fast-check Arbitrary for the `A` type of the provided schema. + * + * @category arbitrary + * @since 3.10.0 + */ +export declare const make: (schema: Schema.Schema) => FastCheck.Arbitrary; +interface StringConstraints { + readonly _tag: "StringConstraints"; + readonly constraints: FastCheck.StringSharedConstraints; + readonly pattern?: string; +} +interface NumberConstraints { + readonly _tag: "NumberConstraints"; + readonly constraints: FastCheck.FloatConstraints; + readonly isInteger: boolean; +} +interface BigIntConstraints { + readonly _tag: "BigIntConstraints"; + readonly constraints: FastCheck.BigIntConstraints; +} +interface ArrayConstraints { + readonly _tag: "ArrayConstraints"; + readonly constraints: FastCheck.ArrayConstraints; +} +interface DateConstraints { + readonly _tag: "DateConstraints"; + readonly constraints: FastCheck.DateConstraints; +} +export {}; +//# sourceMappingURL=Arbitrary.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Arbitrary.d.ts.map b/backend/node_modules/effect/dist/dts/Arbitrary.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..1f3b665b98e1ae2faa413f2536fffab65f946576 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Arbitrary.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Arbitrary.d.ts","sourceRoot":"","sources":["../../src/Arbitrary.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAO3C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAI1C;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,CAAC,EAAE,EAAE,OAAO,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,GAAG,iBAAiB,GAAG,eAAe,GAAG,gBAAgB,CAAA;CACtH;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,cAAc,SAAS,aAAa,CAAC,GAAG,CAAC,GAAG,SAAS,EAAE,IAAI,CAC5F,GAAG,WAAW,EAAE;IACd,GAAG;QAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,cAAc,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;KAAE;IAC7E,GAAG,EAAE,0BAA0B;CAChC,KACE,aAAa,CAAC,CAAC,CAAC,CAAA;AAErB;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,aAAa,CAAC,CAAC,CAGjF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,SAAS,CAAC,SAAS,CAAC,CAAC,CAAgC,CAAA;AAEpH,UAAU,iBAAiB;IACzB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,uBAAuB,CAAA;IACvD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAC1B;AAwBD,UAAU,iBAAiB;IACzB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,gBAAgB,CAAA;IAChD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAsCD,UAAU,iBAAiB;IACzB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,iBAAiB,CAAA;CAClD;AAoBD,UAAU,gBAAgB;IACxB,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,gBAAgB,CAAA;CACjD;AAoBD,UAAU,eAAe;IACvB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,eAAe,CAAA;CAChD"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Array.d.ts b/backend/node_modules/effect/dist/dts/Array.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..58edc404f0b7190d80f13c8968e1b8efa1d6fd37 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Array.d.ts @@ -0,0 +1,5922 @@ +/** + * This module provides utility functions for working with arrays in TypeScript. + * + * @since 2.0.0 + */ +import * as Either from "./Either.js"; +import * as Equivalence from "./Equivalence.js"; +import type { LazyArg } from "./Function.js"; +import type { TypeLambda } from "./HKT.js"; +import * as Option from "./Option.js"; +import * as Order from "./Order.js"; +import * as Predicate from "./Predicate.js"; +import * as Record from "./Record.js"; +import type { NoInfer, TupleOf } from "./Types.js"; +/** + * @category type lambdas + * @since 2.0.0 + */ +export interface ReadonlyArrayTypeLambda extends TypeLambda { + readonly type: ReadonlyArray; +} +/** + * @category models + * @since 2.0.0 + */ +export type NonEmptyReadonlyArray = readonly [A, ...Array]; +/** + * @category models + * @since 2.0.0 + */ +export type NonEmptyArray = [A, ...Array]; +/** + * Builds a `NonEmptyArray` from an non-empty collection of elements. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.make(1, 2, 3) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const make: >(...elements: Elements) => NonEmptyArray; +/** + * Creates a new `Array` of the specified length. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.allocate(3) + * console.log(result) // [ <3 empty items> ] + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const allocate: (n: number) => Array; +/** + * Return a `NonEmptyArray` of length `n` with element `i` initialized with `f(i)`. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * **Example** + * + * ```ts + * import { makeBy } from "effect/Array" + * + * const result = makeBy(5, n => n * 2) + * console.log(result) // [0, 2, 4, 6, 8] + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const makeBy: { + /** + * Return a `NonEmptyArray` of length `n` with element `i` initialized with `f(i)`. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * **Example** + * + * ```ts + * import { makeBy } from "effect/Array" + * + * const result = makeBy(5, n => n * 2) + * console.log(result) // [0, 2, 4, 6, 8] + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (f: (i: number) => A): (n: number) => NonEmptyArray; + /** + * Return a `NonEmptyArray` of length `n` with element `i` initialized with `f(i)`. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * **Example** + * + * ```ts + * import { makeBy } from "effect/Array" + * + * const result = makeBy(5, n => n * 2) + * console.log(result) // [0, 2, 4, 6, 8] + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (n: number, f: (i: number) => A): NonEmptyArray; +}; +/** + * Return a `NonEmptyArray` containing a range of integers, including both endpoints. + * + * **Example** + * + * ```ts + * import { range } from "effect/Array" + * + * const result = range(1, 3) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const range: (start: number, end: number) => NonEmptyArray; +/** + * Return a `NonEmptyArray` containing a value repeated the specified number of times. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replicate("a", 3) + * console.log(result) // ["a", "a", "a"] + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const replicate: { + /** + * Return a `NonEmptyArray` containing a value repeated the specified number of times. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replicate("a", 3) + * console.log(result) // ["a", "a", "a"] + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (n: number): (a: A) => NonEmptyArray; + /** + * Return a `NonEmptyArray` containing a value repeated the specified number of times. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replicate("a", 3) + * console.log(result) // ["a", "a", "a"] + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (a: A, n: number): NonEmptyArray; +}; +/** + * Creates a new `Array` from an iterable collection of values. + * If the input is already an array, it returns the input as-is. + * Otherwise, it converts the iterable collection to an array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.fromIterable(new Set([1, 2, 3])) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const fromIterable: (collection: Iterable) => Array; +/** + * Creates a new `Array` from a value that might not be an iterable. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.ensure("a")) // ["a"] + * console.log(Array.ensure(["a"])) // ["a"] + * console.log(Array.ensure(["a", "b", "c"])) // ["a", "b", "c"] + * ``` + * + * @category constructors + * @since 3.3.0 + */ +export declare const ensure: (self: ReadonlyArray | A) => Array; +/** + * Takes a record and returns an array of tuples containing its keys and values. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.fromRecord({ a: 1, b: 2, c: 3 }) + * console.log(result) // [["a", 1], ["b", 2], ["c", 3]] + * ``` + * + * @category conversions + * @since 2.0.0 + */ +export declare const fromRecord: (self: Readonly>) => Array<[K, A]>; +/** + * Converts an `Option` to an array. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * console.log(Array.fromOption(Option.some(1))) // [1] + * console.log(Array.fromOption(Option.none())) // [] + * ``` + * + * @category conversions + * @since 2.0.0 + */ +export declare const fromOption: (self: Option.Option) => Array; +/** + * Matches the elements of an array, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const match = Array.match({ + * onEmpty: () => "empty", + * onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}` + * }) + * console.log(match([])) // "empty" + * console.log(match([1, 2, 3])) // "head: 1, tail: 2" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ +export declare const match: { + /** + * Matches the elements of an array, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const match = Array.match({ + * onEmpty: () => "empty", + * onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}` + * }) + * console.log(match([])) // "empty" + * console.log(match([1, 2, 3])) // "head: 1, tail: 2" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (options: { + readonly onEmpty: LazyArg; + readonly onNonEmpty: (self: NonEmptyReadonlyArray) => C; + }): (self: ReadonlyArray) => B | C; + /** + * Matches the elements of an array, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const match = Array.match({ + * onEmpty: () => "empty", + * onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}` + * }) + * console.log(match([])) // "empty" + * console.log(match([1, 2, 3])) // "head: 1, tail: 2" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (self: ReadonlyArray, options: { + readonly onEmpty: LazyArg; + readonly onNonEmpty: (self: NonEmptyReadonlyArray) => C; + }): B | C; +}; +/** + * Matches the elements of an array from the left, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const matchLeft = Array.matchLeft({ + * onEmpty: () => "empty", + * onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}` + * }) + * console.log(matchLeft([])) // "empty" + * console.log(matchLeft([1, 2, 3])) // "head: 1, tail: 2" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ +export declare const matchLeft: { + /** + * Matches the elements of an array from the left, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const matchLeft = Array.matchLeft({ + * onEmpty: () => "empty", + * onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}` + * }) + * console.log(matchLeft([])) // "empty" + * console.log(matchLeft([1, 2, 3])) // "head: 1, tail: 2" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (options: { + readonly onEmpty: LazyArg; + readonly onNonEmpty: (head: A, tail: Array) => C; + }): (self: ReadonlyArray) => B | C; + /** + * Matches the elements of an array from the left, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const matchLeft = Array.matchLeft({ + * onEmpty: () => "empty", + * onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}` + * }) + * console.log(matchLeft([])) // "empty" + * console.log(matchLeft([1, 2, 3])) // "head: 1, tail: 2" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (self: ReadonlyArray, options: { + readonly onEmpty: LazyArg; + readonly onNonEmpty: (head: A, tail: Array) => C; + }): B | C; +}; +/** + * Matches the elements of an array from the right, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const matchRight = Array.matchRight({ + * onEmpty: () => "empty", + * onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}` + * }) + * console.log(matchRight([])) // "empty" + * console.log(matchRight([1, 2, 3])) // "init: 2, last: 3" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ +export declare const matchRight: { + /** + * Matches the elements of an array from the right, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const matchRight = Array.matchRight({ + * onEmpty: () => "empty", + * onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}` + * }) + * console.log(matchRight([])) // "empty" + * console.log(matchRight([1, 2, 3])) // "init: 2, last: 3" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (options: { + readonly onEmpty: LazyArg; + readonly onNonEmpty: (init: Array, last: A) => C; + }): (self: ReadonlyArray) => B | C; + /** + * Matches the elements of an array from the right, applying functions to cases of empty and non-empty arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const matchRight = Array.matchRight({ + * onEmpty: () => "empty", + * onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}` + * }) + * console.log(matchRight([])) // "empty" + * console.log(matchRight([1, 2, 3])) // "init: 2, last: 3" + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (self: ReadonlyArray, options: { + readonly onEmpty: LazyArg; + readonly onNonEmpty: (init: Array, last: A) => C; + }): B | C; +}; +/** + * Prepend an element to the front of an `Iterable`, creating a new `NonEmptyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prepend([2, 3, 4], 1) + * console.log(result) // [1, 2, 3, 4] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prepend: { + /** + * Prepend an element to the front of an `Iterable`, creating a new `NonEmptyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prepend([2, 3, 4], 1) + * console.log(result) // [1, 2, 3, 4] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (head: B): (self: Iterable) => NonEmptyArray; + /** + * Prepend an element to the front of an `Iterable`, creating a new `NonEmptyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prepend([2, 3, 4], 1) + * console.log(result) // [1, 2, 3, 4] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, head: B): NonEmptyArray; +}; +/** + * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable). + * If either array is non-empty, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prependAll([2, 3], [0, 1]) + * console.log(result) // [0, 1, 2, 3] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prependAll: { + /** + * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable). + * If either array is non-empty, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prependAll([2, 3], [0, 1]) + * console.log(result) // [0, 1, 2, 3] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + , T extends Iterable>(that: T): (self: S) => ReadonlyArray.OrNonEmpty | ReadonlyArray.Infer>; + /** + * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable). + * If either array is non-empty, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prependAll([2, 3], [0, 1]) + * console.log(result) // [0, 1, 2, 3] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, that: NonEmptyReadonlyArray): NonEmptyArray; + /** + * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable). + * If either array is non-empty, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prependAll([2, 3], [0, 1]) + * console.log(result) // [0, 1, 2, 3] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, that: Iterable): NonEmptyArray; + /** + * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable). + * If either array is non-empty, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.prependAll([2, 3], [0, 1]) + * console.log(result) // [0, 1, 2, 3] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Array; +}; +/** + * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.append([1, 2, 3], 4); + * console.log(result) // [1, 2, 3, 4] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const append: { + /** + * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.append([1, 2, 3], 4); + * console.log(result) // [1, 2, 3, 4] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (last: B): (self: Iterable) => NonEmptyArray; + /** + * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.append([1, 2, 3], 4); + * console.log(result) // [1, 2, 3, 4] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, last: B): NonEmptyArray; +}; +/** + * Concatenates two arrays (or iterables), combining their elements. + * If either array is non-empty, the result is also a non-empty array. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const appendAll: { + /** + * Concatenates two arrays (or iterables), combining their elements. + * If either array is non-empty, the result is also a non-empty array. + * + * @category concatenating + * @since 2.0.0 + */ + , T extends Iterable>(that: T): (self: S) => ReadonlyArray.OrNonEmpty | ReadonlyArray.Infer>; + /** + * Concatenates two arrays (or iterables), combining their elements. + * If either array is non-empty, the result is also a non-empty array. + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, that: NonEmptyReadonlyArray): NonEmptyArray; + /** + * Concatenates two arrays (or iterables), combining their elements. + * If either array is non-empty, the result is also a non-empty array. + * + * @category concatenating + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, that: Iterable): NonEmptyArray; + /** + * Concatenates two arrays (or iterables), combining their elements. + * If either array is non-empty, the result is also a non-empty array. + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Array; +}; +/** + * Accumulates values from an `Iterable` starting from the left, storing + * each intermediate result in an array. Useful for tracking the progression of + * a value through a series of transformations. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value) + * console.log(result) // [0, 1, 3, 6, 10] + * + * // Explanation: + * // This function starts with the initial value (0 in this case) + * // and adds each element of the array to this accumulator one by one, + * // keeping track of the cumulative sum after each addition. + * // Each of these sums is captured in the resulting array. + * ``` + * + * @category folding + * @since 2.0.0 + */ +export declare const scan: { + /** + * Accumulates values from an `Iterable` starting from the left, storing + * each intermediate result in an array. Useful for tracking the progression of + * a value through a series of transformations. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value) + * console.log(result) // [0, 1, 3, 6, 10] + * + * // Explanation: + * // This function starts with the initial value (0 in this case) + * // and adds each element of the array to this accumulator one by one, + * // keeping track of the cumulative sum after each addition. + * // Each of these sums is captured in the resulting array. + * ``` + * + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A) => B): (self: Iterable) => NonEmptyArray; + /** + * Accumulates values from an `Iterable` starting from the left, storing + * each intermediate result in an array. Useful for tracking the progression of + * a value through a series of transformations. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value) + * console.log(result) // [0, 1, 3, 6, 10] + * + * // Explanation: + * // This function starts with the initial value (0 in this case) + * // and adds each element of the array to this accumulator one by one, + * // keeping track of the cumulative sum after each addition. + * // Each of these sums is captured in the resulting array. + * ``` + * + * @category folding + * @since 2.0.0 + */ + (self: Iterable, b: B, f: (b: B, a: A) => B): NonEmptyArray; +}; +/** + * Accumulates values from an `Iterable` starting from the right, storing + * each intermediate result in an array. Useful for tracking the progression of + * a value through a series of transformations. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value) + * console.log(result) // [10, 9, 7, 4, 0] + * ``` + * + * @category folding + * @since 2.0.0 + */ +export declare const scanRight: { + /** + * Accumulates values from an `Iterable` starting from the right, storing + * each intermediate result in an array. Useful for tracking the progression of + * a value through a series of transformations. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value) + * console.log(result) // [10, 9, 7, 4, 0] + * ``` + * + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A) => B): (self: Iterable) => NonEmptyArray; + /** + * Accumulates values from an `Iterable` starting from the right, storing + * each intermediate result in an array. Useful for tracking the progression of + * a value through a series of transformations. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value) + * console.log(result) // [10, 9, 7, 4, 0] + * ``` + * + * @category folding + * @since 2.0.0 + */ + (self: Iterable, b: B, f: (b: B, a: A) => B): NonEmptyArray; +}; +/** + * Determine if `unknown` is an Array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.isArray(null)) // false + * console.log(Array.isArray([1, 2, 3])) // true + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isArray: { + /** + * Determine if `unknown` is an Array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.isArray(null)) // false + * console.log(Array.isArray([1, 2, 3])) // true + * ``` + * + * @category guards + * @since 2.0.0 + */ + (self: unknown): self is Array; + /** + * Determine if `unknown` is an Array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.isArray(null)) // false + * console.log(Array.isArray([1, 2, 3])) // true + * ``` + * + * @category guards + * @since 2.0.0 + */ + (self: T): self is Extract>; +}; +/** + * Determine if an `Array` is empty narrowing down the type to `[]`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.isEmptyArray([])) // true + * console.log(Array.isEmptyArray([1, 2, 3])) // false + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isEmptyArray: (self: Array) => self is []; +/** + * Determine if a `ReadonlyArray` is empty narrowing down the type to `readonly []`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.isEmptyReadonlyArray([])) // true + * console.log(Array.isEmptyReadonlyArray([1, 2, 3])) // false + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isEmptyReadonlyArray: (self: ReadonlyArray) => self is readonly []; +/** + * Determine if an `Array` is non empty narrowing down the type to `NonEmptyArray`. + * + * An `Array` is considered to be a `NonEmptyArray` if it contains at least one element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.isNonEmptyArray([])) // false + * console.log(Array.isNonEmptyArray([1, 2, 3])) // true + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isNonEmptyArray: (self: Array) => self is NonEmptyArray; +/** + * Determine if a `ReadonlyArray` is non empty narrowing down the type to `NonEmptyReadonlyArray`. + * + * A `ReadonlyArray` is considered to be a `NonEmptyReadonlyArray` if it contains at least one element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * console.log(Array.isNonEmptyReadonlyArray([])) // false + * console.log(Array.isNonEmptyReadonlyArray([1, 2, 3])) // true + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isNonEmptyReadonlyArray: (self: ReadonlyArray) => self is NonEmptyReadonlyArray; +/** + * Return the number of elements in a `ReadonlyArray`. + * + * @category getters + * @since 2.0.0 + */ +export declare const length: (self: ReadonlyArray) => number; +/** + * This function provides a safe way to read a value at a particular index from a `ReadonlyArray`. + * + * @category getters + * @since 2.0.0 + */ +export declare const get: { + /** + * This function provides a safe way to read a value at a particular index from a `ReadonlyArray`. + * + * @category getters + * @since 2.0.0 + */ + (index: number): (self: ReadonlyArray) => Option.Option; + /** + * This function provides a safe way to read a value at a particular index from a `ReadonlyArray`. + * + * @category getters + * @since 2.0.0 + */ + (self: ReadonlyArray, index: number): Option.Option; +}; +/** + * Gets an element unsafely, will throw on out of bounds. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeGet: { + /** + * Gets an element unsafely, will throw on out of bounds. + * + * @since 2.0.0 + * @category unsafe + */ + (index: number): (self: ReadonlyArray) => A; + /** + * Gets an element unsafely, will throw on out of bounds. + * + * @since 2.0.0 + * @category unsafe + */ + (self: ReadonlyArray, index: number): A; +}; +/** + * Return a tuple containing the first element, and a new `Array` of the remaining elements, if any. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.unprepend([1, 2, 3, 4]) + * console.log(result) // [1, [2, 3, 4]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ +export declare const unprepend: (self: NonEmptyReadonlyArray) => [firstElement: A, remainingElements: Array]; +/** + * Return a tuple containing a copy of the `NonEmptyReadonlyArray` without its last element, and that last element. + * + * **Example** + * + * ```ts + * import { Array } from "effect"; + * + * const result = Array.unappend([1, 2, 3, 4]) + * console.log(result) // [[1, 2, 3], 4] + * ``` + * + * @category splitting + * @since 2.0.0 + */ +export declare const unappend: (self: NonEmptyReadonlyArray) => [arrayWithoutLastElement: Array, lastElement: A]; +/** + * Get the first element of a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty. + * + * @category getters + * @since 2.0.0 + */ +export declare const head: (self: ReadonlyArray) => Option.Option; +/** + * Get the first element of a non empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.headNonEmpty([1, 2, 3, 4]) + * console.log(result) // 1 + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const headNonEmpty: (self: NonEmptyReadonlyArray) => A; +/** + * Get the last element in a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty. + * + * @category getters + * @since 2.0.0 + */ +export declare const last: (self: ReadonlyArray) => Option.Option; +/** + * Get the last element of a non empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.lastNonEmpty([1, 2, 3, 4]) + * console.log(result) // 4 + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const lastNonEmpty: (self: NonEmptyReadonlyArray) => A; +/** + * Get all but the first element of an `Iterable`, creating a new `Array`, or `None` if the `Iterable` is empty. + * + * @category getters + * @since 2.0.0 + */ +export declare const tail: (self: Iterable) => Option.Option>; +/** + * Get all but the first element of a `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.tailNonEmpty([1, 2, 3, 4]) + * console.log(result) // [2, 3, 4] + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const tailNonEmpty: (self: NonEmptyReadonlyArray) => Array; +/** + * Get all but the last element of an `Iterable`, creating a new `Array`, or `None` if the `Iterable` is empty. + * + * @category getters + * @since 2.0.0 + */ +export declare const init: (self: Iterable) => Option.Option>; +/** + * Get all but the last element of a non empty array, creating a new array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.initNonEmpty([1, 2, 3, 4]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const initNonEmpty: (self: NonEmptyReadonlyArray) => Array; +/** + * Keep only a max number of elements from the start of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.take([1, 2, 3, 4, 5], 3) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const take: { + /** + * Keep only a max number of elements from the start of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.take([1, 2, 3, 4, 5], 3) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (n: number): (self: Iterable) => Array; + /** + * Keep only a max number of elements from the start of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.take([1, 2, 3, 4, 5], 3) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, n: number): Array; +}; +/** + * Keep only a max number of elements from the end of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeRight([1, 2, 3, 4, 5], 3) + * console.log(result) // [3, 4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const takeRight: { + /** + * Keep only a max number of elements from the end of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeRight([1, 2, 3, 4, 5], 3) + * console.log(result) // [3, 4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (n: number): (self: Iterable) => Array; + /** + * Keep only a max number of elements from the end of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeRight([1, 2, 3, 4, 5], 3) + * console.log(result) // [3, 4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, n: number): Array; +}; +/** + * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeWhile([1, 3, 2, 4, 1, 2], x => x < 4) + * console.log(result) // [1, 3, 2] + * + * // Explanation: + * // - The function starts with the first element (`1`), which is less than `4`, so it adds `1` to the result. + * // - The next element (`3`) is also less than `4`, so it adds `3`. + * // - The next element (`2`) is again less than `4`, so it adds `2`. + * // - The function then encounters `4`, which is not less than `4`. At this point, it stops checking further elements and finalizes the result. + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const takeWhile: { + /** + * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeWhile([1, 3, 2, 4, 1, 2], x => x < 4) + * console.log(result) // [1, 3, 2] + * + * // Explanation: + * // - The function starts with the first element (`1`), which is less than `4`, so it adds `1` to the result. + * // - The next element (`3`) is also less than `4`, so it adds `3`. + * // - The next element (`2`) is again less than `4`, so it adds `2`. + * // - The function then encounters `4`, which is not less than `4`. At this point, it stops checking further elements and finalizes the result. + * ``` + * + * @category getters + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Array; + /** + * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeWhile([1, 3, 2, 4, 1, 2], x => x < 4) + * console.log(result) // [1, 3, 2] + * + * // Explanation: + * // - The function starts with the first element (`1`), which is less than `4`, so it adds `1` to the result. + * // - The next element (`3`) is also less than `4`, so it adds `3`. + * // - The next element (`2`) is again less than `4`, so it adds `2`. + * // - The function then encounters `4`, which is not less than `4`. At this point, it stops checking further elements and finalizes the result. + * ``` + * + * @category getters + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Array; + /** + * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeWhile([1, 3, 2, 4, 1, 2], x => x < 4) + * console.log(result) // [1, 3, 2] + * + * // Explanation: + * // - The function starts with the first element (`1`), which is less than `4`, so it adds `1` to the result. + * // - The next element (`3`) is also less than `4`, so it adds `3`. + * // - The next element (`2`) is again less than `4`, so it adds `2`. + * // - The function then encounters `4`, which is not less than `4`. At this point, it stops checking further elements and finalizes the result. + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Array; + /** + * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.takeWhile([1, 3, 2, 4, 1, 2], x => x < 4) + * console.log(result) // [1, 3, 2] + * + * // Explanation: + * // - The function starts with the first element (`1`), which is less than `4`, so it adds `1` to the result. + * // - The next element (`3`) is also less than `4`, so it adds `3`. + * // - The next element (`2`) is again less than `4`, so it adds `2`. + * // - The function then encounters `4`, which is not less than `4`. At this point, it stops checking further elements and finalizes the result. + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Array; +}; +/** + * Split an `Iterable` into two parts: + * + * 1. the longest initial subarray for which all elements satisfy the specified predicate + * 2. the remaining elements + * + * @category splitting + * @since 2.0.0 + */ +export declare const span: { + /** + * Split an `Iterable` into two parts: + * + * 1. the longest initial subarray for which all elements satisfy the specified predicate + * 2. the remaining elements + * + * @category splitting + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => [init: Array, rest: Array>]; + /** + * Split an `Iterable` into two parts: + * + * 1. the longest initial subarray for which all elements satisfy the specified predicate + * 2. the remaining elements + * + * @category splitting + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => [init: Array, rest: Array]; + /** + * Split an `Iterable` into two parts: + * + * 1. the longest initial subarray for which all elements satisfy the specified predicate + * 2. the remaining elements + * + * @category splitting + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): [init: Array, rest: Array>]; + /** + * Split an `Iterable` into two parts: + * + * 1. the longest initial subarray for which all elements satisfy the specified predicate + * 2. the remaining elements + * + * @category splitting + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): [init: Array, rest: Array]; +}; +/** + * Drop a max number of elements from the start of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.drop([1, 2, 3, 4, 5], 2) + * console.log(result) // [3, 4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const drop: { + /** + * Drop a max number of elements from the start of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.drop([1, 2, 3, 4, 5], 2) + * console.log(result) // [3, 4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (n: number): (self: Iterable) => Array; + /** + * Drop a max number of elements from the start of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.drop([1, 2, 3, 4, 5], 2) + * console.log(result) // [3, 4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, n: number): Array; +}; +/** + * Drop a max number of elements from the end of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dropRight([1, 2, 3, 4, 5], 2) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const dropRight: { + /** + * Drop a max number of elements from the end of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dropRight([1, 2, 3, 4, 5], 2) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (n: number): (self: Iterable) => Array; + /** + * Drop a max number of elements from the end of an `Iterable`, creating a new `Array`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dropRight([1, 2, 3, 4, 5], 2) + * console.log(result) // [1, 2, 3] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, n: number): Array; +}; +/** + * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dropWhile([1, 2, 3, 4, 5], x => x < 4) + * console.log(result) // [4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const dropWhile: { + /** + * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dropWhile([1, 2, 3, 4, 5], x => x < 4) + * console.log(result) // [4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Array; + /** + * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dropWhile([1, 2, 3, 4, 5], x => x < 4) + * console.log(result) // [4, 5] + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Array; +}; +/** + * Return the first index for which a predicate holds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstIndex([5, 3, 8, 9], x => x > 5) + * console.log(result) // Option.some(2) + * ``` + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirstIndex: { + /** + * Return the first index for which a predicate holds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstIndex([5, 3, 8, 9], x => x > 5) + * console.log(result) // Option.some(2) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Option.Option; + /** + * Return the first index for which a predicate holds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstIndex([5, 3, 8, 9], x => x > 5) + * console.log(result) // Option.some(2) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Option.Option; +}; +/** + * Return the last index for which a predicate holds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLastIndex([1, 3, 8, 9], x => x < 5) + * console.log(result) // Option.some(1) + * ``` + * + * @category elements + * @since 2.0.0 + */ +export declare const findLastIndex: { + /** + * Return the last index for which a predicate holds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLastIndex([1, 3, 8, 9], x => x < 5) + * console.log(result) // Option.some(1) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Option.Option; + /** + * Return the last index for which a predicate holds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLastIndex([1, 3, 8, 9], x => x < 5) + * console.log(result) // Option.some(1) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Option.Option; +}; +/** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirst: { + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (f: (a: NoInfer, i: number) => Option.Option): (self: Iterable) => Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option.Option): Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Option.Option; +}; +/** + * Finds the last element in an iterable collection that satisfies the given predicate or refinement. + * Returns an `Option` containing the found element, or `Option.none` if no element matches. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ +export declare const findLast: { + /** + * Finds the last element in an iterable collection that satisfies the given predicate or refinement. + * Returns an `Option` containing the found element, or `Option.none` if no element matches. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (f: (a: NoInfer, i: number) => Option.Option): (self: Iterable) => Option.Option; + /** + * Finds the last element in an iterable collection that satisfies the given predicate or refinement. + * Returns an `Option` containing the found element, or `Option.none` if no element matches. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Option.Option; + /** + * Finds the last element in an iterable collection that satisfies the given predicate or refinement. + * Returns an `Option` containing the found element, or `Option.none` if no element matches. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Option.Option; + /** + * Finds the last element in an iterable collection that satisfies the given predicate or refinement. + * Returns an `Option` containing the found element, or `Option.none` if no element matches. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option.Option): Option.Option; + /** + * Finds the last element in an iterable collection that satisfies the given predicate or refinement. + * Returns an `Option` containing the found element, or `Option.none` if no element matches. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Option.Option; + /** + * Finds the last element in an iterable collection that satisfies the given predicate or refinement. + * Returns an `Option` containing the found element, or `Option.none` if no element matches. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // Option.some(4) + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Option.Option; +}; +/** + * Returns a tuple of the first element that satisfies the specified + * predicate and its index, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some([4, 3]) + * ``` + * + * @category elements + * @since 3.17.0 + */ +export declare const findFirstWithIndex: { + /** + * Returns a tuple of the first element that satisfies the specified + * predicate and its index, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some([4, 3]) + * ``` + * + * @category elements + * @since 3.17.0 + */ + (f: (a: NoInfer, i: number) => Option.Option): (self: Iterable) => Option.Option<[B, number]>; + /** + * Returns a tuple of the first element that satisfies the specified + * predicate and its index, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some([4, 3]) + * ``` + * + * @category elements + * @since 3.17.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Option.Option<[B, number]>; + /** + * Returns a tuple of the first element that satisfies the specified + * predicate and its index, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some([4, 3]) + * ``` + * + * @category elements + * @since 3.17.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Option.Option<[A, number]>; + /** + * Returns a tuple of the first element that satisfies the specified + * predicate and its index, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some([4, 3]) + * ``` + * + * @category elements + * @since 3.17.0 + */ + (self: Iterable, f: (a: A, i: number) => Option.Option): Option.Option<[B, number]>; + /** + * Returns a tuple of the first element that satisfies the specified + * predicate and its index, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some([4, 3]) + * ``` + * + * @category elements + * @since 3.17.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Option.Option<[B, number]>; + /** + * Returns a tuple of the first element that satisfies the specified + * predicate and its index, or `None` if no such element exists. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.findFirstWithIndex([1, 2, 3, 4, 5], x => x > 3) + * console.log(result) // Option.some([4, 3]) + * ``` + * + * @category elements + * @since 3.17.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Option.Option<[A, number]>; +}; +/** + * Counts all the element of the given array that pass the given predicate + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.countBy([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // 2 + * ``` + * + * @category folding + * @since 3.16.0 + */ +export declare const countBy: { + /** + * Counts all the element of the given array that pass the given predicate + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.countBy([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // 2 + * ``` + * + * @category folding + * @since 3.16.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => number; + /** + * Counts all the element of the given array that pass the given predicate + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.countBy([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // 2 + * ``` + * + * @category folding + * @since 3.16.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): number; +}; +/** + * Insert an element at the specified index, creating a new `NonEmptyArray`, + * or return `None` if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.insertAt(['a', 'b', 'c', 'e'], 3, 'd') + * console.log(result) // Option.some(['a', 'b', 'c', 'd', 'e']) + * ``` + * + * @since 2.0.0 + */ +export declare const insertAt: { + /** + * Insert an element at the specified index, creating a new `NonEmptyArray`, + * or return `None` if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.insertAt(['a', 'b', 'c', 'e'], 3, 'd') + * console.log(result) // Option.some(['a', 'b', 'c', 'd', 'e']) + * ``` + * + * @since 2.0.0 + */ + (i: number, b: B): (self: Iterable) => Option.Option>; + /** + * Insert an element at the specified index, creating a new `NonEmptyArray`, + * or return `None` if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.insertAt(['a', 'b', 'c', 'e'], 3, 'd') + * console.log(result) // Option.some(['a', 'b', 'c', 'd', 'e']) + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, i: number, b: B): Option.Option>; +}; +/** + * Change the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replace(['a', 'b', 'c', 'd'], 1, 'z') + * console.log(result) // ['a', 'z', 'c', 'd'] + * ``` + * + * @since 2.0.0 + */ +export declare const replace: { + /** + * Change the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replace(['a', 'b', 'c', 'd'], 1, 'z') + * console.log(result) // ['a', 'z', 'c', 'd'] + * ``` + * + * @since 2.0.0 + */ + (i: number, b: B): = Iterable>(self: S) => ReadonlyArray.With | B>; + /** + * Change the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replace(['a', 'b', 'c', 'd'], 1, 'z') + * console.log(result) // ['a', 'z', 'c', 'd'] + * ``` + * + * @since 2.0.0 + */ + = Iterable>(self: S, i: number, b: B): ReadonlyArray.With | B>; +}; +/** + * Replaces an element in an array with the given value, returning an option of the updated array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replaceOption([1, 2, 3], 1, 4) + * console.log(result) // Option.some([1, 4, 3]) + * ``` + * + * @since 2.0.0 + */ +export declare const replaceOption: { + /** + * Replaces an element in an array with the given value, returning an option of the updated array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replaceOption([1, 2, 3], 1, 4) + * console.log(result) // Option.some([1, 4, 3]) + * ``` + * + * @since 2.0.0 + */ + (i: number, b: B): = Iterable>(self: S) => Option.Option | B>>; + /** + * Replaces an element in an array with the given value, returning an option of the updated array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.replaceOption([1, 2, 3], 1, 4) + * console.log(result) // Option.some([1, 4, 3]) + * ``` + * + * @since 2.0.0 + */ + = Iterable>(self: S, i: number, b: B): Option.Option | B>>; +}; +/** + * Apply a function to the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modify([1, 2, 3, 4], 2, (n) => n * 2) + * console.log(result) // [1, 2, 6, 4] + * ``` + * + * @since 2.0.0 + */ +export declare const modify: { + /** + * Apply a function to the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modify([1, 2, 3, 4], 2, (n) => n * 2) + * console.log(result) // [1, 2, 6, 4] + * ``` + * + * @since 2.0.0 + */ + = Iterable>(i: number, f: (a: ReadonlyArray.Infer) => B): (self: S) => ReadonlyArray.With | B>; + /** + * Apply a function to the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modify([1, 2, 3, 4], 2, (n) => n * 2) + * console.log(result) // [1, 2, 6, 4] + * ``` + * + * @since 2.0.0 + */ + = Iterable>(self: S, i: number, f: (a: ReadonlyArray.Infer) => B): ReadonlyArray.With | B>; +}; +/** + * Apply a function to the element at the specified index, creating a new `Array`, + * or return `None` if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const input = [1, 2, 3, 4] + * const result = Array.modifyOption(input, 2, (n) => n * 2) + * console.log(result) // Option.some([1, 2, 6, 4]) + * + * const outOfBoundsResult = Array.modifyOption(input, 5, (n) => n * 2) + * console.log(outOfBoundsResult) // Option.none() + * ``` + * + * @since 2.0.0 + */ +export declare const modifyOption: { + /** + * Apply a function to the element at the specified index, creating a new `Array`, + * or return `None` if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const input = [1, 2, 3, 4] + * const result = Array.modifyOption(input, 2, (n) => n * 2) + * console.log(result) // Option.some([1, 2, 6, 4]) + * + * const outOfBoundsResult = Array.modifyOption(input, 5, (n) => n * 2) + * console.log(outOfBoundsResult) // Option.none() + * ``` + * + * @since 2.0.0 + */ + = Iterable>(i: number, f: (a: ReadonlyArray.Infer) => B): (self: S) => Option.Option | B>>; + /** + * Apply a function to the element at the specified index, creating a new `Array`, + * or return `None` if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const input = [1, 2, 3, 4] + * const result = Array.modifyOption(input, 2, (n) => n * 2) + * console.log(result) // Option.some([1, 2, 6, 4]) + * + * const outOfBoundsResult = Array.modifyOption(input, 5, (n) => n * 2) + * console.log(outOfBoundsResult) // Option.none() + * ``` + * + * @since 2.0.0 + */ + = Iterable>(self: S, i: number, f: (a: ReadonlyArray.Infer) => B): Option.Option | B>>; +}; +/** + * Delete the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const input = [1, 2, 3, 4] + * const result = Array.remove(input, 2) + * console.log(result) // [1, 2, 4] + * + * const outOfBoundsResult = Array.remove(input, 5) + * console.log(outOfBoundsResult) // [1, 2, 3, 4] + * ``` + * + * @since 2.0.0 + */ +export declare const remove: { + /** + * Delete the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const input = [1, 2, 3, 4] + * const result = Array.remove(input, 2) + * console.log(result) // [1, 2, 4] + * + * const outOfBoundsResult = Array.remove(input, 5) + * console.log(outOfBoundsResult) // [1, 2, 3, 4] + * ``` + * + * @since 2.0.0 + */ + (i: number): (self: Iterable) => Array; + /** + * Delete the element at the specified index, creating a new `Array`, + * or return a copy of the input if the index is out of bounds. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const input = [1, 2, 3, 4] + * const result = Array.remove(input, 2) + * console.log(result) // [1, 2, 4] + * + * const outOfBoundsResult = Array.remove(input, 5) + * console.log(outOfBoundsResult) // [1, 2, 3, 4] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, i: number): Array; +}; +/** + * Delete the element at the specified index, creating a new `Array`, + * or return `None` if the index is out of bounds. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Array, Option } from "effect" + * + * const numbers = [1, 2, 3, 4] + * const result = Array.removeOption(numbers, 2) + * assert.deepStrictEqual(result, Option.some([1, 2, 4])) + * + * const outOfBoundsResult = Array.removeOption(numbers, 5) + * assert.deepStrictEqual(outOfBoundsResult, Option.none()) + * ``` + * + * @since 3.16.0 + */ +export declare const removeOption: { + /** + * Delete the element at the specified index, creating a new `Array`, + * or return `None` if the index is out of bounds. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Array, Option } from "effect" + * + * const numbers = [1, 2, 3, 4] + * const result = Array.removeOption(numbers, 2) + * assert.deepStrictEqual(result, Option.some([1, 2, 4])) + * + * const outOfBoundsResult = Array.removeOption(numbers, 5) + * assert.deepStrictEqual(outOfBoundsResult, Option.none()) + * ``` + * + * @since 3.16.0 + */ + (i: number): (self: Iterable) => Option.Option>; + /** + * Delete the element at the specified index, creating a new `Array`, + * or return `None` if the index is out of bounds. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Array, Option } from "effect" + * + * const numbers = [1, 2, 3, 4] + * const result = Array.removeOption(numbers, 2) + * assert.deepStrictEqual(result, Option.some([1, 2, 4])) + * + * const outOfBoundsResult = Array.removeOption(numbers, 5) + * assert.deepStrictEqual(outOfBoundsResult, Option.none()) + * ``` + * + * @since 3.16.0 + */ + (self: Iterable, i: number): Option.Option>; +}; +/** + * Reverse an `Iterable`, creating a new `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.reverse([1, 2, 3, 4]) + * console.log(result) // [4, 3, 2, 1] + * ``` + * + * @category elements + * @since 2.0.0 + */ +export declare const reverse: >(self: S) => S extends NonEmptyReadonlyArray ? NonEmptyArray : S extends Iterable ? Array : never; +/** + * Create a new array with elements sorted in increasing order based on the specified comparator. + * If the input is a `NonEmptyReadonlyArray`, the output will also be a `NonEmptyReadonlyArray`. + * + * @category sorting + * @since 2.0.0 + */ +export declare const sort: { + /** + * Create a new array with elements sorted in increasing order based on the specified comparator. + * If the input is a `NonEmptyReadonlyArray`, the output will also be a `NonEmptyReadonlyArray`. + * + * @category sorting + * @since 2.0.0 + */ + (O: Order.Order): >(self: S) => ReadonlyArray.With>; + /** + * Create a new array with elements sorted in increasing order based on the specified comparator. + * If the input is a `NonEmptyReadonlyArray`, the output will also be a `NonEmptyReadonlyArray`. + * + * @category sorting + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, O: Order.Order): NonEmptyArray; + /** + * Create a new array with elements sorted in increasing order based on the specified comparator. + * If the input is a `NonEmptyReadonlyArray`, the output will also be a `NonEmptyReadonlyArray`. + * + * @category sorting + * @since 2.0.0 + */ + (self: Iterable, O: Order.Order): Array; +}; +/** + * Sorts an array based on a provided mapping function and order. The mapping + * function transforms the elements into a value that can be compared, and the + * order defines how those values should be sorted. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.number) + * console.log(result) // ["b", "cc", "aaa"] + * + * // Explanation: + * // The array of strings is sorted based on their lengths. The mapping function `(s) => s.length` + * // converts each string into its length, and the `Order.number` specifies that the lengths should + * // be sorted in ascending order. + * ``` + * + * @since 2.0.0 + * @category elements + */ +export declare const sortWith: { + /** + * Sorts an array based on a provided mapping function and order. The mapping + * function transforms the elements into a value that can be compared, and the + * order defines how those values should be sorted. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.number) + * console.log(result) // ["b", "cc", "aaa"] + * + * // Explanation: + * // The array of strings is sorted based on their lengths. The mapping function `(s) => s.length` + * // converts each string into its length, and the `Order.number` specifies that the lengths should + * // be sorted in ascending order. + * ``` + * + * @since 2.0.0 + * @category elements + */ + , B>(f: (a: ReadonlyArray.Infer) => B, order: Order.Order): (self: S) => ReadonlyArray.With>; + /** + * Sorts an array based on a provided mapping function and order. The mapping + * function transforms the elements into a value that can be compared, and the + * order defines how those values should be sorted. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.number) + * console.log(result) // ["b", "cc", "aaa"] + * + * // Explanation: + * // The array of strings is sorted based on their lengths. The mapping function `(s) => s.length` + * // converts each string into its length, and the `Order.number` specifies that the lengths should + * // be sorted in ascending order. + * ``` + * + * @since 2.0.0 + * @category elements + */ + (self: NonEmptyReadonlyArray, f: (a: A) => B, O: Order.Order): NonEmptyArray; + /** + * Sorts an array based on a provided mapping function and order. The mapping + * function transforms the elements into a value that can be compared, and the + * order defines how those values should be sorted. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.number) + * console.log(result) // ["b", "cc", "aaa"] + * + * // Explanation: + * // The array of strings is sorted based on their lengths. The mapping function `(s) => s.length` + * // converts each string into its length, and the `Order.number` specifies that the lengths should + * // be sorted in ascending order. + * ``` + * + * @since 2.0.0 + * @category elements + */ + (self: Iterable, f: (a: A) => B, order: Order.Order): Array; +}; +/** + * Sorts the elements of an `Iterable` in increasing order based on the provided + * orders. The elements are compared using the first order in `orders`, then the + * second order if the first comparison is equal, and so on. + * + * **Example** + * + * ```ts + * import { Array, Order, pipe } from "effect" + * + * const users = [ + * { name: "Alice", age: 30 }, + * { name: "Bob", age: 25 }, + * { name: "Charlie", age: 30 } + * ] + * + * const result = pipe( + * users, + * Array.sortBy( + * Order.mapInput(Order.number, (user: (typeof users)[number]) => user.age), + * Order.mapInput(Order.string, (user: (typeof users)[number]) => user.name) + * ) + * ) + * + * console.log(result) + * // [ + * // { name: "Bob", age: 25 }, + * // { name: "Alice", age: 30 }, + * // { name: "Charlie", age: 30 } + * // ] + * + * // Explanation: + * // The array of users is sorted first by age in ascending order. When ages are equal, + * // the users are further sorted by name in ascending order. + * ``` + * + * @category sorting + * @since 2.0.0 + */ +export declare const sortBy: >(...orders: ReadonlyArray>>) => (self: S) => S extends NonEmptyReadonlyArray ? NonEmptyArray : S extends Iterable ? Array : never; +/** + * Takes two `Iterable`s and returns an `Array` of corresponding pairs. + * If one input `Iterable` is short, excess elements of the + * longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zip([1, 2, 3], ['a', 'b']) + * console.log(result) // [[1, 'a'], [2, 'b']] + * ``` + * + * @category zipping + * @since 2.0.0 + */ +export declare const zip: { + /** + * Takes two `Iterable`s and returns an `Array` of corresponding pairs. + * If one input `Iterable` is short, excess elements of the + * longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zip([1, 2, 3], ['a', 'b']) + * console.log(result) // [[1, 'a'], [2, 'b']] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (that: NonEmptyReadonlyArray): (self: NonEmptyReadonlyArray) => NonEmptyArray<[A, B]>; + /** + * Takes two `Iterable`s and returns an `Array` of corresponding pairs. + * If one input `Iterable` is short, excess elements of the + * longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zip([1, 2, 3], ['a', 'b']) + * console.log(result) // [[1, 'a'], [2, 'b']] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (that: Iterable): (self: Iterable) => Array<[A, B]>; + /** + * Takes two `Iterable`s and returns an `Array` of corresponding pairs. + * If one input `Iterable` is short, excess elements of the + * longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zip([1, 2, 3], ['a', 'b']) + * console.log(result) // [[1, 'a'], [2, 'b']] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, that: NonEmptyReadonlyArray): NonEmptyArray<[A, B]>; + /** + * Takes two `Iterable`s and returns an `Array` of corresponding pairs. + * If one input `Iterable` is short, excess elements of the + * longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zip([1, 2, 3], ['a', 'b']) + * console.log(result) // [[1, 'a'], [2, 'b']] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Array<[A, B]>; +}; +/** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) + * console.log(result) // [5, 7, 9] + * ``` + * + * @category zipping + * @since 2.0.0 + */ +export declare const zipWith: { + /** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) + * console.log(result) // [5, 7, 9] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (that: NonEmptyReadonlyArray, f: (a: A, b: B) => C): (self: NonEmptyReadonlyArray) => NonEmptyArray; + /** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) + * console.log(result) // [5, 7, 9] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (that: Iterable, f: (a: A, b: B) => C): (self: Iterable) => Array; + /** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) + * console.log(result) // [5, 7, 9] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, that: NonEmptyReadonlyArray, f: (a: A, b: B) => C): NonEmptyArray; + /** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) + * console.log(result) // [5, 7, 9] + * ``` + * + * @category zipping + * @since 2.0.0 + */ + (self: Iterable, that: Iterable, f: (a: A, b: B) => C): Array; +}; +/** + * This function is the inverse of `zip`. Takes an `Iterable` of pairs and return two corresponding `Array`s. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.unzip([[1, "a"], [2, "b"], [3, "c"]]) + * console.log(result) // [[1, 2, 3], ['a', 'b', 'c']] + * ``` + * + * @since 2.0.0 + */ +export declare const unzip: >(self: S) => S extends NonEmptyReadonlyArray ? [NonEmptyArray, NonEmptyArray] : S extends Iterable ? [Array, Array] : never; +/** + * Places an element in between members of an `Iterable`. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.intersperse([1, 2, 3], 0) + * console.log(result) // [1, 0, 2, 0, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const intersperse: { + /** + * Places an element in between members of an `Iterable`. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.intersperse([1, 2, 3], 0) + * console.log(result) // [1, 0, 2, 0, 3] + * ``` + * + * @since 2.0.0 + */ + (middle: B): >(self: S) => ReadonlyArray.With | B>; + /** + * Places an element in between members of an `Iterable`. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.intersperse([1, 2, 3], 0) + * console.log(result) // [1, 0, 2, 0, 3] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, middle: B): NonEmptyArray; + /** + * Places an element in between members of an `Iterable`. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.intersperse([1, 2, 3], 0) + * console.log(result) // [1, 0, 2, 0, 3] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, middle: B): Array; +}; +/** + * Apply a function to the head, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modifyNonEmptyHead([1, 2, 3], n => n * 10) + * console.log(result) // [10, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const modifyNonEmptyHead: { + /** + * Apply a function to the head, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modifyNonEmptyHead([1, 2, 3], n => n * 10) + * console.log(result) // [10, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (f: (a: A) => B): (self: NonEmptyReadonlyArray) => NonEmptyArray; + /** + * Apply a function to the head, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modifyNonEmptyHead([1, 2, 3], n => n * 10) + * console.log(result) // [10, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, f: (a: A) => B): NonEmptyArray; +}; +/** + * Change the head, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.setNonEmptyHead([1, 2, 3], 10) + * console.log(result) // [10, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const setNonEmptyHead: { + /** + * Change the head, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.setNonEmptyHead([1, 2, 3], 10) + * console.log(result) // [10, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (b: B): (self: NonEmptyReadonlyArray) => NonEmptyArray; + /** + * Change the head, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.setNonEmptyHead([1, 2, 3], 10) + * console.log(result) // [10, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, b: B): NonEmptyArray; +}; +/** + * Apply a function to the last element, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modifyNonEmptyLast([1, 2, 3], n => n * 2) + * console.log(result) // [1, 2, 6] + * ``` + * + * @since 2.0.0 + */ +export declare const modifyNonEmptyLast: { + /** + * Apply a function to the last element, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modifyNonEmptyLast([1, 2, 3], n => n * 2) + * console.log(result) // [1, 2, 6] + * ``` + * + * @since 2.0.0 + */ + (f: (a: A) => B): (self: NonEmptyReadonlyArray) => NonEmptyArray; + /** + * Apply a function to the last element, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.modifyNonEmptyLast([1, 2, 3], n => n * 2) + * console.log(result) // [1, 2, 6] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, f: (a: A) => B): NonEmptyArray; +}; +/** + * Change the last element, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.setNonEmptyLast([1, 2, 3], 4) + * console.log(result) // [1, 2, 4] + * ``` + * + * @since 2.0.0 + */ +export declare const setNonEmptyLast: { + /** + * Change the last element, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.setNonEmptyLast([1, 2, 3], 4) + * console.log(result) // [1, 2, 4] + * ``` + * + * @since 2.0.0 + */ + (b: B): (self: NonEmptyReadonlyArray) => NonEmptyArray; + /** + * Change the last element, creating a new `NonEmptyReadonlyArray`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.setNonEmptyLast([1, 2, 3], 4) + * console.log(result) // [1, 2, 4] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, b: B): NonEmptyArray; +}; +/** + * Rotate an `Iterable` by `n` steps. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2) + * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ] + * ``` + * + * @since 2.0.0 + */ +export declare const rotate: { + /** + * Rotate an `Iterable` by `n` steps. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2) + * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ] + * ``` + * + * @since 2.0.0 + */ + (n: number): >(self: S) => ReadonlyArray.With>; + /** + * Rotate an `Iterable` by `n` steps. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2) + * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, n: number): NonEmptyArray; + /** + * Rotate an `Iterable` by `n` steps. + * If the input is a non-empty array, the result is also a non-empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.rotate(['a', 'b', 'c', 'd', 'e'], 2) + * console.log(result) // [ 'd', 'e', 'a', 'b', 'c' ] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, n: number): Array; +}; +/** + * Returns a function that checks if a `ReadonlyArray` contains a given value using a provided `isEquivalent` function. + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const isEquivalent = (a: number, b: number) => a === b + * const containsNumber = Array.containsWith(isEquivalent) + * const result = pipe([1, 2, 3, 4], containsNumber(3)) + * console.log(result) // true + * ``` + * + * @category elements + * @since 2.0.0 + */ +export declare const containsWith: (isEquivalent: (self: A, that: A) => boolean) => { + (a: A): (self: Iterable) => boolean; + (self: Iterable, a: A): boolean; +}; +/** + * Returns a function that checks if a `ReadonlyArray` contains a given value using the default `Equivalence`. + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const result = pipe(['a', 'b', 'c', 'd'], Array.contains('c')) + * console.log(result) // true + * ``` + * + * @category elements + * @since 2.0.0 + */ +export declare const contains: { + /** + * Returns a function that checks if a `ReadonlyArray` contains a given value using the default `Equivalence`. + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const result = pipe(['a', 'b', 'c', 'd'], Array.contains('c')) + * console.log(result) // true + * ``` + * + * @category elements + * @since 2.0.0 + */ + (a: A): (self: Iterable) => boolean; + /** + * Returns a function that checks if a `ReadonlyArray` contains a given value using the default `Equivalence`. + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const result = pipe(['a', 'b', 'c', 'd'], Array.contains('c')) + * console.log(result) // true + * ``` + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, a: A): boolean; +}; +/** + * A useful recursion pattern for processing an `Iterable` to produce a new `Array`, often used for "chopping" up the input + * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a + * value and the rest of the `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chop([1, 2, 3, 4, 5], (as): [number, Array] => [as[0] * 2, as.slice(1)]) + * console.log(result) // [2, 4, 6, 8, 10] + * + * // Explanation: + * // The `chopFunction` takes the first element of the array, doubles it, and then returns it along with the rest of the array. + * // The `chop` function applies this `chopFunction` recursively to the input array `[1, 2, 3, 4, 5]`, + * // resulting in a new array `[2, 4, 6, 8, 10]`. + * ``` + * + * @since 2.0.0 + */ +export declare const chop: { + /** + * A useful recursion pattern for processing an `Iterable` to produce a new `Array`, often used for "chopping" up the input + * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a + * value and the rest of the `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chop([1, 2, 3, 4, 5], (as): [number, Array] => [as[0] * 2, as.slice(1)]) + * console.log(result) // [2, 4, 6, 8, 10] + * + * // Explanation: + * // The `chopFunction` takes the first element of the array, doubles it, and then returns it along with the rest of the array. + * // The `chop` function applies this `chopFunction` recursively to the input array `[1, 2, 3, 4, 5]`, + * // resulting in a new array `[2, 4, 6, 8, 10]`. + * ``` + * + * @since 2.0.0 + */ + , B>(f: (as: NonEmptyReadonlyArray>) => readonly [B, ReadonlyArray>]): (self: S) => ReadonlyArray.With>; + /** + * A useful recursion pattern for processing an `Iterable` to produce a new `Array`, often used for "chopping" up the input + * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a + * value and the rest of the `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chop([1, 2, 3, 4, 5], (as): [number, Array] => [as[0] * 2, as.slice(1)]) + * console.log(result) // [2, 4, 6, 8, 10] + * + * // Explanation: + * // The `chopFunction` takes the first element of the array, doubles it, and then returns it along with the rest of the array. + * // The `chop` function applies this `chopFunction` recursively to the input array `[1, 2, 3, 4, 5]`, + * // resulting in a new array `[2, 4, 6, 8, 10]`. + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, f: (as: NonEmptyReadonlyArray) => readonly [B, ReadonlyArray]): NonEmptyArray; + /** + * A useful recursion pattern for processing an `Iterable` to produce a new `Array`, often used for "chopping" up the input + * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a + * value and the rest of the `Array`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chop([1, 2, 3, 4, 5], (as): [number, Array] => [as[0] * 2, as.slice(1)]) + * console.log(result) // [2, 4, 6, 8, 10] + * + * // Explanation: + * // The `chopFunction` takes the first element of the array, doubles it, and then returns it along with the rest of the array. + * // The `chop` function applies this `chopFunction` recursively to the input array `[1, 2, 3, 4, 5]`, + * // resulting in a new array `[2, 4, 6, 8, 10]`. + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, f: (as: NonEmptyReadonlyArray) => readonly [B, ReadonlyArray]): Array; +}; +/** + * Splits an `Iterable` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` can be `0`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitAt([1, 2, 3, 4, 5], 3) + * console.log(result) // [[1, 2, 3], [4, 5]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ +export declare const splitAt: { + /** + * Splits an `Iterable` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` can be `0`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitAt([1, 2, 3, 4, 5], 3) + * console.log(result) // [[1, 2, 3], [4, 5]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (n: number): (self: Iterable) => [beforeIndex: Array, fromIndex: Array]; + /** + * Splits an `Iterable` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` can be `0`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitAt([1, 2, 3, 4, 5], 3) + * console.log(result) // [[1, 2, 3], [4, 5]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (self: Iterable, n: number): [beforeIndex: Array, fromIndex: Array]; +}; +/** + * Splits a `NonEmptyReadonlyArray` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` must be `>= 1`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitNonEmptyAt(["a", "b", "c", "d", "e"], 3) + * console.log(result) // [["a", "b", "c"], ["d", "e"]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ +export declare const splitNonEmptyAt: { + /** + * Splits a `NonEmptyReadonlyArray` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` must be `>= 1`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitNonEmptyAt(["a", "b", "c", "d", "e"], 3) + * console.log(result) // [["a", "b", "c"], ["d", "e"]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (n: number): (self: NonEmptyReadonlyArray) => [beforeIndex: NonEmptyArray, fromIndex: Array]; + /** + * Splits a `NonEmptyReadonlyArray` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` must be `>= 1`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitNonEmptyAt(["a", "b", "c", "d", "e"], 3) + * console.log(result) // [["a", "b", "c"], ["d", "e"]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, n: number): [beforeIndex: NonEmptyArray, fromIndex: Array]; +}; +/** + * Splits this iterable into `n` equally sized arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3) + * console.log(result) // [[1, 2, 3], [4, 5, 6], [7, 8]] + * ``` + * + * @since 2.0.0 + * @category splitting + */ +export declare const split: { + /** + * Splits this iterable into `n` equally sized arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3) + * console.log(result) // [[1, 2, 3], [4, 5, 6], [7, 8]] + * ``` + * + * @since 2.0.0 + * @category splitting + */ + (n: number): (self: Iterable) => Array>; + /** + * Splits this iterable into `n` equally sized arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3) + * console.log(result) // [[1, 2, 3], [4, 5, 6], [7, 8]] + * ``` + * + * @since 2.0.0 + * @category splitting + */ + (self: Iterable, n: number): Array>; +}; +/** + * Splits this iterable on the first element that matches this predicate. + * Returns a tuple containing two arrays: the first one is before the match, and the second one is from the match onward. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitWhere([1, 2, 3, 4, 5], n => n > 3) + * console.log(result) // [[1, 2, 3], [4, 5]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ +export declare const splitWhere: { + /** + * Splits this iterable on the first element that matches this predicate. + * Returns a tuple containing two arrays: the first one is before the match, and the second one is from the match onward. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitWhere([1, 2, 3, 4, 5], n => n > 3) + * console.log(result) // [[1, 2, 3], [4, 5]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => [beforeMatch: Array, fromMatch: Array]; + /** + * Splits this iterable on the first element that matches this predicate. + * Returns a tuple containing two arrays: the first one is before the match, and the second one is from the match onward. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.splitWhere([1, 2, 3, 4, 5], n => n > 3) + * console.log(result) // [[1, 2, 3], [4, 5]] + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): [beforeMatch: Array, fromMatch: Array]; +}; +/** + * Copies an array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.copy([1, 2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const copy: { + /** + * Copies an array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.copy([1, 2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray): NonEmptyArray; + /** + * Copies an array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.copy([1, 2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyArray): Array; +}; +/** + * Pads an array. + * Returns a new array of length `n` with the elements of `array` followed by `fill` elements if `array` is shorter than `n`. + * If `array` is longer than `n`, the returned array will be a slice of `array` containing the `n` first elements of `array`. + * If `n` is less than or equal to 0, the returned array will be an empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.pad([1, 2, 3], 6, 0) + * console.log(result) // [1, 2, 3, 0, 0, 0] + * ``` + * + * @since 3.8.4 + */ +export declare const pad: { + /** + * Pads an array. + * Returns a new array of length `n` with the elements of `array` followed by `fill` elements if `array` is shorter than `n`. + * If `array` is longer than `n`, the returned array will be a slice of `array` containing the `n` first elements of `array`. + * If `n` is less than or equal to 0, the returned array will be an empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.pad([1, 2, 3], 6, 0) + * console.log(result) // [1, 2, 3, 0, 0, 0] + * ``` + * + * @since 3.8.4 + */ + (n: number, fill: T): (self: Array) => Array; + /** + * Pads an array. + * Returns a new array of length `n` with the elements of `array` followed by `fill` elements if `array` is shorter than `n`. + * If `array` is longer than `n`, the returned array will be a slice of `array` containing the `n` first elements of `array`. + * If `n` is less than or equal to 0, the returned array will be an empty array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.pad([1, 2, 3], 6, 0) + * console.log(result) // [1, 2, 3, 0, 0, 0] + * ``` + * + * @since 3.8.4 + */ + (self: Array, n: number, fill: T): Array; +}; +/** + * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of + * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive + * definition of `chunksOf`; it satisfies the property that + * + * ```ts skip-type-checking + * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys))) + * ``` + * + * whenever `n` evenly divides the length of `self`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chunksOf([1, 2, 3, 4, 5], 2) + * console.log(result) // [[1, 2], [3, 4], [5]] + * + * // Explanation: + * // The `chunksOf` function takes an array of numbers `[1, 2, 3, 4, 5]` and a number `2`. + * // It splits the array into chunks of length 2. Since the array length is not evenly divisible by 2, + * // the last chunk contains the remaining elements. + * // The result is `[[1, 2], [3, 4], [5]]`. + * ``` + * + * @category splitting + * @since 2.0.0 + */ +export declare const chunksOf: { + /** + * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of + * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive + * definition of `chunksOf`; it satisfies the property that + * + * ```ts skip-type-checking + * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys))) + * ``` + * + * whenever `n` evenly divides the length of `self`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chunksOf([1, 2, 3, 4, 5], 2) + * console.log(result) // [[1, 2], [3, 4], [5]] + * + * // Explanation: + * // The `chunksOf` function takes an array of numbers `[1, 2, 3, 4, 5]` and a number `2`. + * // It splits the array into chunks of length 2. Since the array length is not evenly divisible by 2, + * // the last chunk contains the remaining elements. + * // The result is `[[1, 2], [3, 4], [5]]`. + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (n: number): >(self: S) => ReadonlyArray.With>>; + /** + * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of + * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive + * definition of `chunksOf`; it satisfies the property that + * + * ```ts skip-type-checking + * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys))) + * ``` + * + * whenever `n` evenly divides the length of `self`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chunksOf([1, 2, 3, 4, 5], 2) + * console.log(result) // [[1, 2], [3, 4], [5]] + * + * // Explanation: + * // The `chunksOf` function takes an array of numbers `[1, 2, 3, 4, 5]` and a number `2`. + * // It splits the array into chunks of length 2. Since the array length is not evenly divisible by 2, + * // the last chunk contains the remaining elements. + * // The result is `[[1, 2], [3, 4], [5]]`. + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, n: number): NonEmptyArray>; + /** + * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of + * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive + * definition of `chunksOf`; it satisfies the property that + * + * ```ts skip-type-checking + * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys))) + * ``` + * + * whenever `n` evenly divides the length of `self`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.chunksOf([1, 2, 3, 4, 5], 2) + * console.log(result) // [[1, 2], [3, 4], [5]] + * + * // Explanation: + * // The `chunksOf` function takes an array of numbers `[1, 2, 3, 4, 5]` and a number `2`. + * // It splits the array into chunks of length 2. Since the array length is not evenly divisible by 2, + * // the last chunk contains the remaining elements. + * // The result is `[[1, 2], [3, 4], [5]]`. + * ``` + * + * @category splitting + * @since 2.0.0 + */ + (self: Iterable, n: number): Array>; +}; +/** + * Creates sliding windows of size `n` from an `Iterable`. + * If the number of elements is less than `n` or if `n` is not greater than zero, + * an empty array is returned. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Array } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * assert.deepStrictEqual(Array.window(numbers, 3), [[1, 2, 3], [2, 3, 4], [3, 4, 5]]) + * assert.deepStrictEqual(Array.window(numbers, 6), []) + * ``` + * + * @category splitting + * @since 3.13.2 + */ +export declare const window: { + /** + * Creates sliding windows of size `n` from an `Iterable`. + * If the number of elements is less than `n` or if `n` is not greater than zero, + * an empty array is returned. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Array } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * assert.deepStrictEqual(Array.window(numbers, 3), [[1, 2, 3], [2, 3, 4], [3, 4, 5]]) + * assert.deepStrictEqual(Array.window(numbers, 6), []) + * ``` + * + * @category splitting + * @since 3.13.2 + */ + (n: N): (self: Iterable) => Array>; + /** + * Creates sliding windows of size `n` from an `Iterable`. + * If the number of elements is less than `n` or if `n` is not greater than zero, + * an empty array is returned. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Array } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * assert.deepStrictEqual(Array.window(numbers, 3), [[1, 2, 3], [2, 3, 4], [3, 4, 5]]) + * assert.deepStrictEqual(Array.window(numbers, 6), []) + * ``` + * + * @category splitting + * @since 3.13.2 + */ + (self: Iterable, n: N): Array>; +}; +/** + * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s using the provided `isEquivalent` function. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.groupWith(["a", "a", "b", "b", "b", "c", "a"], (x, y) => x === y) + * console.log(result) // [["a", "a"], ["b", "b", "b"], ["c"], ["a"]] + * ``` + * + * @category grouping + * @since 2.0.0 + */ +export declare const groupWith: { + /** + * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s using the provided `isEquivalent` function. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.groupWith(["a", "a", "b", "b", "b", "c", "a"], (x, y) => x === y) + * console.log(result) // [["a", "a"], ["b", "b", "b"], ["c"], ["a"]] + * ``` + * + * @category grouping + * @since 2.0.0 + */ + (isEquivalent: (self: A, that: A) => boolean): (self: NonEmptyReadonlyArray) => NonEmptyArray>; + /** + * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s using the provided `isEquivalent` function. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.groupWith(["a", "a", "b", "b", "b", "c", "a"], (x, y) => x === y) + * console.log(result) // [["a", "a"], ["b", "b", "b"], ["c"], ["a"]] + * ``` + * + * @category grouping + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, isEquivalent: (self: A, that: A) => boolean): NonEmptyArray>; +}; +/** + * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.group([1, 1, 2, 2, 2, 3, 1]) + * console.log(result) // [[1, 1], [2, 2, 2], [3], [1]] + * ``` + * + * @category grouping + * @since 2.0.0 + */ +export declare const group: (self: NonEmptyReadonlyArray) => NonEmptyArray>; +/** + * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning + * function on each element, and grouping the results according to values returned + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const people = [ + * { name: "Alice", group: "A" }, + * { name: "Bob", group: "B" }, + * { name: "Charlie", group: "A" } + * ] + * + * const result = Array.groupBy(people, person => person.group) + * console.log(result) + * // { + * // A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }], + * // B: [{ name: "Bob", group: "B" }] + * // } + * ``` + * + * @category grouping + * @since 2.0.0 + */ +export declare const groupBy: { + /** + * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning + * function on each element, and grouping the results according to values returned + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const people = [ + * { name: "Alice", group: "A" }, + * { name: "Bob", group: "B" }, + * { name: "Charlie", group: "A" } + * ] + * + * const result = Array.groupBy(people, person => person.group) + * console.log(result) + * // { + * // A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }], + * // B: [{ name: "Bob", group: "B" }] + * // } + * ``` + * + * @category grouping + * @since 2.0.0 + */ + (f: (a: A) => K): (self: Iterable) => Record, NonEmptyArray>; + /** + * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning + * function on each element, and grouping the results according to values returned + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const people = [ + * { name: "Alice", group: "A" }, + * { name: "Bob", group: "B" }, + * { name: "Charlie", group: "A" } + * ] + * + * const result = Array.groupBy(people, person => person.group) + * console.log(result) + * // { + * // A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }], + * // B: [{ name: "Bob", group: "B" }] + * // } + * ``` + * + * @category grouping + * @since 2.0.0 + */ + (self: Iterable, f: (a: A) => K): Record, NonEmptyArray>; +}; +/** + * Calculates the union of two arrays using the provided equivalence relation. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const union = Array.unionWith([1, 2], [2, 3], (a, b) => a === b) + * console.log(union) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const unionWith: { + /** + * Calculates the union of two arrays using the provided equivalence relation. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const union = Array.unionWith([1, 2], [2, 3], (a, b) => a === b) + * console.log(union) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + , T extends Iterable>(that: T, isEquivalent: (self: ReadonlyArray.Infer, that: ReadonlyArray.Infer) => boolean): (self: S) => ReadonlyArray.OrNonEmpty | ReadonlyArray.Infer>; + /** + * Calculates the union of two arrays using the provided equivalence relation. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const union = Array.unionWith([1, 2], [2, 3], (a, b) => a === b) + * console.log(union) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, that: Iterable, isEquivalent: (self: A, that: B) => boolean): NonEmptyArray; + /** + * Calculates the union of two arrays using the provided equivalence relation. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const union = Array.unionWith([1, 2], [2, 3], (a, b) => a === b) + * console.log(union) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, that: NonEmptyReadonlyArray, isEquivalent: (self: A, that: B) => boolean): NonEmptyArray; + /** + * Calculates the union of two arrays using the provided equivalence relation. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const union = Array.unionWith([1, 2], [2, 3], (a, b) => a === b) + * console.log(union) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, that: Iterable, isEquivalent: (self: A, that: B) => boolean): Array; +}; +/** + * Creates a union of two arrays, removing duplicates. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.union([1, 2], [2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const union: { + /** + * Creates a union of two arrays, removing duplicates. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.union([1, 2], [2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + >(that: T): >(self: S) => ReadonlyArray.OrNonEmpty | ReadonlyArray.Infer>; + /** + * Creates a union of two arrays, removing duplicates. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.union([1, 2], [2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, that: ReadonlyArray): NonEmptyArray; + /** + * Creates a union of two arrays, removing duplicates. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.union([1, 2], [2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyArray, that: NonEmptyReadonlyArray): NonEmptyArray; + /** + * Creates a union of two arrays, removing duplicates. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.union([1, 2], [2, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Array; +}; +/** + * Creates an `Array` of unique values that are included in all given `Iterable`s using the provided `isEquivalent` function. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }] + * const array2 = [{ id: 3 }, { id: 4 }, { id: 1 }] + * const isEquivalent = (a: { id: number }, b: { id: number }) => a.id === b.id + * const result = Array.intersectionWith(isEquivalent)(array2)(array1) + * console.log(result) // [{ id: 1 }, { id: 3 }] + * ``` + * + * @since 2.0.0 + */ +export declare const intersectionWith: (isEquivalent: (self: A, that: A) => boolean) => { + (that: Iterable): (self: Iterable) => Array; + (self: Iterable, that: Iterable): Array; +}; +/** + * Creates an `Array` of unique values that are included in all given `Iterable`s. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.intersection([1, 2, 3], [3, 4, 1]) + * console.log(result) // [1, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const intersection: { + /** + * Creates an `Array` of unique values that are included in all given `Iterable`s. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.intersection([1, 2, 3], [3, 4, 1]) + * console.log(result) // [1, 3] + * ``` + * + * @since 2.0.0 + */ + (that: Iterable): (self: Iterable) => Array; + /** + * Creates an `Array` of unique values that are included in all given `Iterable`s. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.intersection([1, 2, 3], [3, 4, 1]) + * console.log(result) // [1, 3] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Array; +}; +/** + * Creates a `Array` of values not included in the other given `Iterable` using the provided `isEquivalent` function. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const array1 = [1, 2, 3] + * const array2 = [2, 3, 4] + * const difference = Array.differenceWith((a, b) => a === b)(array1, array2) + * console.log(difference) // [1] + * ``` + * + * @since 2.0.0 + */ +export declare const differenceWith: (isEquivalent: (self: A, that: A) => boolean) => { + (that: Iterable): (self: Iterable) => Array; + (self: Iterable, that: Iterable): Array; +}; +/** + * Creates a `Array` of values not included in the other given `Iterable`. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const difference = Array.difference([1, 2, 3], [2, 3, 4]) + * console.log(difference) // [1] + * ``` + * + * @since 2.0.0 + */ +export declare const difference: { + /** + * Creates a `Array` of values not included in the other given `Iterable`. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const difference = Array.difference([1, 2, 3], [2, 3, 4]) + * console.log(difference) // [1] + * ``` + * + * @since 2.0.0 + */ + (that: Iterable): (self: Iterable) => Array; + /** + * Creates a `Array` of values not included in the other given `Iterable`. + * The order and references of result values are determined by the first `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const difference = Array.difference([1, 2, 3], [2, 3, 4]) + * console.log(difference) // [1] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Array; +}; +/** + * @category constructors + * @since 2.0.0 + */ +export declare const empty: () => Array; +/** + * Constructs a new `NonEmptyArray` from the specified value. + * + * @category constructors + * @since 2.0.0 + */ +export declare const of: (a: A) => NonEmptyArray; +/** + * @since 2.0.0 + */ +export declare namespace ReadonlyArray { + /** + * @since 2.0.0 + */ + type Infer> = S extends ReadonlyArray ? A : S extends Iterable ? A : never; + /** + * @since 2.0.0 + */ + type With, A> = S extends NonEmptyReadonlyArray ? NonEmptyArray : Array; + /** + * @since 2.0.0 + */ + type OrNonEmpty, T extends Iterable, A> = S extends NonEmptyReadonlyArray ? NonEmptyArray : T extends NonEmptyReadonlyArray ? NonEmptyArray : Array; + /** + * @since 2.0.0 + */ + type AndNonEmpty, T extends Iterable, A> = S extends NonEmptyReadonlyArray ? T extends NonEmptyReadonlyArray ? NonEmptyArray : Array : Array; + /** + * @since 2.0.0 + */ + type Flatten>> = T extends NonEmptyReadonlyArray> ? NonEmptyArray : Array; +} +/** + * @category mapping + * @since 2.0.0 + */ +export declare const map: { + /** + * @category mapping + * @since 2.0.0 + */ + , B>(f: (a: ReadonlyArray.Infer, i: number) => B): (self: S) => ReadonlyArray.With; + /** + * @category mapping + * @since 2.0.0 + */ + , B>(self: S, f: (a: ReadonlyArray.Infer, i: number) => B): ReadonlyArray.With; +}; +/** + * Applies a function to each element in an array and returns a new array containing the concatenated mapped elements. + * + * @category sequencing + * @since 2.0.0 + */ +export declare const flatMap: { + /** + * Applies a function to each element in an array and returns a new array containing the concatenated mapped elements. + * + * @category sequencing + * @since 2.0.0 + */ + , T extends ReadonlyArray>(f: (a: ReadonlyArray.Infer, i: number) => T): (self: S) => ReadonlyArray.AndNonEmpty>; + /** + * Applies a function to each element in an array and returns a new array containing the concatenated mapped elements. + * + * @category sequencing + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, f: (a: A, i: number) => NonEmptyReadonlyArray): NonEmptyArray; + /** + * Applies a function to each element in an array and returns a new array containing the concatenated mapped elements. + * + * @category sequencing + * @since 2.0.0 + */ + (self: ReadonlyArray, f: (a: A, i: number) => ReadonlyArray): Array; +}; +/** + * Combines multiple arrays into a single array by concatenating all elements + * from each nested array. This function ensures that the structure of nested + * arrays is collapsed into a single, flat array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.flatten([[1, 2], [], [3, 4], [], [5, 6]]) + * console.log(result) // [1, 2, 3, 4, 5, 6] + * ``` + * + * @category sequencing + * @since 2.0.0 + */ +export declare const flatten: >>(self: S) => ReadonlyArray.Flatten; +/** + * Applies a function to each element of the `Iterable` and filters based on the result, keeping the transformed values where the function returns `Some`. + * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * const evenSquares = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none() + * + * const result = Array.filterMap([1, 2, 3, 4, 5], evenSquares); + * console.log(result) // [4, 16] + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const filterMap: { + /** + * Applies a function to each element of the `Iterable` and filters based on the result, keeping the transformed values where the function returns `Some`. + * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * const evenSquares = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none() + * + * const result = Array.filterMap([1, 2, 3, 4, 5], evenSquares); + * console.log(result) // [4, 16] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (f: (a: A, i: number) => Option.Option): (self: Iterable) => Array; + /** + * Applies a function to each element of the `Iterable` and filters based on the result, keeping the transformed values where the function returns `Some`. + * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * const evenSquares = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none() + * + * const result = Array.filterMap([1, 2, 3, 4, 5], evenSquares); + * console.log(result) // [4, 16] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option.Option): Array; +}; +/** + * Applies a function to each element of the array and filters based on the result, stopping when a condition is not met. + * This method combines filtering and mapping in a single pass, and short-circuits, i.e., stops processing, as soon as the function returns `None`. + * This is useful when you need to transform an array but only up to the point where a certain condition holds true. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * const toSquareTillOdd = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none() + * + * const result = Array.filterMapWhile([2, 4, 5], toSquareTillOdd) + * console.log(result) // [4, 16] + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const filterMapWhile: { + /** + * Applies a function to each element of the array and filters based on the result, stopping when a condition is not met. + * This method combines filtering and mapping in a single pass, and short-circuits, i.e., stops processing, as soon as the function returns `None`. + * This is useful when you need to transform an array but only up to the point where a certain condition holds true. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * const toSquareTillOdd = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none() + * + * const result = Array.filterMapWhile([2, 4, 5], toSquareTillOdd) + * console.log(result) // [4, 16] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (f: (a: A, i: number) => Option.Option): (self: Iterable) => Array; + /** + * Applies a function to each element of the array and filters based on the result, stopping when a condition is not met. + * This method combines filtering and mapping in a single pass, and short-circuits, i.e., stops processing, as soon as the function returns `None`. + * This is useful when you need to transform an array but only up to the point where a certain condition holds true. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * const toSquareTillOdd = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none() + * + * const result = Array.filterMapWhile([2, 4, 5], toSquareTillOdd) + * console.log(result) // [4, 16] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option.Option): Array; +}; +/** + * Applies a function to each element of the `Iterable`, categorizing the results into two separate arrays. + * This function is particularly useful for operations where each element can result in two possible types, + * and you want to separate these types into different collections. For instance, separating validation results + * into successes and failures. + * + * **Example** + * + * ```ts + * import { Array, Either } from "effect"; + * + * const isEven = (x: number) => x % 2 === 0 + * + * const result = Array.partitionMap([1, 2, 3, 4, 5], x => + * isEven(x) ? Either.right(x) : Either.left(x) + * ) + * console.log(result) + * // [ + * // [1, 3, 5], + * // [2, 4] + * // ] + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const partitionMap: { + /** + * Applies a function to each element of the `Iterable`, categorizing the results into two separate arrays. + * This function is particularly useful for operations where each element can result in two possible types, + * and you want to separate these types into different collections. For instance, separating validation results + * into successes and failures. + * + * **Example** + * + * ```ts + * import { Array, Either } from "effect"; + * + * const isEven = (x: number) => x % 2 === 0 + * + * const result = Array.partitionMap([1, 2, 3, 4, 5], x => + * isEven(x) ? Either.right(x) : Either.left(x) + * ) + * console.log(result) + * // [ + * // [1, 3, 5], + * // [2, 4] + * // ] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (f: (a: A, i: number) => Either.Either): (self: Iterable) => [left: Array, right: Array]; + /** + * Applies a function to each element of the `Iterable`, categorizing the results into two separate arrays. + * This function is particularly useful for operations where each element can result in two possible types, + * and you want to separate these types into different collections. For instance, separating validation results + * into successes and failures. + * + * **Example** + * + * ```ts + * import { Array, Either } from "effect"; + * + * const isEven = (x: number) => x % 2 === 0 + * + * const result = Array.partitionMap([1, 2, 3, 4, 5], x => + * isEven(x) ? Either.right(x) : Either.left(x) + * ) + * console.log(result) + * // [ + * // [1, 3, 5], + * // [2, 4] + * // ] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Either.Either): [left: Array, right: Array]; +}; +/** + * Retrieves the `Some` values from an `Iterable` of `Option`s, collecting them into an array. + * + * **Example** + * + * ```ts + * import { Array, Option } from "effect" + * + * const result = Array.getSomes([Option.some(1), Option.none(), Option.some(2)]) + * console.log(result) // [1, 2] + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const getSomes: >, X = any>(self: T) => Array>>; +/** + * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array. + * + * **Example** + * + * ```ts + * import { Array, Either } from "effect" + * + * const result = Array.getLefts([Either.right(1), Either.left("err"), Either.right(2)]) + * console.log(result) // ["err"] + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const getLefts: >>(self: T) => Array>>; +/** + * Retrieves the `Right` values from an `Iterable` of `Either`s, collecting them into an array. + * + * **Example** + * + * ```ts + * import { Array, Either } from "effect" + * + * const result = Array.getRights([Either.right(1), Either.left("err"), Either.right(2)]) + * console.log(result) // [1, 2] + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const getRights: >>(self: T) => Array>>; +/** + * @category filtering + * @since 2.0.0 + */ +export declare const filter: { + /** + * @category filtering + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Array; + /** + * @category filtering + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Array; + /** + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Array; + /** + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Array; +}; +/** + * Separate elements based on a predicate that also exposes the index of the element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.partition([1, 2, 3, 4], n => n % 2 === 0) + * console.log(result) // [[1, 3], [2, 4]] + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const partition: { + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.partition([1, 2, 3, 4], n => n % 2 === 0) + * console.log(result) // [[1, 3], [2, 4]] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => [excluded: Array>, satisfying: Array]; + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.partition([1, 2, 3, 4], n => n % 2 === 0) + * console.log(result) // [[1, 3], [2, 4]] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => [excluded: Array, satisfying: Array]; + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.partition([1, 2, 3, 4], n => n % 2 === 0) + * console.log(result) // [[1, 3], [2, 4]] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): [excluded: Array>, satisfying: Array]; + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.partition([1, 2, 3, 4], n => n % 2 === 0) + * console.log(result) // [[1, 3], [2, 4]] + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): [excluded: Array, satisfying: Array]; +}; +/** + * Separates an `Iterable` into two arrays based on a predicate. + * + * @category filtering + * @since 2.0.0 + */ +export declare const separate: >>(self: T) => [Array>>, Array>>]; +/** + * Reduces an array from the left. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.reduce([1, 2, 3], 0, (acc, n) => acc + n) + * console.log(result) // 6 + * ``` + * + * @category folding + * @since 2.0.0 + */ +export declare const reduce: { + /** + * Reduces an array from the left. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.reduce([1, 2, 3], 0, (acc, n) => acc + n) + * console.log(result) // 6 + * ``` + * + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A, i: number) => B): (self: Iterable) => B; + /** + * Reduces an array from the left. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.reduce([1, 2, 3], 0, (acc, n) => acc + n) + * console.log(result) // 6 + * ``` + * + * @category folding + * @since 2.0.0 + */ + (self: Iterable, b: B, f: (b: B, a: A, i: number) => B): B; +}; +/** + * Reduces an array from the right. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n) + * console.log(result) // 6 + * ``` + * + * @category folding + * @since 2.0.0 + */ +export declare const reduceRight: { + /** + * Reduces an array from the right. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n) + * console.log(result) // 6 + * ``` + * + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A, i: number) => B): (self: Iterable) => B; + /** + * Reduces an array from the right. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n) + * console.log(result) // 6 + * ``` + * + * @category folding + * @since 2.0.0 + */ + (self: Iterable, b: B, f: (b: B, a: A, i: number) => B): B; +}; +/** + * Lifts a predicate into an array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const isEven = (n: number) => n % 2 === 0 + * const to = Array.liftPredicate(isEven) + * console.log(to(1)) // [] + * console.log(to(2)) // [2] + * ``` + * + * @category lifting + * @since 2.0.0 + */ +export declare const liftPredicate: { + (refinement: Predicate.Refinement): (a: A) => Array; + /** + * Lifts a predicate into an array. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const isEven = (n: number) => n % 2 === 0 + * const to = Array.liftPredicate(isEven) + * console.log(to(1)) // [] + * console.log(to(2)) // [2] + * ``` + * + * @category lifting + * @since 2.0.0 + */ + (predicate: Predicate.Predicate): (b: B) => Array; +}; +/** + * @category lifting + * @since 2.0.0 + */ +export declare const liftOption: , B>(f: (...a: A) => Option.Option) => (...a: A) => Array; +/** + * @category conversions + * @since 2.0.0 + */ +export declare const fromNullable: (a: A) => Array>; +/** + * @category lifting + * @since 2.0.0 + */ +export declare const liftNullable: , B>(f: (...a: A) => B | null | undefined) => (...a: A) => Array>; +/** + * Maps over an array and flattens the result, removing null and undefined values. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.flatMapNullable([1, 2, 3], n => (n % 2 === 0 ? null : n)) + * console.log(result) // [1, 3] + * + * // Explanation: + * // The array of numbers [1, 2, 3] is mapped with a function that returns null for even numbers + * // and the number itself for odd numbers. The resulting array [1, null, 3] is then flattened + * // to remove null values, resulting in [1, 3]. + * ``` + * + * @category sequencing + * @since 2.0.0 + */ +export declare const flatMapNullable: { + /** + * Maps over an array and flattens the result, removing null and undefined values. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.flatMapNullable([1, 2, 3], n => (n % 2 === 0 ? null : n)) + * console.log(result) // [1, 3] + * + * // Explanation: + * // The array of numbers [1, 2, 3] is mapped with a function that returns null for even numbers + * // and the number itself for odd numbers. The resulting array [1, null, 3] is then flattened + * // to remove null values, resulting in [1, 3]. + * ``` + * + * @category sequencing + * @since 2.0.0 + */ + (f: (a: A) => B | null | undefined): (self: ReadonlyArray) => Array>; + /** + * Maps over an array and flattens the result, removing null and undefined values. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.flatMapNullable([1, 2, 3], n => (n % 2 === 0 ? null : n)) + * console.log(result) // [1, 3] + * + * // Explanation: + * // The array of numbers [1, 2, 3] is mapped with a function that returns null for even numbers + * // and the number itself for odd numbers. The resulting array [1, null, 3] is then flattened + * // to remove null values, resulting in [1, 3]. + * ``` + * + * @category sequencing + * @since 2.0.0 + */ + (self: ReadonlyArray, f: (a: A) => B | null | undefined): Array>; +}; +/** + * Lifts a function that returns an `Either` into a function that returns an array. + * If the `Either` is a left, it returns an empty array. + * If the `Either` is a right, it returns an array with the right value. + * + * **Example** + * + * ```ts + * import { Array, Either } from "effect" + * + * const parseNumber = (s: string): Either.Either => + * isNaN(Number(s)) ? Either.left(new Error("Not a number")) : Either.right(Number(s)) + * + * const liftedParseNumber = Array.liftEither(parseNumber) + * + * const result1 = liftedParseNumber("42") + * console.log(result1) // [42] + * + * const result2 = liftedParseNumber("not a number") + * console.log(result2) // [] + * + * // Explanation: + * // The function parseNumber is lifted to return an array. + * // When parsing "42", it returns an Either.left with the number 42, resulting in [42]. + * // When parsing "not a number", it returns an Either.right with an error, resulting in an empty array []. + * ``` + * + * @category lifting + * @since 2.0.0 + */ +export declare const liftEither: , E, B>(f: (...a: A) => Either.Either) => (...a: A) => Array; +/** + * Check if a predicate holds true for every `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ +export declare const every: { + /** + * Check if a predicate holds true for every `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: ReadonlyArray) => self is ReadonlyArray; + /** + * Check if a predicate holds true for every `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: ReadonlyArray) => boolean; + /** + * Check if a predicate holds true for every `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ + (self: ReadonlyArray, refinement: (a: A, i: number) => a is B): self is ReadonlyArray; + /** + * Check if a predicate holds true for every `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ + (self: ReadonlyArray, predicate: (a: A, i: number) => boolean): boolean; +}; +/** + * Check if a predicate holds true for some `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ +export declare const some: { + /** + * Check if a predicate holds true for some `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: ReadonlyArray) => self is NonEmptyReadonlyArray; + /** + * Check if a predicate holds true for some `ReadonlyArray` element. + * + * @category elements + * @since 2.0.0 + */ + (self: ReadonlyArray, predicate: (a: A, i: number) => boolean): self is NonEmptyReadonlyArray; +}; +/** + * Extends an array with a function that maps each subarray to a value. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.extend([1, 2, 3], as => as.length) + * console.log(result) // [3, 2, 1] + * + * // Explanation: + * // The function maps each subarray starting from each element to its length. + * // The subarrays are: [1, 2, 3], [2, 3], [3]. + * // The lengths are: 3, 2, 1. + * // Therefore, the result is [3, 2, 1]. + * ``` + * + * @since 2.0.0 + */ +export declare const extend: { + /** + * Extends an array with a function that maps each subarray to a value. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.extend([1, 2, 3], as => as.length) + * console.log(result) // [3, 2, 1] + * + * // Explanation: + * // The function maps each subarray starting from each element to its length. + * // The subarrays are: [1, 2, 3], [2, 3], [3]. + * // The lengths are: 3, 2, 1. + * // Therefore, the result is [3, 2, 1]. + * ``` + * + * @since 2.0.0 + */ + (f: (as: ReadonlyArray) => B): (self: ReadonlyArray) => Array; + /** + * Extends an array with a function that maps each subarray to a value. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.extend([1, 2, 3], as => as.length) + * console.log(result) // [3, 2, 1] + * + * // Explanation: + * // The function maps each subarray starting from each element to its length. + * // The subarrays are: [1, 2, 3], [2, 3], [3]. + * // The lengths are: 3, 2, 1. + * // Therefore, the result is [3, 2, 1]. + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyArray, f: (as: ReadonlyArray) => B): Array; +}; +/** + * Finds the minimum element in an array based on a comparator. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.min([3, 1, 2], Order.number) + * console.log(result) // 1 + * ``` + * + * @since 2.0.0 + */ +export declare const min: { + /** + * Finds the minimum element in an array based on a comparator. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.min([3, 1, 2], Order.number) + * console.log(result) // 1 + * ``` + * + * @since 2.0.0 + */ + (O: Order.Order): (self: NonEmptyReadonlyArray) => A; + /** + * Finds the minimum element in an array based on a comparator. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.min([3, 1, 2], Order.number) + * console.log(result) // 1 + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, O: Order.Order): A; +}; +/** + * Finds the maximum element in an array based on a comparator. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.max([3, 1, 2], Order.number) + * console.log(result) // 3 + * ``` + * + * @since 2.0.0 + */ +export declare const max: { + /** + * Finds the maximum element in an array based on a comparator. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.max([3, 1, 2], Order.number) + * console.log(result) // 3 + * ``` + * + * @since 2.0.0 + */ + (O: Order.Order): (self: NonEmptyReadonlyArray) => A; + /** + * Finds the maximum element in an array based on a comparator. + * + * **Example** + * + * ```ts + * import { Array, Order } from "effect" + * + * const result = Array.max([3, 1, 2], Order.number) + * console.log(result) // 3 + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, O: Order.Order): A; +}; +/** + * @category constructors + * @since 2.0.0 + */ +export declare const unfold: (b: B, f: (b: B) => Option.Option) => Array; +/** + * This function creates and returns a new `Order` for an array of values based on a given `Order` for the elements of the array. + * The returned `Order` compares two arrays by applying the given `Order` to each element in the arrays. + * If all elements are equal, the arrays are then compared based on their length. + * It is useful when you need to compare two arrays of the same type and you have a specific way of comparing each element of the array. + * + * @category instances + * @since 2.0.0 + */ +export declare const getOrder: (O: Order.Order) => Order.Order>; +/** + * Creates an equivalence relation for arrays. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const eq = Array.getEquivalence((a, b) => a === b) + * console.log(eq([1, 2, 3], [1, 2, 3])) // true + * ``` + * + * @category instances + * @since 2.0.0 + */ +export declare const getEquivalence: (isEquivalent: Equivalence.Equivalence) => Equivalence.Equivalence>; +/** + * Performs a side-effect for each element of the `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * Array.forEach([1, 2, 3], n => console.log(n)) // 1, 2, 3 + * ``` + * + * @since 2.0.0 + */ +export declare const forEach: { + /** + * Performs a side-effect for each element of the `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * Array.forEach([1, 2, 3], n => console.log(n)) // 1, 2, 3 + * ``` + * + * @since 2.0.0 + */ + (f: (a: A, i: number) => void): (self: Iterable) => void; + /** + * Performs a side-effect for each element of the `Iterable`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * Array.forEach([1, 2, 3], n => console.log(n)) // 1, 2, 3 + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => void): void; +}; +/** + * Remove duplicates from an `Iterable` using the provided `isEquivalent` function, + * preserving the order of the first occurrence of each element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const dedupeWith: { + /** + * Remove duplicates from an `Iterable` using the provided `isEquivalent` function, + * preserving the order of the first occurrence of each element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + >(isEquivalent: (self: ReadonlyArray.Infer, that: ReadonlyArray.Infer) => boolean): (self: S) => ReadonlyArray.With>; + /** + * Remove duplicates from an `Iterable` using the provided `isEquivalent` function, + * preserving the order of the first occurrence of each element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: NonEmptyReadonlyArray, isEquivalent: (self: A, that: A) => boolean): NonEmptyArray; + /** + * Remove duplicates from an `Iterable` using the provided `isEquivalent` function, + * preserving the order of the first occurrence of each element. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, isEquivalent: (self: A, that: A) => boolean): Array; +}; +/** + * Remove duplicates from an `Iterable`, preserving the order of the first occurrence of each element. + * The equivalence used to compare elements is provided by `Equal.equivalence()` from the `Equal` module. + * + * @since 2.0.0 + */ +export declare const dedupe: >(self: S) => S extends NonEmptyReadonlyArray ? NonEmptyArray : S extends Iterable ? Array : never; +/** + * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const dedupeAdjacentWith: { + /** + * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (isEquivalent: (self: A, that: A) => boolean): (self: Iterable) => Array; + /** + * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ + (self: Iterable, isEquivalent: (self: A, that: A) => boolean): Array; +}; +/** + * Deduplicates adjacent elements that are identical. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.dedupeAdjacent([1, 1, 2, 2, 3, 3]) + * console.log(result) // [1, 2, 3] + * ``` + * + * @since 2.0.0 + */ +export declare const dedupeAdjacent: (self: Iterable) => Array; +/** + * Joins the elements together with "sep" in the middle. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const strings = ["a", "b", "c"] + * const joined = Array.join(strings, "-") + * console.log(joined) // "a-b-c" + * ``` + * + * @since 2.0.0 + * @category folding + */ +export declare const join: { + /** + * Joins the elements together with "sep" in the middle. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const strings = ["a", "b", "c"] + * const joined = Array.join(strings, "-") + * console.log(joined) // "a-b-c" + * ``` + * + * @since 2.0.0 + * @category folding + */ + (sep: string): (self: Iterable) => string; + /** + * Joins the elements together with "sep" in the middle. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const strings = ["a", "b", "c"] + * const joined = Array.join(strings, "-") + * console.log(joined) // "a-b-c" + * ``` + * + * @since 2.0.0 + * @category folding + */ + (self: Iterable, sep: string): string; +}; +/** + * Statefully maps over the chunk, producing new elements of type `B`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n]) + * console.log(result) // [6, [1, 3, 6]] + * ``` + * + * @since 2.0.0 + * @category folding + */ +export declare const mapAccum: { + /** + * Statefully maps over the chunk, producing new elements of type `B`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n]) + * console.log(result) // [6, [1, 3, 6]] + * ``` + * + * @since 2.0.0 + * @category folding + */ + = Iterable>(s: S, f: (s: S, a: ReadonlyArray.Infer, i: number) => readonly [S, B]): (self: I) => [state: S, mappedArray: ReadonlyArray.With]; + /** + * Statefully maps over the chunk, producing new elements of type `B`. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n]) + * console.log(result) // [6, [1, 3, 6]] + * ``` + * + * @since 2.0.0 + * @category folding + */ + = Iterable>(self: I, s: S, f: (s: S, a: ReadonlyArray.Infer, i: number) => readonly [S, B]): [state: S, mappedArray: ReadonlyArray.With]; +}; +/** + * Zips this chunk crosswise with the specified chunk using the specified combiner. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.cartesianWith([1, 2], ["a", "b"], (a, b) => `${a}-${b}`) + * console.log(result) // ["1-a", "1-b", "2-a", "2-b"] + * ``` + * + * @since 2.0.0 + * @category elements + */ +export declare const cartesianWith: { + /** + * Zips this chunk crosswise with the specified chunk using the specified combiner. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.cartesianWith([1, 2], ["a", "b"], (a, b) => `${a}-${b}`) + * console.log(result) // ["1-a", "1-b", "2-a", "2-b"] + * ``` + * + * @since 2.0.0 + * @category elements + */ + (that: ReadonlyArray, f: (a: A, b: B) => C): (self: ReadonlyArray) => Array; + /** + * Zips this chunk crosswise with the specified chunk using the specified combiner. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.cartesianWith([1, 2], ["a", "b"], (a, b) => `${a}-${b}`) + * console.log(result) // ["1-a", "1-b", "2-a", "2-b"] + * ``` + * + * @since 2.0.0 + * @category elements + */ + (self: ReadonlyArray, that: ReadonlyArray, f: (a: A, b: B) => C): Array; +}; +/** + * Zips this chunk crosswise with the specified chunk. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.cartesian([1, 2], ["a", "b"]) + * console.log(result) // [[1, "a"], [1, "b"], [2, "a"], [2, "b"]] + * ``` + * + * @since 2.0.0 + * @category elements + */ +export declare const cartesian: { + /** + * Zips this chunk crosswise with the specified chunk. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.cartesian([1, 2], ["a", "b"]) + * console.log(result) // [[1, "a"], [1, "b"], [2, "a"], [2, "b"]] + * ``` + * + * @since 2.0.0 + * @category elements + */ + (that: ReadonlyArray): (self: ReadonlyArray) => Array<[A, B]>; + /** + * Zips this chunk crosswise with the specified chunk. + * + * **Example** + * + * ```ts + * import { Array } from "effect" + * + * const result = Array.cartesian([1, 2], ["a", "b"]) + * console.log(result) // [[1, "a"], [1, "b"], [2, "a"], [2, "b"]] + * ``` + * + * @since 2.0.0 + * @category elements + */ + (self: ReadonlyArray, that: ReadonlyArray): Array<[A, B]>; +}; +/** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * ``` + * + * @see {@link bindTo} + * @see {@link bind} + * @see {@link let_ let} + * + * @category do notation + * @since 3.2.0 + */ +export declare const Do: ReadonlyArray<{}>; +/** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * ``` + * + * @see {@link bindTo} + * @see {@link Do} + * @see {@link let_ let} + * + * @category do notation + * @since 3.2.0 + */ +export declare const bind: { + /** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * ``` + * + * @see {@link bindTo} + * @see {@link Do} + * @see {@link let_ let} + * + * @category do notation + * @since 3.2.0 + */ + (tag: Exclude, f: (a: NoInfer) => ReadonlyArray): (self: ReadonlyArray) => Array<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; + /** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * ``` + * + * @see {@link bindTo} + * @see {@link Do} + * @see {@link let_ let} + * + * @category do notation + * @since 3.2.0 + */ + (self: ReadonlyArray, tag: Exclude, f: (a: NoInfer) => ReadonlyArray): Array<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; +}; +/** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * ``` + * + * @see {@link bindTo} + * @see {@link Do} + * @see {@link let_ let} + * + * @category do notation + * @since 3.2.0 + */ +export declare const bindTo: { + /** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * ``` + * + * @see {@link bindTo} + * @see {@link Do} + * @see {@link let_ let} + * + * @category do notation + * @since 3.2.0 + */ + (tag: N): (self: ReadonlyArray) => Array<{ + [K in N]: A; + }>; + /** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * ``` + * + * @see {@link bindTo} + * @see {@link Do} + * @see {@link let_ let} + * + * @category do notation + * @since 3.2.0 + */ + (self: ReadonlyArray, tag: N): Array<{ + [K in N]: A; + }>; +}; +declare const let_: { + (tag: Exclude, f: (a: NoInfer) => B): (self: ReadonlyArray) => Array<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; + (self: ReadonlyArray, tag: Exclude, f: (a: NoInfer) => B): Array<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; +}; +export { +/** + * The "do simulation" for array allows you to sequentially apply operations to the elements of arrays, just as nested loops allow you to go through all combinations of elements in an arrays. + * + * It can be used to simulate "array comprehension". + * It's a technique that allows you to create new arrays by iterating over existing ones and applying specific **conditions** or **transformations** to the elements. It's like assembling a new collection from pieces of other collections based on certain rules. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Array` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Array` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * **Example** + * + * ```ts + * import { Array, pipe } from "effect" + * + * const doResult = pipe( + * Array.Do, + * Array.bind("x", () => [1, 3, 5]), + * Array.bind("y", () => [2, 4, 6]), + * Array.filter(({ x, y }) => x < y), // condition + * Array.map(({ x, y }) => [x, y] as const) // transformation + * ) + * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]] + * + * // equivalent + * const x = [1, 3, 5], + * y = [2, 4, 6], + * result = []; + * for(let i = 0; i < x.length; i++) { + * for(let j = 0; j < y.length; j++) { + * const _x = x[i], _y = y[j]; + * if(_x < _y) result.push([_x, _y] as const) + * } + * } + * + * ``` + * + * @see {@link bindTo} + * @see {@link bind} + * @see {@link Do} + * + * @category do notation + * @since 3.2.0 + */ +let_ as let }; +//# sourceMappingURL=Array.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Array.d.ts.map b/backend/node_modules/effect/dist/dts/Array.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6331e625a6c8740857482999224b47bb88aa2250 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Array.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Array.d.ts","sourceRoot":"","sources":["../../src/Array.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/BigDecimal.d.ts b/backend/node_modules/effect/dist/dts/BigDecimal.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c153b402dc94f73ed0e069cd0b6d4d0887905d0c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/BigDecimal.d.ts @@ -0,0 +1,1483 @@ +/** + * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript. + * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`. + * + * A `BigDecimal` allows storing any real number to arbitrary precision; which avoids common floating point errors + * (such as 0.1 + 0.2 ≠ 0.3) at the cost of complexity. + * + * Internally, `BigDecimal` uses a `BigInt` object, paired with a 64-bit integer which determines the position of the + * decimal point. Therefore, the precision *is not* actually arbitrary, but limited to 263 decimal places. + * + * It is not recommended to convert a floating point number to a decimal directly, as the floating point representation + * may be unexpected. + * + * @module BigDecimal + * @since 2.0.0 + * @see {@link module:BigInt} for more similar operations on `bigint` types + * @see {@link module:Number} for more similar operations on `number` types + */ +import * as Equal from "./Equal.js"; +import * as equivalence from "./Equivalence.js"; +import { type Inspectable } from "./Inspectable.js"; +import * as Option from "./Option.js"; +import * as order from "./Order.js"; +import type { Ordering } from "./Ordering.js"; +import { type Pipeable } from "./Pipeable.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface BigDecimal extends Equal.Equal, Pipeable, Inspectable { + readonly [TypeId]: TypeId; + readonly value: bigint; + readonly scale: number; +} +/** + * Checks if a given value is a `BigDecimal`. + * + * @since 2.0.0 + * @category guards + */ +export declare const isBigDecimal: (u: unknown) => u is BigDecimal; +/** + * Creates a `BigDecimal` from a `bigint` value and a scale. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (value: bigint, scale: number) => BigDecimal; +/** + * Normalizes a given `BigDecimal` by removing trailing zeros. + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { normalize, make, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(normalize(unsafeFromString("123.00000")), normalize(make(123n, 0))) + * assert.deepStrictEqual(normalize(unsafeFromString("12300000")), normalize(make(123n, -5))) + * ``` + * + * @since 2.0.0 + * @category scaling + */ +export declare const normalize: (self: BigDecimal) => BigDecimal; +/** + * Scales a given `BigDecimal` to the specified scale. + * + * If the given scale is smaller than the current scale, the value will be rounded down to + * the nearest integer. + * + * @since 2.0.0 + * @category scaling + */ +export declare const scale: { + /** + * Scales a given `BigDecimal` to the specified scale. + * + * If the given scale is smaller than the current scale, the value will be rounded down to + * the nearest integer. + * + * @since 2.0.0 + * @category scaling + */ + (scale: number): (self: BigDecimal) => BigDecimal; + /** + * Scales a given `BigDecimal` to the specified scale. + * + * If the given scale is smaller than the current scale, the value will be rounded down to + * the nearest integer. + * + * @since 2.0.0 + * @category scaling + */ + (self: BigDecimal, scale: number): BigDecimal; +}; +/** + * Provides an addition operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { sum, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(sum(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("5")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const sum: { + /** + * Provides an addition operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { sum, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(sum(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("5")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (that: BigDecimal): (self: BigDecimal) => BigDecimal; + /** + * Provides an addition operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { sum, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(sum(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("5")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, that: BigDecimal): BigDecimal; +}; +/** + * Provides a multiplication operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { multiply, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(multiply(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("6")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const multiply: { + /** + * Provides a multiplication operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { multiply, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(multiply(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("6")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (that: BigDecimal): (self: BigDecimal) => BigDecimal; + /** + * Provides a multiplication operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { multiply, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(multiply(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("6")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, that: BigDecimal): BigDecimal; +}; +/** + * Provides a subtraction operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { subtract, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(subtract(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("-1")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const subtract: { + /** + * Provides a subtraction operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { subtract, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(subtract(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("-1")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (that: BigDecimal): (self: BigDecimal) => BigDecimal; + /** + * Provides a subtraction operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { subtract, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(subtract(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("-1")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, that: BigDecimal): BigDecimal; +}; +/** + * Provides a division operation on `BigDecimal`s. + * + * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value + * which represents the integer division rounded down to the nearest integer. + * + * If the divisor is `0`, the result will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("3")), Option.some(BigDecimal.unsafeFromString("2"))) + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("4")), Option.some(BigDecimal.unsafeFromString("1.5"))) + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("0")), Option.none()) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const divide: { + /** + * Provides a division operation on `BigDecimal`s. + * + * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value + * which represents the integer division rounded down to the nearest integer. + * + * If the divisor is `0`, the result will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("3")), Option.some(BigDecimal.unsafeFromString("2"))) + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("4")), Option.some(BigDecimal.unsafeFromString("1.5"))) + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("0")), Option.none()) + * ``` + * + * @since 2.0.0 + * @category math + */ + (that: BigDecimal): (self: BigDecimal) => Option.Option; + /** + * Provides a division operation on `BigDecimal`s. + * + * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value + * which represents the integer division rounded down to the nearest integer. + * + * If the divisor is `0`, the result will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("3")), Option.some(BigDecimal.unsafeFromString("2"))) + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("4")), Option.some(BigDecimal.unsafeFromString("1.5"))) + * assert.deepStrictEqual(BigDecimal.divide(BigDecimal.unsafeFromString("6"), BigDecimal.unsafeFromString("0")), Option.none()) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, that: BigDecimal): Option.Option; +}; +/** + * Provides an unsafe division operation on `BigDecimal`s. + * + * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value + * which represents the integer division rounded down to the nearest integer. + * + * Throws a `RangeError` if the divisor is `0`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeDivide, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("3")), unsafeFromString("2")) + * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("4")), unsafeFromString("1.5")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const unsafeDivide: { + /** + * Provides an unsafe division operation on `BigDecimal`s. + * + * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value + * which represents the integer division rounded down to the nearest integer. + * + * Throws a `RangeError` if the divisor is `0`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeDivide, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("3")), unsafeFromString("2")) + * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("4")), unsafeFromString("1.5")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (that: BigDecimal): (self: BigDecimal) => BigDecimal; + /** + * Provides an unsafe division operation on `BigDecimal`s. + * + * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value + * which represents the integer division rounded down to the nearest integer. + * + * Throws a `RangeError` if the divisor is `0`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeDivide, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("3")), unsafeFromString("2")) + * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("4")), unsafeFromString("1.5")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, that: BigDecimal): BigDecimal; +}; +/** + * @since 2.0.0 + * @category instances + */ +export declare const Order: order.Order; +/** + * Returns `true` if the first argument is less than the second, otherwise `false`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { lessThan, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(lessThan(unsafeFromString("2"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThan(unsafeFromString("3"), unsafeFromString("3")), false) + * assert.deepStrictEqual(lessThan(unsafeFromString("4"), unsafeFromString("3")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const lessThan: { + /** + * Returns `true` if the first argument is less than the second, otherwise `false`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { lessThan, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(lessThan(unsafeFromString("2"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThan(unsafeFromString("3"), unsafeFromString("3")), false) + * assert.deepStrictEqual(lessThan(unsafeFromString("4"), unsafeFromString("3")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (that: BigDecimal): (self: BigDecimal) => boolean; + /** + * Returns `true` if the first argument is less than the second, otherwise `false`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { lessThan, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(lessThan(unsafeFromString("2"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThan(unsafeFromString("3"), unsafeFromString("3")), false) + * assert.deepStrictEqual(lessThan(unsafeFromString("4"), unsafeFromString("3")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (self: BigDecimal, that: BigDecimal): boolean; +}; +/** + * Checks if a given `BigDecimal` is less than or equal to the provided one. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { lessThanOrEqualTo, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const lessThanOrEqualTo: { + /** + * Checks if a given `BigDecimal` is less than or equal to the provided one. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { lessThanOrEqualTo, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (that: BigDecimal): (self: BigDecimal) => boolean; + /** + * Checks if a given `BigDecimal` is less than or equal to the provided one. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { lessThanOrEqualTo, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true) + * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (self: BigDecimal, that: BigDecimal): boolean; +}; +/** + * Returns `true` if the first argument is greater than the second, otherwise `false`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { greaterThan, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(greaterThan(unsafeFromString("2"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThan(unsafeFromString("3"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThan(unsafeFromString("4"), unsafeFromString("3")), true) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const greaterThan: { + /** + * Returns `true` if the first argument is greater than the second, otherwise `false`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { greaterThan, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(greaterThan(unsafeFromString("2"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThan(unsafeFromString("3"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThan(unsafeFromString("4"), unsafeFromString("3")), true) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (that: BigDecimal): (self: BigDecimal) => boolean; + /** + * Returns `true` if the first argument is greater than the second, otherwise `false`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { greaterThan, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(greaterThan(unsafeFromString("2"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThan(unsafeFromString("3"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThan(unsafeFromString("4"), unsafeFromString("3")), true) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (self: BigDecimal, that: BigDecimal): boolean; +}; +/** + * Checks if a given `BigDecimal` is greater than or equal to the provided one. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { greaterThanOrEqualTo, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true) + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), true) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const greaterThanOrEqualTo: { + /** + * Checks if a given `BigDecimal` is greater than or equal to the provided one. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { greaterThanOrEqualTo, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true) + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), true) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (that: BigDecimal): (self: BigDecimal) => boolean; + /** + * Checks if a given `BigDecimal` is greater than or equal to the provided one. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { greaterThanOrEqualTo, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), false) + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true) + * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), true) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (self: BigDecimal, that: BigDecimal): boolean; +}; +/** + * Checks if a `BigDecimal` is between a `minimum` and `maximum` value (inclusive). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal } from "effect" + * + * const between = BigDecimal.between({ + * minimum: BigDecimal.unsafeFromString("1"), + * maximum: BigDecimal.unsafeFromString("5") } + * ) + * + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("3")), true) + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("0")), false) + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("6")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const between: { + /** + * Checks if a `BigDecimal` is between a `minimum` and `maximum` value (inclusive). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal } from "effect" + * + * const between = BigDecimal.between({ + * minimum: BigDecimal.unsafeFromString("1"), + * maximum: BigDecimal.unsafeFromString("5") } + * ) + * + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("3")), true) + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("0")), false) + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("6")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (options: { + minimum: BigDecimal; + maximum: BigDecimal; + }): (self: BigDecimal) => boolean; + /** + * Checks if a `BigDecimal` is between a `minimum` and `maximum` value (inclusive). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal } from "effect" + * + * const between = BigDecimal.between({ + * minimum: BigDecimal.unsafeFromString("1"), + * maximum: BigDecimal.unsafeFromString("5") } + * ) + * + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("3")), true) + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("0")), false) + * assert.deepStrictEqual(between(BigDecimal.unsafeFromString("6")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ + (self: BigDecimal, options: { + minimum: BigDecimal; + maximum: BigDecimal; + }): boolean; +}; +/** + * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values. + * + * - If the `BigDecimal` is less than the `minimum` value, the function returns the `minimum` value. + * - If the `BigDecimal` is greater than the `maximum` value, the function returns the `maximum` value. + * - Otherwise, it returns the original `BigDecimal`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal } from "effect" + * + * const clamp = BigDecimal.clamp({ + * minimum: BigDecimal.unsafeFromString("1"), + * maximum: BigDecimal.unsafeFromString("5") } + * ) + * + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("3")), BigDecimal.unsafeFromString("3")) + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("0")), BigDecimal.unsafeFromString("1")) + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("6")), BigDecimal.unsafeFromString("5")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const clamp: { + /** + * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values. + * + * - If the `BigDecimal` is less than the `minimum` value, the function returns the `minimum` value. + * - If the `BigDecimal` is greater than the `maximum` value, the function returns the `maximum` value. + * - Otherwise, it returns the original `BigDecimal`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal } from "effect" + * + * const clamp = BigDecimal.clamp({ + * minimum: BigDecimal.unsafeFromString("1"), + * maximum: BigDecimal.unsafeFromString("5") } + * ) + * + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("3")), BigDecimal.unsafeFromString("3")) + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("0")), BigDecimal.unsafeFromString("1")) + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("6")), BigDecimal.unsafeFromString("5")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (options: { + minimum: BigDecimal; + maximum: BigDecimal; + }): (self: BigDecimal) => BigDecimal; + /** + * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values. + * + * - If the `BigDecimal` is less than the `minimum` value, the function returns the `minimum` value. + * - If the `BigDecimal` is greater than the `maximum` value, the function returns the `maximum` value. + * - Otherwise, it returns the original `BigDecimal`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal } from "effect" + * + * const clamp = BigDecimal.clamp({ + * minimum: BigDecimal.unsafeFromString("1"), + * maximum: BigDecimal.unsafeFromString("5") } + * ) + * + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("3")), BigDecimal.unsafeFromString("3")) + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("0")), BigDecimal.unsafeFromString("1")) + * assert.deepStrictEqual(clamp(BigDecimal.unsafeFromString("6")), BigDecimal.unsafeFromString("5")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, options: { + minimum: BigDecimal; + maximum: BigDecimal; + }): BigDecimal; +}; +/** + * Returns the minimum between two `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { min, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(min(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("2")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const min: { + /** + * Returns the minimum between two `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { min, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(min(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("2")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (that: BigDecimal): (self: BigDecimal) => BigDecimal; + /** + * Returns the minimum between two `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { min, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(min(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("2")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, that: BigDecimal): BigDecimal; +}; +/** + * Returns the maximum between two `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { max, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(max(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("3")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const max: { + /** + * Returns the maximum between two `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { max, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(max(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("3")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (that: BigDecimal): (self: BigDecimal) => BigDecimal; + /** + * Returns the maximum between two `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { max, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(max(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("3")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, that: BigDecimal): BigDecimal; +}; +/** + * Determines the sign of a given `BigDecimal`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { sign, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(sign(unsafeFromString("-5")), -1) + * assert.deepStrictEqual(sign(unsafeFromString("0")), 0) + * assert.deepStrictEqual(sign(unsafeFromString("5")), 1) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const sign: (n: BigDecimal) => Ordering; +/** + * Determines the absolute value of a given `BigDecimal`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { abs, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(abs(unsafeFromString("-5")), unsafeFromString("5")) + * assert.deepStrictEqual(abs(unsafeFromString("0")), unsafeFromString("0")) + * assert.deepStrictEqual(abs(unsafeFromString("5")), unsafeFromString("5")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const abs: (n: BigDecimal) => BigDecimal; +/** + * Provides a negate operation on `BigDecimal`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { negate, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(negate(unsafeFromString("3")), unsafeFromString("-3")) + * assert.deepStrictEqual(negate(unsafeFromString("-6")), unsafeFromString("6")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const negate: (n: BigDecimal) => BigDecimal; +/** + * Returns the remainder left over when one operand is divided by a second operand. + * + * If the divisor is `0`, the result will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("2"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0"))) + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("3"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("1"))) + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("-4"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0"))) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const remainder: { + /** + * Returns the remainder left over when one operand is divided by a second operand. + * + * If the divisor is `0`, the result will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("2"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0"))) + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("3"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("1"))) + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("-4"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0"))) + * ``` + * + * @since 2.0.0 + * @category math + */ + (divisor: BigDecimal): (self: BigDecimal) => Option.Option; + /** + * Returns the remainder left over when one operand is divided by a second operand. + * + * If the divisor is `0`, the result will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("2"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0"))) + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("3"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("1"))) + * assert.deepStrictEqual(BigDecimal.remainder(BigDecimal.unsafeFromString("-4"), BigDecimal.unsafeFromString("2")), Option.some(BigDecimal.unsafeFromString("0"))) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, divisor: BigDecimal): Option.Option; +}; +/** + * Returns the remainder left over when one operand is divided by a second operand. + * + * Throws a `RangeError` if the divisor is `0`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeRemainder, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("2"), unsafeFromString("2")), unsafeFromString("0")) + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("3"), unsafeFromString("2")), unsafeFromString("1")) + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("-4"), unsafeFromString("2")), unsafeFromString("0")) + * ``` + * + * @since 2.0.0 + * @category math + */ +export declare const unsafeRemainder: { + /** + * Returns the remainder left over when one operand is divided by a second operand. + * + * Throws a `RangeError` if the divisor is `0`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeRemainder, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("2"), unsafeFromString("2")), unsafeFromString("0")) + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("3"), unsafeFromString("2")), unsafeFromString("1")) + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("-4"), unsafeFromString("2")), unsafeFromString("0")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (divisor: BigDecimal): (self: BigDecimal) => BigDecimal; + /** + * Returns the remainder left over when one operand is divided by a second operand. + * + * Throws a `RangeError` if the divisor is `0`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeRemainder, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("2"), unsafeFromString("2")), unsafeFromString("0")) + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("3"), unsafeFromString("2")), unsafeFromString("1")) + * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("-4"), unsafeFromString("2")), unsafeFromString("0")) + * ``` + * + * @since 2.0.0 + * @category math + */ + (self: BigDecimal, divisor: BigDecimal): BigDecimal; +}; +/** + * @category instances + * @since 2.0.0 + */ +export declare const Equivalence: equivalence.Equivalence; +/** + * Checks if two `BigDecimal`s are equal. + * + * @since 2.0.0 + * @category predicates + */ +export declare const equals: { + /** + * Checks if two `BigDecimal`s are equal. + * + * @since 2.0.0 + * @category predicates + */ + (that: BigDecimal): (self: BigDecimal) => boolean; + /** + * Checks if two `BigDecimal`s are equal. + * + * @since 2.0.0 + * @category predicates + */ + (self: BigDecimal, that: BigDecimal): boolean; +}; +/** + * Creates a `BigDecimal` from a `bigint` value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromBigInt: (n: bigint) => BigDecimal; +/** + * Creates a `BigDecimal` from a `number` value. + * + * It is not recommended to convert a floating point number to a decimal directly, + * as the floating point representation may be unexpected. + * + * Throws a `RangeError` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeFromNumber, make } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeFromNumber(123), make(123n, 0)) + * assert.deepStrictEqual(unsafeFromNumber(123.456), make(123456n, 3)) + * ``` + * + * @since 3.11.0 + * @category constructors + */ +export declare const unsafeFromNumber: (n: number) => BigDecimal; +/** + * Creates a `BigDecimal` from a `number` value. + * + * It is not recommended to convert a floating point number to a decimal directly, + * as the floating point representation may be unexpected. + * + * Throws a `RangeError` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`). + * + * @since 2.0.0 + * @category constructors + * @deprecated Use {@link unsafeFromNumber} instead. + */ +export declare const fromNumber: (n: number) => BigDecimal; +/** + * Creates a `BigDecimal` from a `number` value. + * + * It is not recommended to convert a floating point number to a decimal directly, + * as the floating point representation may be unexpected. + * + * Returns `None` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.safeFromNumber(123), Option.some(BigDecimal.make(123n, 0))) + * assert.deepStrictEqual(BigDecimal.safeFromNumber(123.456), Option.some(BigDecimal.make(123456n, 3))) + * assert.deepStrictEqual(BigDecimal.safeFromNumber(Infinity), Option.none()) + * ``` + * + * @since 3.11.0 + * @category constructors + */ +export declare const safeFromNumber: (n: number) => Option.Option; +/** + * Parses a numerical `string` into a `BigDecimal`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { BigDecimal, Option } from "effect" + * + * assert.deepStrictEqual(BigDecimal.fromString("123"), Option.some(BigDecimal.make(123n, 0))) + * assert.deepStrictEqual(BigDecimal.fromString("123.456"), Option.some(BigDecimal.make(123456n, 3))) + * assert.deepStrictEqual(BigDecimal.fromString("123.abc"), Option.none()) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromString: (s: string) => Option.Option; +/** + * Parses a numerical `string` into a `BigDecimal`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeFromString, make } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeFromString("123"), make(123n, 0)) + * assert.deepStrictEqual(unsafeFromString("123.456"), make(123456n, 3)) + * assert.throws(() => unsafeFromString("123.abc")) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeFromString: (s: string) => BigDecimal; +/** + * Formats a given `BigDecimal` as a `string`. + * + * If the scale of the `BigDecimal` is greater than or equal to 16, the `BigDecimal` will + * be formatted in scientific notation. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { format, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(format(unsafeFromString("-5")), "-5") + * assert.deepStrictEqual(format(unsafeFromString("123.456")), "123.456") + * assert.deepStrictEqual(format(unsafeFromString("-0.00000123")), "-0.00000123") + * ``` + * + * @since 2.0.0 + * @category conversions + */ +export declare const format: (n: BigDecimal) => string; +/** + * Formats a given `BigDecimal` as a `string` in scientific notation. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { toExponential, make } from "effect/BigDecimal" + * + * assert.deepStrictEqual(toExponential(make(123456n, -5)), "1.23456e+10") + * ``` + * + * @since 3.11.0 + * @category conversions + */ +export declare const toExponential: (n: BigDecimal) => string; +/** + * Converts a `BigDecimal` to a `number`. + * + * This function will produce incorrect results if the `BigDecimal` exceeds the 64-bit range of a `number`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeToNumber, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(unsafeToNumber(unsafeFromString("123.456")), 123.456) + * ``` + * + * @since 2.0.0 + * @category conversions + */ +export declare const unsafeToNumber: (n: BigDecimal) => number; +/** + * Checks if a given `BigDecimal` is an integer. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isInteger, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(isInteger(unsafeFromString("0")), true) + * assert.deepStrictEqual(isInteger(unsafeFromString("1")), true) + * assert.deepStrictEqual(isInteger(unsafeFromString("1.1")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const isInteger: (n: BigDecimal) => boolean; +/** + * Checks if a given `BigDecimal` is `0`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isZero, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(isZero(unsafeFromString("0")), true) + * assert.deepStrictEqual(isZero(unsafeFromString("1")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const isZero: (n: BigDecimal) => boolean; +/** + * Checks if a given `BigDecimal` is negative. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNegative, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(isNegative(unsafeFromString("-1")), true) + * assert.deepStrictEqual(isNegative(unsafeFromString("0")), false) + * assert.deepStrictEqual(isNegative(unsafeFromString("1")), false) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const isNegative: (n: BigDecimal) => boolean; +/** + * Checks if a given `BigDecimal` is positive. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isPositive, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(isPositive(unsafeFromString("-1")), false) + * assert.deepStrictEqual(isPositive(unsafeFromString("0")), false) + * assert.deepStrictEqual(isPositive(unsafeFromString("1")), true) + * ``` + * + * @since 2.0.0 + * @category predicates + */ +export declare const isPositive: (n: BigDecimal) => boolean; +/** + * Calculate the ceiling of a `BigDecimal` at the given scale. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { ceil, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(ceil(unsafeFromString("145"), -1), unsafeFromString("150")) + * assert.deepStrictEqual(ceil(unsafeFromString("-14.5")), unsafeFromString("-14")) + * ``` + * + * @since 3.16.0 + * @category math + */ +export declare const ceil: { + /** + * Calculate the ceiling of a `BigDecimal` at the given scale. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { ceil, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(ceil(unsafeFromString("145"), -1), unsafeFromString("150")) + * assert.deepStrictEqual(ceil(unsafeFromString("-14.5")), unsafeFromString("-14")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (scale: number): (self: BigDecimal) => BigDecimal; + /** + * Calculate the ceiling of a `BigDecimal` at the given scale. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { ceil, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(ceil(unsafeFromString("145"), -1), unsafeFromString("150")) + * assert.deepStrictEqual(ceil(unsafeFromString("-14.5")), unsafeFromString("-14")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (self: BigDecimal, scale?: number): BigDecimal; +}; +/** + * Calculate the floor of a `BigDecimal` at the given scale. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { floor, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(floor(unsafeFromString("145"), -1), unsafeFromString("140")) + * assert.deepStrictEqual(floor(unsafeFromString("-14.5")), unsafeFromString("-15")) + * ``` + * + * @since 3.16.0 + * @category math + */ +export declare const floor: { + /** + * Calculate the floor of a `BigDecimal` at the given scale. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { floor, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(floor(unsafeFromString("145"), -1), unsafeFromString("140")) + * assert.deepStrictEqual(floor(unsafeFromString("-14.5")), unsafeFromString("-15")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (scale: number): (self: BigDecimal) => BigDecimal; + /** + * Calculate the floor of a `BigDecimal` at the given scale. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { floor, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(floor(unsafeFromString("145"), -1), unsafeFromString("140")) + * assert.deepStrictEqual(floor(unsafeFromString("-14.5")), unsafeFromString("-15")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (self: BigDecimal, scale?: number): BigDecimal; +}; +/** + * Truncate a `BigDecimal` at the given scale. This is the same operation as rounding away from zero. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { truncate, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(truncate(unsafeFromString("145"), -1), unsafeFromString("140")) + * assert.deepStrictEqual(truncate(unsafeFromString("-14.5")), unsafeFromString("-14")) + * ``` + * + * @since 3.16.0 + * @category math + */ +export declare const truncate: { + /** + * Truncate a `BigDecimal` at the given scale. This is the same operation as rounding away from zero. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { truncate, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(truncate(unsafeFromString("145"), -1), unsafeFromString("140")) + * assert.deepStrictEqual(truncate(unsafeFromString("-14.5")), unsafeFromString("-14")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (scale: number): (self: BigDecimal) => BigDecimal; + /** + * Truncate a `BigDecimal` at the given scale. This is the same operation as rounding away from zero. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { truncate, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(truncate(unsafeFromString("145"), -1), unsafeFromString("140")) + * assert.deepStrictEqual(truncate(unsafeFromString("-14.5")), unsafeFromString("-14")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (self: BigDecimal, scale?: number): BigDecimal; +}; +/** + * Rounding modes for `BigDecimal`. + * + * `ceil`: round towards positive infinity + * `floor`: round towards negative infinity + * `to-zero`: round towards zero + * `from-zero`: round away from zero + * `half-ceil`: round to the nearest neighbor; if equidistant round towards positive infinity + * `half-floor`: round to the nearest neighbor; if equidistant round towards negative infinity + * `half-to-zero`: round to the nearest neighbor; if equidistant round towards zero + * `half-from-zero`: round to the nearest neighbor; if equidistant round away from zero + * `half-even`: round to the nearest neighbor; if equidistant round to the neighbor with an even digit + * `half-odd`: round to the nearest neighbor; if equidistant round to the neighbor with an odd digit + * + * @since 3.16.0 + * @category math + */ +export type RoundingMode = "ceil" | "floor" | "to-zero" | "from-zero" | "half-ceil" | "half-floor" | "half-to-zero" | "half-from-zero" | "half-even" | "half-odd"; +/** + * Rounds a `BigDecimal` at the given scale with the specified rounding mode. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { round, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(round(unsafeFromString("145"), { mode: "from-zero", scale: -1 }), unsafeFromString("150")) + * assert.deepStrictEqual(round(unsafeFromString("-14.5")), unsafeFromString("-15")) + * ``` + * + * @since 3.16.0 + * @category math + */ +export declare const round: { + /** + * Rounds a `BigDecimal` at the given scale with the specified rounding mode. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { round, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(round(unsafeFromString("145"), { mode: "from-zero", scale: -1 }), unsafeFromString("150")) + * assert.deepStrictEqual(round(unsafeFromString("-14.5")), unsafeFromString("-15")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (options: { + scale?: number; + mode?: RoundingMode; + }): (self: BigDecimal) => BigDecimal; + /** + * Rounds a `BigDecimal` at the given scale with the specified rounding mode. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { round, unsafeFromString } from "effect/BigDecimal" + * + * assert.deepStrictEqual(round(unsafeFromString("145"), { mode: "from-zero", scale: -1 }), unsafeFromString("150")) + * assert.deepStrictEqual(round(unsafeFromString("-14.5")), unsafeFromString("-15")) + * ``` + * + * @since 3.16.0 + * @category math + */ + (n: BigDecimal, options?: { + scale?: number; + mode?: RoundingMode; + }): BigDecimal; +}; +/** + * Takes an `Iterable` of `BigDecimal`s and returns their sum as a single `BigDecimal` + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { unsafeFromString, sumAll } from "effect/BigDecimal" + * + * assert.deepStrictEqual(sumAll([unsafeFromString("2"), unsafeFromString("3"), unsafeFromString("4")]), unsafeFromString("9")) + * ``` + * + * @category math + * @since 3.16.0 + */ +export declare const sumAll: (collection: Iterable) => BigDecimal; +//# sourceMappingURL=BigDecimal.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/BigDecimal.d.ts.map b/backend/node_modules/effect/dist/dts/BigDecimal.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6f547910b8694b85722c7bf830e96967342639a3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/BigDecimal.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"BigDecimal.d.ts","sourceRoot":"","sources":["../../src/BigDecimal.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Boolean.d.ts.map b/backend/node_modules/effect/dist/dts/Boolean.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..772c192912a48e0086aa87a2314a952aa54818e7 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Boolean.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Boolean.d.ts","sourceRoot":"","sources":["../../src/Boolean.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Brand.d.ts.map b/backend/node_modules/effect/dist/dts/Brand.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..b8b5da699cf562709d514e27a5ad3bae3cfb6790 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Brand.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Brand.d.ts","sourceRoot":"","sources":["../../src/Brand.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Cache.d.ts b/backend/node_modules/effect/dist/dts/Cache.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..232443887161c94e0ec2a541c35708628b5008c2 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Cache.d.ts @@ -0,0 +1,241 @@ +/** + * @since 2.0.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import type { Either } from "./Either.js"; +import type * as Exit from "./Exit.js"; +import type * as Option from "./Option.js"; +import type * as Predicate from "./Predicate.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const CacheTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type CacheTypeId = typeof CacheTypeId; +/** + * @since 3.6.4 + * @category symbols + */ +export declare const ConsumerCacheTypeId: unique symbol; +/** + * @since 3.6.4 + * @category symbols + */ +export type ConsumerCacheTypeId = typeof ConsumerCacheTypeId; +/** + * A `Cache` is defined in terms of a lookup function that, given a key of + * type `Key`, can either fail with an error of type `Error` or succeed with a + * value of type `Value`. Getting a value from the cache will either return + * the previous result of the lookup function if it is available or else + * compute a new result with the lookup function, put it in the cache, and + * return it. + * + * A cache also has a specified capacity and time to live. When the cache is + * at capacity the least recently accessed values in the cache will be + * removed to make room for new values. Getting a value with a life older than + * the specified time to live will result in a new value being computed with + * the lookup function and returned when available. + * + * The cache is safe for concurrent access. If multiple fibers attempt to get + * the same key the lookup function will only be computed once and the result + * will be returned to all fibers. + * + * @since 2.0.0 + * @category models + */ +export interface Cache extends ConsumerCache, Cache.Variance { + /** + * Retrieves the value associated with the specified key if it exists. + * Otherwise computes the value with the lookup function, puts it in the + * cache, and returns it. + */ + get(key: Key): Effect.Effect; + /** + * Retrieves the value associated with the specified key if it exists as a left. + * Otherwise computes the value with the lookup function, puts it in the + * cache, and returns it as a right. + */ + getEither(key: Key): Effect.Effect, Error>; + /** + * Computes the value associated with the specified key, with the lookup + * function, and puts it in the cache. The difference between this and + * `get` method is that `refresh` triggers (re)computation of the value + * without invalidating it in the cache, so any request to the associated + * key can still be served while the value is being re-computed/retrieved + * by the lookup function. Additionally, `refresh` always triggers the + * lookup function, disregarding the last `Error`. + */ + refresh(key: Key): Effect.Effect; + /** + * Associates the specified value with the specified key in the cache. + */ + set(key: Key, value: Value): Effect.Effect; +} +/** + * A ConsumerCache models a portion of a cache which is safe to share without allowing to create new values or access existing ones. + * + * It can be used safely to give over control for request management without leaking writer side details. + * + * @since 2.0.0 + * @category models + */ +export interface ConsumerCache extends Cache.ConsumerVariance { + /** + * Retrieves the value associated with the specified key if it exists. + * Otherwise returns `Option.none`. + */ + getOption(key: Key): Effect.Effect, Error>; + /** + * Retrieves the value associated with the specified key if it exists and the + * lookup function has completed. Otherwise returns `Option.none`. + */ + getOptionComplete(key: Key): Effect.Effect>; + /** + * Returns statistics for this cache. + */ + readonly cacheStats: Effect.Effect; + /** + * Returns whether a value associated with the specified key exists in the + * cache. + */ + contains(key: Key): Effect.Effect; + /** + * Returns statistics for the specified entry. + */ + entryStats(key: Key): Effect.Effect>; + /** + * Invalidates the value associated with the specified key. + */ + invalidate(key: Key): Effect.Effect; + /** + * Invalidates the value associated with the specified key if the predicate holds. + */ + invalidateWhen(key: Key, predicate: Predicate.Predicate): Effect.Effect; + /** + * Invalidates all values in the cache. + */ + readonly invalidateAll: Effect.Effect; + /** + * Returns the approximate number of values in the cache. + */ + readonly size: Effect.Effect; + /** + * Returns an approximation of the values in the cache. + */ + readonly keys: Effect.Effect>; + /** + * Returns an approximation of the values in the cache. + */ + readonly values: Effect.Effect>; + /** + * Returns an approximation of the values in the cache. + */ + readonly entries: Effect.Effect>; +} +/** + * @since 2.0.0 + */ +export declare namespace Cache { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [CacheTypeId]: { + readonly _Key: Types.Invariant; + readonly _Error: Types.Covariant; + readonly _Value: Types.Invariant; + }; + } + /** + * @since 3.6.4 + * @category models + */ + interface ConsumerVariance { + readonly [ConsumerCacheTypeId]: { + readonly _Key: Types.Invariant; + readonly _Error: Types.Covariant; + readonly _Value: Types.Covariant; + }; + } +} +/** + * Constructs a new cache with the specified capacity, time to live, and + * lookup function. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (options: { + readonly capacity: number; + readonly timeToLive: Duration.DurationInput; + readonly lookup: Lookup; +}) => Effect.Effect, never, Environment>; +/** + * Constructs a new cache with the specified capacity, time to live, and + * lookup function, where the time to live can depend on the `Exit` value + * returned by the lookup function. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeWith: (options: { + readonly capacity: number; + readonly lookup: Lookup; + readonly timeToLive: (exit: Exit.Exit) => Duration.DurationInput; +}) => Effect.Effect, never, Environment>; +/** + * `CacheStats` represents a snapshot of statistics for the cache as of a + * point in time. + * + * @since 2.0.0 + * @category models + */ +export interface CacheStats { + readonly hits: number; + readonly misses: number; + readonly size: number; +} +/** + * Constructs a new `CacheStats` from the specified values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeCacheStats: (options: { + readonly hits: number; + readonly misses: number; + readonly size: number; +}) => CacheStats; +/** + * Represents a snapshot of statistics for an entry in the cache. + * + * @since 2.0.0 + * @category models + */ +export interface EntryStats { + readonly loadedMillis: number; +} +/** + * Constructs a new `EntryStats` from the specified values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeEntryStats: (loadedMillis: number) => EntryStats; +/** + * A `Lookup` represents a lookup function that, given a key of type `Key`, can + * return an effect that will either produce a value of type `Value` or fail + * with an error of type `Error` using an environment of type `Environment`. + * + * @since 2.0.0 + * @category models + */ +export type Lookup = (key: Key) => Effect.Effect; +//# sourceMappingURL=Cache.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Cache.d.ts.map b/backend/node_modules/effect/dist/dts/Cache.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e6d67d54832cf1bfcb9c7d4a971dbe5c44a48a43 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Cache.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../src/Cache.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Cause.d.ts b/backend/node_modules/effect/dist/dts/Cause.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0c958371aa2a1bd28a90b860204729b785ef8ba5 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Cause.d.ts @@ -0,0 +1,1928 @@ +/** + * The `Effect` type is polymorphic in values of type `E` and we can + * work with any error type that we want. However, there is a lot of information + * that is not inside an arbitrary `E` value. So as a result, an `Effect` needs + * somewhere to store things like unexpected errors or defects, stack and + * execution traces, causes of fiber interruptions, and so forth. + * + * Effect-TS is very strict about preserving the full information related to a + * failure. It captures all type of errors into the `Cause` data type. `Effect` + * uses the `Cause` data type to store the full story of failure. So its + * error model is lossless. It doesn't throw information related to the failure + * result. So we can figure out exactly what happened during the operation of + * our effects. + * + * It is important to note that `Cause` is an underlying data type representing + * errors occuring within an `Effect` workflow. Thus, we don't usually deal with + * `Cause`s directly. Even though it is not a data type that we deal with very + * often, the `Cause` of a failing `Effect` workflow can be accessed at any + * time, which gives us total access to all parallel and sequential errors in + * occurring within our codebase. + * + * @since 2.0.0 + */ +import type * as Channel from "./Channel.js"; +import type * as Chunk from "./Chunk.js"; +import type * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type * as Equal from "./Equal.js"; +import type * as FiberId from "./FiberId.js"; +import type * as HashSet from "./HashSet.js"; +import type { Inspectable } from "./Inspectable.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import type * as Sink from "./Sink.js"; +import type * as Stream from "./Stream.js"; +import type { Span } from "./Tracer.js"; +import type { Covariant, NoInfer } from "./Types.js"; +/** + * A unique symbol identifying the `Cause` type. + * + * **Details** + * + * This provides a symbol that helps identify instances of the `Cause` data + * type. This can be used for advanced operations such as refining types or + * building internal utilities that check whether an unknown value is a `Cause`. + * + * @see {@link isCause} Check if a value is a `Cause` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const CauseTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type CauseTypeId = typeof CauseTypeId; +/** + * A unique symbol identifying the `RuntimeException` type. + * + * **Details** + * + * This provides a symbol that identifies a `RuntimeException`. This is + * typically used internally by the library to recognize checked exceptions that + * occur during runtime. + * + * @see {@link RuntimeException} Create or work with a `RuntimeException` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const RuntimeExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type RuntimeExceptionTypeId = typeof RuntimeExceptionTypeId; +/** + * A unique symbol identifying the `InterruptedException` type. + * + * **Details** + * + * This provides a symbol that identifies an `InterruptedException`. This is + * typically used internally to recognize when a fiber has been interrupted, + * helping the framework handle interruption logic correctly. + * + * @see {@link InterruptedException} Create or work with an `InterruptedException` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const InterruptedExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type InterruptedExceptionTypeId = typeof InterruptedExceptionTypeId; +/** + * A unique symbol identifying the `IllegalArgumentException` type. + * + * **Details** + * + * This provides a symbol that identifies an `IllegalArgumentException`. This is + * often used in scenarios where invalid arguments are supplied to methods that + * expect specific input. + * + * @see {@link IllegalArgumentException} Create or work with an `IllegalArgumentException` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const IllegalArgumentExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type IllegalArgumentExceptionTypeId = typeof IllegalArgumentExceptionTypeId; +/** + * A unique symbol identifying the `NoSuchElementException` type. + * + * **Details** + * + * This provides a symbol that identifies a `NoSuchElementException`. It helps + * differentiate cases where a required element is missing within a data + * structure. + * + * @see {@link NoSuchElementException} Create or work with a `NoSuchElementException` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const NoSuchElementExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type NoSuchElementExceptionTypeId = typeof NoSuchElementExceptionTypeId; +/** + * A unique symbol identifying the `InvalidPubSubCapacityException` type. + * + * **Details** + * + * This provides a symbol that identifies an `InvalidPubSubCapacityException`. + * It indicates an error related to an invalid capacity passed to a `PubSub` + * structure. + * + * @see {@link InvalidPubSubCapacityException} Create or work with an `InvalidPubSubCapacityException` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const InvalidPubSubCapacityExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type InvalidPubSubCapacityExceptionTypeId = typeof InvalidPubSubCapacityExceptionTypeId; +/** + * A unique symbol identifying the `ExceededCapacityException` type. + * + * **Details** + * + * This provides a symbol that identifies an `ExceededCapacityException`. It + * denotes situations where a resource has exceeded its configured capacity + * limit. + * + * @see {@link ExceededCapacityException} Create or work with an `ExceededCapacityException` + * + * @since 3.5.0 + * @category Symbols + */ +export declare const ExceededCapacityExceptionTypeId: unique symbol; +/** + * @since 3.5.0 + * @category Symbols + */ +export type ExceededCapacityExceptionTypeId = typeof ExceededCapacityExceptionTypeId; +/** + * A unique symbol identifying the `TimeoutException` type. + * + * **Details** + * + * This provides a symbol that identifies a `TimeoutException`. It helps the + * framework recognize errors related to operations that fail to complete within + * a given timeframe. + * + * @see {@link TimeoutException} Create or work with a `TimeoutException` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const TimeoutExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type TimeoutExceptionTypeId = typeof TimeoutExceptionTypeId; +/** + * A unique symbol identifying the `UnknownException` type. + * + * **Details** + * + * This provides a symbol that identifies an `UnknownException`. It is typically + * used for generic or unexpected errors that do not fit other specific + * exception categories. + * + * @see {@link UnknownException} Create or work with an `UnknownException` + * + * @since 2.0.0 + * @category Symbols + */ +export declare const UnknownExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type UnknownExceptionTypeId = typeof UnknownExceptionTypeId; +/** + * Represents the full history of a failure within an `Effect`. + * + * **Details** + * + * This type is a data structure that captures all information about why and how + * an effect has failed, including parallel errors, sequential errors, defects, + * and interruptions. It enables a "lossless" error model: no error-related + * information is discarded, which helps in debugging and understanding the root + * cause of failures. + * + * @since 2.0.0 + * @category Models + */ +export type Cause = Empty | Fail | Die | Interrupt | Sequential | Parallel; +/** + * @since 2.0.0 + */ +export declare namespace Cause { + /** + * This interface is used internally to manage the type variance of `Cause`. + * + * @since 2.0.0 + * @category Models + */ + interface Variance { + readonly [CauseTypeId]: { + readonly _E: Covariant; + }; + } +} +/** + * Describes methods for reducing a `Cause` into a value of type `Z` with + * access to contextual information. + * + * **Details** + * + * This interface is meant for advanced transformations of `Cause`. By + * implementing each method, you can define how different parts of the `Cause` + * structure (like `Fail`, `Die`, or `Interrupt`) should be transformed into a + * final type `Z`. The `context` parameter carries additional data needed during + * this reduction. + * + * @see {@link reduceWithContext} Apply a `CauseReducer` to transform a `Cause` + * + * @since 2.0.0 + * @category Models + */ +export interface CauseReducer { + emptyCase(context: C): Z; + failCase(context: C, error: E): Z; + dieCase(context: C, defect: unknown): Z; + interruptCase(context: C, fiberId: FiberId.FiberId): Z; + sequentialCase(context: C, left: Z, right: Z): Z; + parallelCase(context: C, left: Z, right: Z): Z; +} +/** + * Represents an error object that can be yielded in `Effect.gen`. + * + * @since 2.0.0 + * @category Models + */ +export interface YieldableError extends Pipeable, Inspectable, Error { + readonly [Effect.EffectTypeId]: Effect.Effect.VarianceStruct; + readonly [Stream.StreamTypeId]: Stream.Stream.VarianceStruct; + readonly [Sink.SinkTypeId]: Sink.Sink.VarianceStruct; + readonly [Channel.ChannelTypeId]: Channel.Channel.VarianceStruct; + [Symbol.iterator](): Effect.EffectGenerator>; +} +/** + * Creates an error that occurs at runtime, extendable for other exception + * types. + * + * @since 2.0.0 + * @category Errors + */ +export declare const YieldableError: new (message?: string | undefined) => YieldableError; +/** + * An error representing a runtime error. + * + * **Details** + * + * This interface is used for errors that occur at runtime but are still + * considered recoverable or typed. + * + * @since 2.0.0 + * @category Models + */ +export interface RuntimeException extends YieldableError { + readonly _tag: "RuntimeException"; + readonly [RuntimeExceptionTypeId]: RuntimeExceptionTypeId; +} +/** + * An error representing fiber interruption. + * + * **Details** + * + * This interface represents errors that occur when a fiber is forcefully + * interrupted. Interruption can happen for various reasons, including + * cancellations or system directives to halt operations. Code that deals with + * concurrency might need to catch or handle these to ensure proper cleanup. + * + * @since 2.0.0 + * @category Models + */ +export interface InterruptedException extends YieldableError { + readonly _tag: "InterruptedException"; + readonly [InterruptedExceptionTypeId]: InterruptedExceptionTypeId; +} +/** + * An error representing an invalid argument passed to a method. + * + * **Details** + * + * This interface is used for signaling that a function or method received an + * argument that does not meet its preconditions. + * + * @since 2.0.0 + * @category Models + */ +export interface IllegalArgumentException extends YieldableError { + readonly _tag: "IllegalArgumentException"; + readonly [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId; +} +/** + * An error that occurs when an expected element is missing. + * + * **Details** + * + * This interface indicates scenarios like looking up an item in a collection + * or searching for data that should be present but isn't. It helps your code + * signal a more specific issue rather than a general error. + * + * @since 2.0.0 + * @category Models + */ +export interface NoSuchElementException extends YieldableError { + readonly _tag: "NoSuchElementException"; + readonly [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId; +} +/** + * An error indicating invalid capacity for a `PubSub`. + * + * @since 2.0.0 + * @category Models + */ +export interface InvalidPubSubCapacityException extends YieldableError { + readonly _tag: "InvalidPubSubCapacityException"; + readonly [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId; +} +/** + * An error that occurs when resource capacity is exceeded. + * + * @since 3.5.0 + * @category Models + */ +export interface ExceededCapacityException extends YieldableError { + readonly _tag: "ExceededCapacityException"; + readonly [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId; +} +/** + * An error representing a computation that timed out. + * + * @since 2.0.0 + * @category Models + */ +export interface TimeoutException extends YieldableError { + readonly _tag: "TimeoutException"; + readonly [TimeoutExceptionTypeId]: TimeoutExceptionTypeId; +} +/** + * A checked exception for handling unknown or unexpected errors. + * + * **Details** + * + * This interface captures errors that don't fall under known categories. It is + * especially helpful for wrapping low-level or third-party library errors that + * might provide little or no context, such as from a rejected promise. + * + * @since 2.0.0 + * @category Models + */ +export interface UnknownException extends YieldableError { + readonly _tag: "UnknownException"; + readonly [UnknownExceptionTypeId]: UnknownExceptionTypeId; + readonly error: unknown; +} +/** + * Represents a lack of errors within a `Cause`. + * + * @see {@link empty} Construct a new `Empty` cause + * @see {@link isEmptyType} Check if a `Cause` is an `Empty` type + * + * @since 2.0.0 + * @category Models + */ +export interface Empty extends Cause.Variance, Equal.Equal, Pipeable, Inspectable { + readonly _tag: "Empty"; +} +/** + * Represents an expected error within a `Cause`. + * + * **Details** + * + * This interface models a `Cause` that carries an expected or known error of + * type `E`. For example, if you validate user input and find it invalid, you + * might store that error within a `Fail`. + * + * @see {@link fail} Construct a `Fail` cause + * @see {@link isFailType} Check if a `Cause` is a `Fail` + * + * @since 2.0.0 + * @category Models + */ +export interface Fail extends Cause.Variance, Equal.Equal, Pipeable, Inspectable { + readonly _tag: "Fail"; + readonly error: E; +} +/** + * Represents an unexpected defect within a `Cause`. + * + * **Details** + * + * This interface models a `Cause` for errors that are typically unrecoverable or + * unanticipated—like runtime exceptions or bugs. When code "dies," it indicates a + * severe failure that wasn't accounted for. + * + * @see {@link die} Construct a `Die` cause + * @see {@link isDieType} Check if a `Cause` is a `Die` + * + * @since 2.0.0 + * @category Models + */ +export interface Die extends Cause.Variance, Equal.Equal, Pipeable, Inspectable { + readonly _tag: "Die"; + readonly defect: unknown; +} +/** + * Represents fiber interruption within a `Cause`. + * + * **Details** + * + * This interface models a scenario where an effect was halted by an external + * signal, carrying a `FiberId` that identifies which fiber was interrupted. + * Interruption is a normal part of concurrency, used for cancellation or + * resource cleanup. + * + * @see {@link interrupt} Construct an `Interrupt` cause + * @see {@link isInterruptType} Check if a `Cause` is an `Interrupt` + * + * @since 2.0.0 + * @category Models + */ +export interface Interrupt extends Cause.Variance, Equal.Equal, Pipeable, Inspectable { + readonly _tag: "Interrupt"; + readonly fiberId: FiberId.FiberId; +} +/** + * Represents parallel composition of two `Cause`s. + * + * **Details** + * + * This interface captures failures that happen simultaneously. In scenarios + * with concurrency, more than one operation can fail in parallel. Instead of + * losing information, this structure stores both errors together. + * + * @see {@link parallel} Combine two `Cause`s in parallel + * @see {@link isParallelType} Check if a `Cause` is a `Parallel` + * + * @since 2.0.0 + * @category Models + */ +export interface Parallel extends Cause.Variance, Equal.Equal, Pipeable, Inspectable { + readonly _tag: "Parallel"; + readonly left: Cause; + readonly right: Cause; +} +/** + * Represents sequential composition of two `Cause`s. + * + * **Details** + * + * This interface models the scenario where one error follows another in + * sequence, such as when a main effect fails and then a finalizer also fails. + * It ensures both errors are retained in the final `Cause`. + * + * @see {@link sequential} Combine two `Cause`s sequentially + * @see {@link isSequentialType} Check if a `Cause` is a `Sequential` + * + * @since 2.0.0 + * @category Models + */ +export interface Sequential extends Cause.Variance, Equal.Equal, Pipeable, Inspectable { + readonly _tag: "Sequential"; + readonly left: Cause; + readonly right: Cause; +} +/** + * Creates an `Empty` cause. + * + * **Details** + * + * This function returns a cause that signifies "no error." It's commonly used + * to represent an absence of failure conditions. + * + * @see {@link isEmpty} Check if a `Cause` is empty + * + * @since 2.0.0 + * @category Constructors + */ +export declare const empty: Cause; +/** + * Creates a `Fail` cause from an expected error. + * + * **Details** + * + * This function constructs a `Cause` carrying an error of type `E`. It's used + * when you want to represent a known or anticipated failure in your effectful + * computations. + * + * @see {@link isFailure} Check if a `Cause` contains a failure + * + * @since 2.0.0 + * @category Constructors + */ +export declare const fail: (error: E) => Cause; +/** + * Creates a `Die` cause from an unexpected error. + * + * **Details** + * + * This function wraps an unhandled or unknown defect (like a runtime crash) + * into a `Cause`. It's useful for capturing unforeseen issues in a structured + * way. + * + * @see {@link isDie} Check if a `Cause` contains a defect + * + * @since 2.0.0 + * @category Constructors + */ +export declare const die: (defect: unknown) => Cause; +/** + * Creates an `Interrupt` cause from a `FiberId`. + * + * **Details** + * + * This function represents a fiber that has been interrupted. It stores the + * identifier of the interrupted fiber, enabling precise tracking of concurrent + * cancellations. + * + * @see {@link isInterrupted} Check if a `Cause` contains an interruption + * + * @since 2.0.0 + * @category Constructors + */ +export declare const interrupt: (fiberId: FiberId.FiberId) => Cause; +/** + * Combines two `Cause`s in parallel. + * + * **Details** + * + * This function merges two errors that occurred simultaneously. Instead of + * discarding one error, both are retained, allowing for richer error reporting + * and debugging. + * + * @see {@link isParallelType} Check if a `Cause` is a `Parallel` + * + * @since 2.0.0 + * @category Constructors + */ +export declare const parallel: (left: Cause, right: Cause) => Cause; +/** + * Combines two `Cause`s sequentially. + * + * **Details** + * + * This function merges two errors that occurred in sequence, such as a main + * error followed by a finalization error. It preserves both errors for complete + * failure information. + * + * @see {@link isSequentialType} Check if a `Cause` is a `Sequential` + * + * @since 2.0.0 + * @category Constructors + */ +export declare const sequential: (left: Cause, right: Cause) => Cause; +/** + * Checks if a value is a `Cause`. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isCause: (u: unknown) => u is Cause; +/** + * Checks if a `Cause` is an `Empty` type. + * + * @see {@link empty} Create a new `Empty` cause + * + * @since 2.0.0 + * @category Guards + */ +export declare const isEmptyType: (self: Cause) => self is Empty; +/** + * Checks if a `Cause` is a `Fail` type. + * + * @see {@link fail} Create a new `Fail` cause + * + * @since 2.0.0 + * @category Guards + */ +export declare const isFailType: (self: Cause) => self is Fail; +/** + * Checks if a `Cause` is a `Die` type. + * + * @see {@link die} Create a new `Die` cause + * + * @since 2.0.0 + * @category Guards + */ +export declare const isDieType: (self: Cause) => self is Die; +/** + * Checks if a `Cause` is an `Interrupt` type. + * + * @see {@link interrupt} Create an `Interrupt` cause + * + * @since 2.0.0 + * @category Guards + */ +export declare const isInterruptType: (self: Cause) => self is Interrupt; +/** + * Checks if a `Cause` is a `Sequential` type. + * + * @see {@link sequential} Combine two `Cause`s sequentially + * + * @since 2.0.0 + * @category Guards + */ +export declare const isSequentialType: (self: Cause) => self is Sequential; +/** + * Checks if a `Cause` is a `Parallel` type. + * + * @see {@link parallel} Combine two `Cause`s in parallel + * + * @since 2.0.0 + * @category Guards + */ +export declare const isParallelType: (self: Cause) => self is Parallel; +/** + * Calculates the size of a `Cause`. + * + * **Details** + * + * This function returns the total number of `Cause` nodes in the semiring + * structure, reflecting how many individual error elements are recorded. + * + * @since 2.0.0 + * @category Getters + */ +export declare const size: (self: Cause) => number; +/** + * Checks if a `Cause` is entirely empty. + * + * **Details** + * + * This function returns `true` if the `Cause` contains no errors, defects, or + * interruptions. It's helpful for verifying if a computation truly had no + * failures. + * + * @since 2.0.0 + * @category Getters + */ +export declare const isEmpty: (self: Cause) => boolean; +/** + * Checks if a `Cause` contains a failure. + * + * **Details** + * + * This function returns `true` if the `Cause` includes any `Fail` error. It's + * commonly used to confirm whether a workflow encountered an anticipated error + * versus just defects or interruptions. + * + * @since 2.0.0 + * @category Getters + */ +export declare const isFailure: (self: Cause) => boolean; +/** + * Checks if a `Cause` contains a defect. + * + * **Details** + * + * This function returns `true` if the `Cause` includes any unexpected or + * unhandled errors (`Die`). It's useful for differentiating known failures from + * unexpected ones. + * + * @since 2.0.0 + * @category Getters + */ +export declare const isDie: (self: Cause) => boolean; +/** + * Checks if a `Cause` contains an interruption. + * + * **Details** + * + * This function returns `true` if the `Cause` includes any fiber interruptions. + * + * @since 2.0.0 + * @category Getters + */ +export declare const isInterrupted: (self: Cause) => boolean; +/** + * Checks if a `Cause` contains only interruptions. + * + * **Details** + * + * This function returns `true` if the `Cause` has been interrupted but does not + * contain any other failures, such as `Fail` or `Die`. It's helpful for + * verifying purely "cancellation" scenarios. + * + * @since 2.0.0 + * @category Getters + */ +export declare const isInterruptedOnly: (self: Cause) => boolean; +/** + * Extracts all recoverable errors of type `E` from a `Cause`. + * + * **Details** + * + * This function returns a chunk of errors, providing a list of all `Fail` + * values found in the cause. It's useful for collecting all known failures for + * logging or combined error handling. + * + * @since 2.0.0 + * @category Getters + */ +export declare const failures: (self: Cause) => Chunk.Chunk; +/** + * Extracts all unrecoverable defects from a `Cause`. + * + * **Details** + * + * This function returns a chunk of values representing unexpected errors + * (`Die`). It's handy for capturing or logging unanticipated failures that + * might need special handling, such as bug reports. + * + * @since 2.0.0 + * @category Getters + */ +export declare const defects: (self: Cause) => Chunk.Chunk; +/** + * Collects all `FiberId`s responsible for interrupting a fiber. + * + * **Details** + * + * This function returns a set of IDs indicating which fibers caused + * interruptions within this `Cause`. It's useful for debugging concurrency + * issues or tracing cancellations. + * + * @since 2.0.0 + * @category Getters + */ +export declare const interruptors: (self: Cause) => HashSet.HashSet; +/** + * Retrieves the first `Fail` error in a `Cause`, if present. + * + * **Details** + * + * This function returns an `Option` containing the first recoverable error + * (`E`) from the cause. It's often used to quickly check if there's a primary + * error to handle or display. + * + * @since 2.0.0 + * @category Getters + */ +export declare const failureOption: (self: Cause) => Option.Option; +/** + * Splits a `Cause` into either its first `Fail` error or the rest of the cause + * (which might only contain `Die` or `Interrupt`). + * + * **Details** + * + * This function either returns the checked error (`E`) or the remaining + * `Cause` with defects/interruptions. It helps you decide if there's a + * recoverable path or if only unhandled issues remain. + * + * @since 2.0.0 + * @category Getters + */ +export declare const failureOrCause: (self: Cause) => Either.Either, E>; +/** + * Strips out failures with an error of `None` from a `Cause>`. + * + * **Details** + * + * This function turns a `Cause>` into an `Option>`. If the + * cause only contains failures of `None`, it becomes `None`; otherwise, it + * returns a `Cause` of the remaining errors. It's helpful when working with + * optional errors and filtering out certain error paths. + * + * @since 2.0.0 + * @category Getters + */ +export declare const flipCauseOption: (self: Cause>) => Option.Option>; +/** + * Retrieves the first `Die` defect in a `Cause`, if present. + * + * **Details** + * + * This function returns an `Option` containing the first unexpected failure + * (`Die`) discovered. It's helpful for diagnosing the primary defect in a chain + * of errors. + * + * @since 2.0.0 + * @category Getters + */ +export declare const dieOption: (self: Cause) => Option.Option; +/** + * Retrieves the first `Interrupt` in a `Cause`, if present. + * + * **Details** + * + * This function returns an `Option` with the first fiber interruption + * discovered. This is particularly useful for concurrency analysis or debugging + * cancellations. + * + * @since 2.0.0 + * @category Getters + */ +export declare const interruptOption: (self: Cause) => Option.Option; +/** + * Removes all `Fail` and `Interrupt` nodes, keeping only defects (`Die`) in a + * `Cause`. + * + * **Details** + * + * This function strips a cause of recoverable errors and interruptions, leaving + * only unexpected failures. If no defects remain, it returns `None`. It's + * valuable for focusing only on unanticipated problems when both known errors + * and defects could occur. + * + * @since 2.0.0 + * @category Getters + */ +export declare const keepDefects: (self: Cause) => Option.Option>; +/** + * Linearizes a `Cause` into a set of parallel causes, each containing a + * sequential chain of failures. + * + * **Details** + * + * This function reorganizes the cause structure so that you can analyze each + * parallel branch separately, even if they have multiple sequential errors. + * + * @since 2.0.0 + * @category Getters + */ +export declare const linearize: (self: Cause) => HashSet.HashSet>; +/** + * Removes `Fail` and `Interrupt` nodes from a `Cause`, keeping only defects + * (`Die`). + * + * **Details** + * + * This function is similar to `keepDefects` but returns a `Cause` + * directly, which can still store `Die` or finalizer-related defects. It's + * helpful for analyzing only the irrecoverable portion of the error. + * + * @since 2.0.0 + * @category Getters + */ +export declare const stripFailures: (self: Cause) => Cause; +/** + * Removes matching defects from a `Cause` using a partial function, returning + * the remainder. + * + * **Details** + * + * This function applies a user-defined extraction function to each defect + * (`Die`). If the function matches the defect, that defect is removed. If all + * defects match, the result is `None`. Otherwise, you get a `Cause` with the + * unmatched defects. + * + * @since 2.0.0 + * @category Getters + */ +export declare const stripSomeDefects: { + /** + * Removes matching defects from a `Cause` using a partial function, returning + * the remainder. + * + * **Details** + * + * This function applies a user-defined extraction function to each defect + * (`Die`). If the function matches the defect, that defect is removed. If all + * defects match, the result is `None`. Otherwise, you get a `Cause` with the + * unmatched defects. + * + * @since 2.0.0 + * @category Getters + */ + (pf: (defect: unknown) => Option.Option): (self: Cause) => Option.Option>; + /** + * Removes matching defects from a `Cause` using a partial function, returning + * the remainder. + * + * **Details** + * + * This function applies a user-defined extraction function to each defect + * (`Die`). If the function matches the defect, that defect is removed. If all + * defects match, the result is `None`. Otherwise, you get a `Cause` with the + * unmatched defects. + * + * @since 2.0.0 + * @category Getters + */ + (self: Cause, pf: (defect: unknown) => Option.Option): Option.Option>; +}; +/** + * Replaces any errors in a `Cause` with a provided constant error. + * + * **Details** + * + * This function transforms all `Fail` errors into the specified error value, + * preserving the structure of the `Cause`. It's useful when you no longer need + * the original error details but still want to keep the cause shape. + * + * @see {@link map} Apply a custom transformation to `Fail` errors + * + * @since 2.0.0 + * @category Mapping + */ +export declare const as: { + /** + * Replaces any errors in a `Cause` with a provided constant error. + * + * **Details** + * + * This function transforms all `Fail` errors into the specified error value, + * preserving the structure of the `Cause`. It's useful when you no longer need + * the original error details but still want to keep the cause shape. + * + * @see {@link map} Apply a custom transformation to `Fail` errors + * + * @since 2.0.0 + * @category Mapping + */ + (error: E2): (self: Cause) => Cause; + /** + * Replaces any errors in a `Cause` with a provided constant error. + * + * **Details** + * + * This function transforms all `Fail` errors into the specified error value, + * preserving the structure of the `Cause`. It's useful when you no longer need + * the original error details but still want to keep the cause shape. + * + * @see {@link map} Apply a custom transformation to `Fail` errors + * + * @since 2.0.0 + * @category Mapping + */ + (self: Cause, error: E2): Cause; +}; +/** + * Transforms the errors in a `Cause` using a user-provided function. + * + * **Details** + * + * This function applies `f` to each `Fail` error while leaving defects (`Die`) + * and interruptions untouched. It's useful for changing or simplifying error + * types in your effectful workflows. + * + * @see {@link as} Replace errors with a single constant + * + * @since 2.0.0 + * @category Mapping + */ +export declare const map: { + /** + * Transforms the errors in a `Cause` using a user-provided function. + * + * **Details** + * + * This function applies `f` to each `Fail` error while leaving defects (`Die`) + * and interruptions untouched. It's useful for changing or simplifying error + * types in your effectful workflows. + * + * @see {@link as} Replace errors with a single constant + * + * @since 2.0.0 + * @category Mapping + */ + (f: (e: E) => E2): (self: Cause) => Cause; + /** + * Transforms the errors in a `Cause` using a user-provided function. + * + * **Details** + * + * This function applies `f` to each `Fail` error while leaving defects (`Die`) + * and interruptions untouched. It's useful for changing or simplifying error + * types in your effectful workflows. + * + * @see {@link as} Replace errors with a single constant + * + * @since 2.0.0 + * @category Mapping + */ + (self: Cause, f: (e: E) => E2): Cause; +}; +/** + * Transforms errors in a `Cause` into new causes. + * + * **Details** + * + * This function applies a function `f` to each `Fail` error, converting it into + * a new `Cause`. This is especially powerful for merging or restructuring error + * types while preserving or combining cause information. + * + * @see {@link map} Apply a simpler transformation to errors + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const flatMap: { + /** + * Transforms errors in a `Cause` into new causes. + * + * **Details** + * + * This function applies a function `f` to each `Fail` error, converting it into + * a new `Cause`. This is especially powerful for merging or restructuring error + * types while preserving or combining cause information. + * + * @see {@link map} Apply a simpler transformation to errors + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (e: E) => Cause): (self: Cause) => Cause; + /** + * Transforms errors in a `Cause` into new causes. + * + * **Details** + * + * This function applies a function `f` to each `Fail` error, converting it into + * a new `Cause`. This is especially powerful for merging or restructuring error + * types while preserving or combining cause information. + * + * @see {@link map} Apply a simpler transformation to errors + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Cause, f: (e: E) => Cause): Cause; +}; +/** + * Sequences two `Cause`s. The second `Cause` can be dependent on the result of + * the first `Cause`. + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const andThen: { + /** + * Sequences two `Cause`s. The second `Cause` can be dependent on the result of + * the first `Cause`. + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (e: E) => Cause): (self: Cause) => Cause; + /** + * Sequences two `Cause`s. The second `Cause` can be dependent on the result of + * the first `Cause`. + * + * @since 2.0.0 + * @category Sequencing + */ + (f: Cause): (self: Cause) => Cause; + /** + * Sequences two `Cause`s. The second `Cause` can be dependent on the result of + * the first `Cause`. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Cause, f: (e: E) => Cause): Cause; + /** + * Sequences two `Cause`s. The second `Cause` can be dependent on the result of + * the first `Cause`. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Cause, f: Cause): Cause; +}; +/** + * Flattens a nested `Cause` structure. + * + * **Details** + * + * This function takes a `Cause>` and merges the layers into a single + * `Cause`. It's useful for eliminating additional nesting created by + * repeated transformations or compositions. + * + * @see {@link flatMap} Compose nested causes + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const flatten: (self: Cause>) => Cause; +/** + * Checks if the current `Cause` contains or is equal to another `Cause`. + * + * **Details** + * + * This function returns `true` if `that` cause is part of or the same as + * the current `Cause`. It's useful when you need to check for specific + * error patterns or deduplicate repeated failures. + * + * @since 2.0.0 + * @category Elements + */ +export declare const contains: { + /** + * Checks if the current `Cause` contains or is equal to another `Cause`. + * + * **Details** + * + * This function returns `true` if `that` cause is part of or the same as + * the current `Cause`. It's useful when you need to check for specific + * error patterns or deduplicate repeated failures. + * + * @since 2.0.0 + * @category Elements + */ + (that: Cause): (self: Cause) => boolean; + /** + * Checks if the current `Cause` contains or is equal to another `Cause`. + * + * **Details** + * + * This function returns `true` if `that` cause is part of or the same as + * the current `Cause`. It's useful when you need to check for specific + * error patterns or deduplicate repeated failures. + * + * @since 2.0.0 + * @category Elements + */ + (self: Cause, that: Cause): boolean; +}; +/** + * Extracts the most "important" defect from a `Cause`. + * + * **Details** + * + * This function reduces a `Cause` to a single, prioritized defect. It evaluates + * the `Cause` in the following order of priority: + * + * 1. If the `Cause` contains a failure (e.g., from `Effect.fail`), it returns + * the raw error value. + * 2. If there is no failure, it looks for the first defect (e.g., from + * `Effect.die`). + * 3. If neither of the above is present, and the `Cause` stems from an + * interruption, it creates and returns an `InterruptedException`. + * + * This function ensures you can always extract a meaningful representation of + * the primary issue from a potentially complex `Cause` structure. + * + * **When to Use** + * + * Use this function when you need to extract the most relevant error or defect + * from a `Cause`, especially in scenarios where multiple errors or defects may + * be present. It's particularly useful for simplifying error reporting or + * logging. + * + * @see {@link squashWith} Allows transforming failures into defects when squashing. + * + * @since 2.0.0 + * @category Destructors + */ +export declare const squash: (self: Cause) => unknown; +/** + * Extracts the most "important" defect from a `Cause`, transforming failures + * into defects using a provided function. + * + * **Details** + * + * This function reduces a `Cause` to a single, prioritized defect, while + * allowing you to transform recoverable failures into defects through a custom + * function. It processes the `Cause` in the following order: + * + * 1. If the `Cause` contains a failure (e.g., from `Effect.fail`), it applies + * the provided function `f` to the error to transform it into a defect. + * 2. If there is no failure, it looks for the first defect (e.g., from + * `Effect.die`) and returns it. + * 3. If neither is present and the `Cause` stems from an interruption, it + * returns an `InterruptedException`. + * + * This function is particularly useful when you need custom handling or + * transformation of errors while processing a `Cause`. + * + * @see {@link squash} Extracts the most "important" defect without transforming failures. + * + * @since 2.0.0 + * @category Destructors + */ +export declare const squashWith: { + /** + * Extracts the most "important" defect from a `Cause`, transforming failures + * into defects using a provided function. + * + * **Details** + * + * This function reduces a `Cause` to a single, prioritized defect, while + * allowing you to transform recoverable failures into defects through a custom + * function. It processes the `Cause` in the following order: + * + * 1. If the `Cause` contains a failure (e.g., from `Effect.fail`), it applies + * the provided function `f` to the error to transform it into a defect. + * 2. If there is no failure, it looks for the first defect (e.g., from + * `Effect.die`) and returns it. + * 3. If neither is present and the `Cause` stems from an interruption, it + * returns an `InterruptedException`. + * + * This function is particularly useful when you need custom handling or + * transformation of errors while processing a `Cause`. + * + * @see {@link squash} Extracts the most "important" defect without transforming failures. + * + * @since 2.0.0 + * @category Destructors + */ + (f: (error: E) => unknown): (self: Cause) => unknown; + /** + * Extracts the most "important" defect from a `Cause`, transforming failures + * into defects using a provided function. + * + * **Details** + * + * This function reduces a `Cause` to a single, prioritized defect, while + * allowing you to transform recoverable failures into defects through a custom + * function. It processes the `Cause` in the following order: + * + * 1. If the `Cause` contains a failure (e.g., from `Effect.fail`), it applies + * the provided function `f` to the error to transform it into a defect. + * 2. If there is no failure, it looks for the first defect (e.g., from + * `Effect.die`) and returns it. + * 3. If neither is present and the `Cause` stems from an interruption, it + * returns an `InterruptedException`. + * + * This function is particularly useful when you need custom handling or + * transformation of errors while processing a `Cause`. + * + * @see {@link squash} Extracts the most "important" defect without transforming failures. + * + * @since 2.0.0 + * @category Destructors + */ + (self: Cause, f: (error: E) => unknown): unknown; +}; +/** + * Searches a `Cause` using a partial function to extract information. + * + * **Details** + * + * This function allows you to search through a `Cause` using a custom partial + * function. The partial function is applied to the `Cause`, and if it matches, + * the result is returned wrapped in a `Some`. If no match is found, the result + * is `None`. + * + * This is particularly useful when you are only interested in specific types of + * errors, defects, or interruption causes within a potentially complex `Cause` + * structure. By leveraging a partial function, you can focus on extracting only + * the relevant information you care about. + * + * The partial function should return an `Option` indicating whether it matched + * and the value it extracted. + * + * @since 2.0.0 + * @category Elements + */ +export declare const find: { + /** + * Searches a `Cause` using a partial function to extract information. + * + * **Details** + * + * This function allows you to search through a `Cause` using a custom partial + * function. The partial function is applied to the `Cause`, and if it matches, + * the result is returned wrapped in a `Some`. If no match is found, the result + * is `None`. + * + * This is particularly useful when you are only interested in specific types of + * errors, defects, or interruption causes within a potentially complex `Cause` + * structure. By leveraging a partial function, you can focus on extracting only + * the relevant information you care about. + * + * The partial function should return an `Option` indicating whether it matched + * and the value it extracted. + * + * @since 2.0.0 + * @category Elements + */ + (pf: (cause: Cause) => Option.Option): (self: Cause) => Option.Option; + /** + * Searches a `Cause` using a partial function to extract information. + * + * **Details** + * + * This function allows you to search through a `Cause` using a custom partial + * function. The partial function is applied to the `Cause`, and if it matches, + * the result is returned wrapped in a `Some`. If no match is found, the result + * is `None`. + * + * This is particularly useful when you are only interested in specific types of + * errors, defects, or interruption causes within a potentially complex `Cause` + * structure. By leveraging a partial function, you can focus on extracting only + * the relevant information you care about. + * + * The partial function should return an `Option` indicating whether it matched + * and the value it extracted. + * + * @since 2.0.0 + * @category Elements + */ + (self: Cause, pf: (cause: Cause) => Option.Option): Option.Option; +}; +/** + * Preserves parts of a `Cause` that match a given predicate. + * + * **Details** + * + * This function allows you to retain only the parts of a `Cause` structure that + * match a specified predicate or refinement. Any parts of the `Cause` that do + * not match the provided condition are excluded from the result. + * + * You can use this function in two ways: + * - With a `Predicate`: A function that evaluates whether a `Cause` should be + * retained based on its value. + * - With a `Refinement`: A more specific predicate that can refine the type of + * the `Cause`. + * + * This is useful when you need to extract specific types of errors, defects, or + * interruptions from a `Cause` while discarding unrelated parts. + * + * @since 2.0.0 + * @category Filtering + */ +export declare const filter: { + /** + * Preserves parts of a `Cause` that match a given predicate. + * + * **Details** + * + * This function allows you to retain only the parts of a `Cause` structure that + * match a specified predicate or refinement. Any parts of the `Cause` that do + * not match the provided condition are excluded from the result. + * + * You can use this function in two ways: + * - With a `Predicate`: A function that evaluates whether a `Cause` should be + * retained based on its value. + * - With a `Refinement`: A more specific predicate that can refine the type of + * the `Cause`. + * + * This is useful when you need to extract specific types of errors, defects, or + * interruptions from a `Cause` while discarding unrelated parts. + * + * @since 2.0.0 + * @category Filtering + */ + (refinement: Refinement>, Cause>): (self: Cause) => Cause; + /** + * Preserves parts of a `Cause` that match a given predicate. + * + * **Details** + * + * This function allows you to retain only the parts of a `Cause` structure that + * match a specified predicate or refinement. Any parts of the `Cause` that do + * not match the provided condition are excluded from the result. + * + * You can use this function in two ways: + * - With a `Predicate`: A function that evaluates whether a `Cause` should be + * retained based on its value. + * - With a `Refinement`: A more specific predicate that can refine the type of + * the `Cause`. + * + * This is useful when you need to extract specific types of errors, defects, or + * interruptions from a `Cause` while discarding unrelated parts. + * + * @since 2.0.0 + * @category Filtering + */ + (predicate: Predicate>>): (self: Cause) => Cause; + /** + * Preserves parts of a `Cause` that match a given predicate. + * + * **Details** + * + * This function allows you to retain only the parts of a `Cause` structure that + * match a specified predicate or refinement. Any parts of the `Cause` that do + * not match the provided condition are excluded from the result. + * + * You can use this function in two ways: + * - With a `Predicate`: A function that evaluates whether a `Cause` should be + * retained based on its value. + * - With a `Refinement`: A more specific predicate that can refine the type of + * the `Cause`. + * + * This is useful when you need to extract specific types of errors, defects, or + * interruptions from a `Cause` while discarding unrelated parts. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Cause, refinement: Refinement, Cause>): Cause; + /** + * Preserves parts of a `Cause` that match a given predicate. + * + * **Details** + * + * This function allows you to retain only the parts of a `Cause` structure that + * match a specified predicate or refinement. Any parts of the `Cause` that do + * not match the provided condition are excluded from the result. + * + * You can use this function in two ways: + * - With a `Predicate`: A function that evaluates whether a `Cause` should be + * retained based on its value. + * - With a `Refinement`: A more specific predicate that can refine the type of + * the `Cause`. + * + * This is useful when you need to extract specific types of errors, defects, or + * interruptions from a `Cause` while discarding unrelated parts. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Cause, predicate: Predicate>): Cause; +}; +/** + * Transforms a `Cause` into a single value using custom handlers for each + * possible case. + * + * **Details** + * + * This function processes a `Cause` by applying a set of custom handlers to + * each possible type of cause: `Empty`, `Fail`, `Die`, `Interrupt`, + * `Sequential`, and `Parallel`. The result of this function is a single value + * of type `Z`. This function allows you to define exactly how to handle each + * part of a `Cause`, whether it's a failure, defect, interruption, or a + * combination of these. + * + * The options parameter provides handlers for: + * - `onEmpty`: Handles the case where the cause is `Empty`, meaning no errors + * occurred. + * - `onFail`: Processes a failure with an error of type `E`. + * - `onDie`: Processes a defect (unexpected error). + * - `onInterrupt`: Handles a fiber interruption, providing the `FiberId` of the + * interruption. + * - `onSequential`: Combines two sequential causes into a single value of type + * `Z`. + * - `onParallel`: Combines two parallel causes into a single value of type `Z`. + * + * @since 2.0.0 + * @category Matching + */ +export declare const match: { + /** + * Transforms a `Cause` into a single value using custom handlers for each + * possible case. + * + * **Details** + * + * This function processes a `Cause` by applying a set of custom handlers to + * each possible type of cause: `Empty`, `Fail`, `Die`, `Interrupt`, + * `Sequential`, and `Parallel`. The result of this function is a single value + * of type `Z`. This function allows you to define exactly how to handle each + * part of a `Cause`, whether it's a failure, defect, interruption, or a + * combination of these. + * + * The options parameter provides handlers for: + * - `onEmpty`: Handles the case where the cause is `Empty`, meaning no errors + * occurred. + * - `onFail`: Processes a failure with an error of type `E`. + * - `onDie`: Processes a defect (unexpected error). + * - `onInterrupt`: Handles a fiber interruption, providing the `FiberId` of the + * interruption. + * - `onSequential`: Combines two sequential causes into a single value of type + * `Z`. + * - `onParallel`: Combines two parallel causes into a single value of type `Z`. + * + * @since 2.0.0 + * @category Matching + */ + (options: { + readonly onEmpty: Z; + readonly onFail: (error: E) => Z; + readonly onDie: (defect: unknown) => Z; + readonly onInterrupt: (fiberId: FiberId.FiberId) => Z; + readonly onSequential: (left: Z, right: Z) => Z; + readonly onParallel: (left: Z, right: Z) => Z; + }): (self: Cause) => Z; + /** + * Transforms a `Cause` into a single value using custom handlers for each + * possible case. + * + * **Details** + * + * This function processes a `Cause` by applying a set of custom handlers to + * each possible type of cause: `Empty`, `Fail`, `Die`, `Interrupt`, + * `Sequential`, and `Parallel`. The result of this function is a single value + * of type `Z`. This function allows you to define exactly how to handle each + * part of a `Cause`, whether it's a failure, defect, interruption, or a + * combination of these. + * + * The options parameter provides handlers for: + * - `onEmpty`: Handles the case where the cause is `Empty`, meaning no errors + * occurred. + * - `onFail`: Processes a failure with an error of type `E`. + * - `onDie`: Processes a defect (unexpected error). + * - `onInterrupt`: Handles a fiber interruption, providing the `FiberId` of the + * interruption. + * - `onSequential`: Combines two sequential causes into a single value of type + * `Z`. + * - `onParallel`: Combines two parallel causes into a single value of type `Z`. + * + * @since 2.0.0 + * @category Matching + */ + (self: Cause, options: { + readonly onEmpty: Z; + readonly onFail: (error: E) => Z; + readonly onDie: (defect: unknown) => Z; + readonly onInterrupt: (fiberId: FiberId.FiberId) => Z; + readonly onSequential: (left: Z, right: Z) => Z; + readonly onParallel: (left: Z, right: Z) => Z; + }): Z; +}; +/** + * Combines all parts of a `Cause` into a single value by starting with an + * initial value. + * + * **Details** + * + * This function processes a `Cause` by starting with an initial value (`zero`) + * and applying a custom function (`pf`) to combine all elements of the `Cause` + * into a single result of type `Z`. The custom function determines how each + * part of the `Cause` contributes to the final result. The function can return + * an `Option` to either continue combining values or skip specific parts of the + * `Cause`. + * + * This function is useful for tasks such as: + * - Aggregating error messages from a `Cause` into a single string. + * - Summarizing the structure of a `Cause` into a simplified result. + * - Filtering or processing only specific parts of a `Cause`. + * + * The reduction proceeds in a top-down manner, visiting all nodes in the + * `Cause` structure. This gives you complete control over how each part of the + * `Cause` contributes to the final result. + * + * @since 2.0.0 + * @category Reducing + */ +export declare const reduce: { + /** + * Combines all parts of a `Cause` into a single value by starting with an + * initial value. + * + * **Details** + * + * This function processes a `Cause` by starting with an initial value (`zero`) + * and applying a custom function (`pf`) to combine all elements of the `Cause` + * into a single result of type `Z`. The custom function determines how each + * part of the `Cause` contributes to the final result. The function can return + * an `Option` to either continue combining values or skip specific parts of the + * `Cause`. + * + * This function is useful for tasks such as: + * - Aggregating error messages from a `Cause` into a single string. + * - Summarizing the structure of a `Cause` into a simplified result. + * - Filtering or processing only specific parts of a `Cause`. + * + * The reduction proceeds in a top-down manner, visiting all nodes in the + * `Cause` structure. This gives you complete control over how each part of the + * `Cause` contributes to the final result. + * + * @since 2.0.0 + * @category Reducing + */ + (zero: Z, pf: (accumulator: Z, cause: Cause) => Option.Option): (self: Cause) => Z; + /** + * Combines all parts of a `Cause` into a single value by starting with an + * initial value. + * + * **Details** + * + * This function processes a `Cause` by starting with an initial value (`zero`) + * and applying a custom function (`pf`) to combine all elements of the `Cause` + * into a single result of type `Z`. The custom function determines how each + * part of the `Cause` contributes to the final result. The function can return + * an `Option` to either continue combining values or skip specific parts of the + * `Cause`. + * + * This function is useful for tasks such as: + * - Aggregating error messages from a `Cause` into a single string. + * - Summarizing the structure of a `Cause` into a simplified result. + * - Filtering or processing only specific parts of a `Cause`. + * + * The reduction proceeds in a top-down manner, visiting all nodes in the + * `Cause` structure. This gives you complete control over how each part of the + * `Cause` contributes to the final result. + * + * @since 2.0.0 + * @category Reducing + */ + (self: Cause, zero: Z, pf: (accumulator: Z, cause: Cause) => Option.Option): Z; +}; +/** + * Combines all parts of a `Cause` into a single value using a custom reducer + * and a context. + * + * **Details** + * + * This function allows you to reduce a `Cause` into a single value of type `Z` + * using a custom `CauseReducer`. A `CauseReducer` provides methods to handle + * specific parts of the `Cause`, such as failures, defects, or interruptions. + * Additionally, this function provides access to a `context` value, which can + * be used to carry information or maintain state during the reduction process. + * + * This is particularly useful when the reduction process needs additional + * context or configuration, such as: + * - Aggregating error details with dynamic formatting. + * - Collecting logs or statistics about the `Cause`. + * - Performing stateful transformations based on the `context`. + * + * @see {@link reduce} To reduce a `Cause` without additional context. + * + * @since 2.0.0 + * @category Reducing + */ +export declare const reduceWithContext: { + /** + * Combines all parts of a `Cause` into a single value using a custom reducer + * and a context. + * + * **Details** + * + * This function allows you to reduce a `Cause` into a single value of type `Z` + * using a custom `CauseReducer`. A `CauseReducer` provides methods to handle + * specific parts of the `Cause`, such as failures, defects, or interruptions. + * Additionally, this function provides access to a `context` value, which can + * be used to carry information or maintain state during the reduction process. + * + * This is particularly useful when the reduction process needs additional + * context or configuration, such as: + * - Aggregating error details with dynamic formatting. + * - Collecting logs or statistics about the `Cause`. + * - Performing stateful transformations based on the `context`. + * + * @see {@link reduce} To reduce a `Cause` without additional context. + * + * @since 2.0.0 + * @category Reducing + */ + (context: C, reducer: CauseReducer): (self: Cause) => Z; + /** + * Combines all parts of a `Cause` into a single value using a custom reducer + * and a context. + * + * **Details** + * + * This function allows you to reduce a `Cause` into a single value of type `Z` + * using a custom `CauseReducer`. A `CauseReducer` provides methods to handle + * specific parts of the `Cause`, such as failures, defects, or interruptions. + * Additionally, this function provides access to a `context` value, which can + * be used to carry information or maintain state during the reduction process. + * + * This is particularly useful when the reduction process needs additional + * context or configuration, such as: + * - Aggregating error details with dynamic formatting. + * - Collecting logs or statistics about the `Cause`. + * - Performing stateful transformations based on the `context`. + * + * @see {@link reduce} To reduce a `Cause` without additional context. + * + * @since 2.0.0 + * @category Reducing + */ + (self: Cause, context: C, reducer: CauseReducer): Z; +}; +/** + * Creates an error that indicates a `Fiber` was interrupted. + * + * **Details** + * + * This function constructs an `InterruptedException` recognized by the Effect + * runtime. It is usually thrown or returned when a fiber's execution is + * interrupted by external events or by another fiber. This is particularly + * helpful in concurrent programs where fibers may halt each other before + * completion. + * + * @since 2.0.0 + * @category Errors + */ +export declare const InterruptedException: new (message?: string | undefined) => InterruptedException; +/** + * Checks if a given unknown value is an `InterruptedException`. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isInterruptedException: (u: unknown) => u is InterruptedException; +/** + * Creates an error indicating an invalid method argument. + * + * **Details** + * + * This function constructs an `IllegalArgumentException`. It is typically + * thrown or returned when an operation receives improper inputs, such as + * out-of-range values or invalid object states. + * + * @since 2.0.0 + * @category Errors + */ +export declare const IllegalArgumentException: new (message?: string | undefined) => IllegalArgumentException; +/** + * Checks if a given unknown value is an `IllegalArgumentException`. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isIllegalArgumentException: (u: unknown) => u is IllegalArgumentException; +/** + * Creates an error indicating a missing element. + * + * **Details** + * + * This function constructs a `NoSuchElementException`. It helps you clearly + * communicate that a required element is unavailable. + * + * @since 2.0.0 + * @category Errors + */ +export declare const NoSuchElementException: new (message?: string | undefined) => NoSuchElementException; +/** + * Checks if a given unknown value is a `NoSuchElementException`. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isNoSuchElementException: (u: unknown) => u is NoSuchElementException; +/** + * Creates an error for general runtime errors. + * + * **Details** + * + * This function constructs a `RuntimeException`, for errors that occur at + * runtime but are not specifically typed or categorized as interruptions, + * missing elements, or invalid arguments. It helps unify a wide range of + * unexpected conditions under a single, recognizable error type. + * + * @since 2.0.0 + * @category Errors + */ +export declare const RuntimeException: new (message?: string | undefined) => RuntimeException; +/** + * Checks if a given unknown value is a `RuntimeException`. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isRuntimeException: (u: unknown) => u is RuntimeException; +/** + * Creates an error for operations that exceed their expected time. + * + * **Details** + * + * This function constructs a `TimeoutException`. It is typically used to signal + * that an operation or fiber did not complete within a designated time limit, + * allowing you to handle slow or hanging processes. + * + * @since 2.0.0 + * @category Errors + */ +export declare const TimeoutException: new (message?: string | undefined) => TimeoutException; +/** + * Checks if a given unknown value is a `TimeoutException`. + * + * @since 3.15.0 + * @category Guards + */ +export declare const isTimeoutException: (u: unknown) => u is TimeoutException; +/** + * Creates an instance of `UnknownException`, an error object used to handle + * unknown errors such as those from rejected promises. + * + * **Details** + * + * This function constructs an `UnknownException` with flexible behavior for + * managing the error message and cause. + * + * The required `error` argument is passed as the `cause` to the global `Error` + * constructor, ensuring that the original cause is preserved in the error chain + * for debugging purposes. This ensures that the origin stack trace is + * preserved. + * + * The `error` argument is always stored in the `error` property of the + * `UnknownException` instance for reference, regardless of its type. + * + * Additionally, if you provide a `message` argument, it is used as the error + * message. If no `message` is provided, the error message defaults to `"An + * unknown error occurred"`. + * + * **When to Use** + * + * Use this function when you need to handle unexpected or unknown errors in + * your application, particularly when the source of the error might not provide + * a clear message. This is useful for wrapping generic errors thrown from + * promises or external APIs. + * + * @since 2.0.0 + * @category Errors + */ +export declare const UnknownException: new (error: unknown, message?: string | undefined) => UnknownException; +/** + * Checks if a given unknown value is an `UnknownException`. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isUnknownException: (u: unknown) => u is UnknownException; +/** + * Creates an error indicating resource capacity has been exceeded. + * + * **Details** + * + * This function constructs an `ExceededCapacityException`, signifying that an + * operation or resource usage surpassed established limits. This can be + * essential for concurrency or resource management situations, ensuring your + * application doesn't go beyond acceptable thresholds. + * + * @since 3.5.0 + * @category Errors + */ +export declare const ExceededCapacityException: new (message?: string | undefined) => ExceededCapacityException; +/** + * Checks if a given unknown value is an `ExceededCapacityException`. + * + * @since 3.5.0 + * @category Guards + */ +export declare const isExceededCapacityException: (u: unknown) => u is ExceededCapacityException; +/** + * Converts a `Cause` into a human-readable string. + * + * **Details** + * + * This function pretty-prints the entire `Cause`, including any failures, + * defects, and interruptions. It can be especially helpful for logging, + * debugging, or displaying structured errors to users. + * + * You can optionally pass `options` to configure how the error cause is + * rendered. By default, it includes essential details of all errors in the + * `Cause`. + * + * @see {@link prettyErrors} Get a list of `PrettyError` objects instead of a single string. + * + * @since 2.0.0 + * @category Formatting + */ +export declare const pretty: (cause: Cause, options?: { + readonly renderErrorCause?: boolean | undefined; +}) => string; +/** + * A shape for prettified errors, optionally including a source span. + * + * @since 3.2.0 + * @category Models + */ +export interface PrettyError extends Error { + readonly span: Span | undefined; +} +/** + * Returns a list of prettified errors (`PrettyError`) from a `Cause`. + * + * **Details** + * + * This function inspects the entire `Cause` and produces an array of + * `PrettyError` objects. Each object may include additional metadata, such as a + * `Span`, to provide deeper insights into where and how the error occurred. + * + * @since 3.2.0 + * @category Formatting + */ +export declare const prettyErrors: (cause: Cause) => Array; +/** + * Retrieves the original, unproxied error instance from an error object. + * + * **Details** + * + * This function returns the underlying error object without any + * library-specific wrapping or proxying that might occur during error handling. + * This can be essential if you need direct access to the error's native + * properties, such as stack traces or custom data fields, for detailed + * debugging or integration with external systems. + * + * @since 2.0.0 + * @category Errors + */ +export declare const originalError: (obj: E) => E; +//# sourceMappingURL=Cause.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Cause.d.ts.map b/backend/node_modules/effect/dist/dts/Cause.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..0e9b7045e7d1db5513897fc868ba8de51bbd9ac6 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Cause.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Cause.d.ts","sourceRoot":"","sources":["../../src/Cause.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Channel.d.ts b/backend/node_modules/effect/dist/dts/Channel.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..34cf39ed49e75670a10a8f41af9b105a0e552537 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Channel.d.ts @@ -0,0 +1,1989 @@ +/** + * @since 2.0.0 + */ +import type * as Cause from "./Cause.js"; +import type * as ChildExecutorDecision from "./ChildExecutorDecision.js"; +import type * as Chunk from "./Chunk.js"; +import type * as Context from "./Context.js"; +import type * as Deferred from "./Deferred.js"; +import type * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type * as Exit from "./Exit.js"; +import type { LazyArg } from "./Function.js"; +import type * as Layer from "./Layer.js"; +import type * as MergeDecision from "./MergeDecision.js"; +import type * as MergeStrategy from "./MergeStrategy.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate } from "./Predicate.js"; +import type * as PubSub from "./PubSub.js"; +import type * as Queue from "./Queue.js"; +import type * as Ref from "./Ref.js"; +import type * as Scope from "./Scope.js"; +import type * as SingleProducerAsyncInput from "./SingleProducerAsyncInput.js"; +import type * as Sink from "./Sink.js"; +import type * as Stream from "./Stream.js"; +import type * as Tracer from "./Tracer.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +import type * as UpstreamPullRequest from "./UpstreamPullRequest.js"; +import type * as UpstreamPullStrategy from "./UpstreamPullStrategy.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const ChannelTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ChannelTypeId = typeof ChannelTypeId; +/** + * A `Channel` is a nexus of I/O operations, which supports both reading and + * writing. A channel may read values of type `InElem` and write values of type + * `OutElem`. When the channel finishes, it yields a value of type `OutDone`. A + * channel may fail with a value of type `OutErr`. + * + * Channels are the foundation of Streams: both streams and sinks are built on + * channels. Most users shouldn't have to use channels directly, as streams and + * sinks are much more convenient and cover all common use cases. However, when + * adding new stream and sink operators, or doing something highly specialized, + * it may be useful to use channels directly. + * + * Channels compose in a variety of ways: + * + * - **Piping**: One channel can be piped to another channel, assuming the + * input type of the second is the same as the output type of the first. + * - **Sequencing**: The terminal value of one channel can be used to create + * another channel, and both the first channel and the function that makes + * the second channel can be composed into a channel. + * - **Concatenating**: The output of one channel can be used to create other + * channels, which are all concatenated together. The first channel and the + * function that makes the other channels can be composed into a channel. + * + * @since 2.0.0 + * @category models + */ +export interface Channel extends Channel.Variance, Pipeable { + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: ChannelUnify; + [Unify.ignoreSymbol]?: ChannelUnifyIgnore; +} +/** + * @since 2.0.0 + * @category models + */ +export interface ChannelUnify extends Effect.EffectUnify { + Channel?: () => A[Unify.typeSymbol] extends Channel | infer _ ? Channel : never; +} +/** + * @category models + * @since 2.0.0 + */ +export interface ChannelUnifyIgnore extends Effect.EffectUnifyIgnore { + Channel?: true; +} +/** + * @since 2.0.0 + * @category models + */ +declare module "./Effect.js" { + interface Effect extends Channel { + } + interface EffectUnifyIgnore { + Channel?: true; + } +} +/** + * @since 2.0.0 + */ +export declare namespace Channel { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [ChannelTypeId]: VarianceStruct; + } + /** + * @since 2.0.0 + * @category models + */ + interface VarianceStruct { + _Env: Types.Covariant; + _InErr: Types.Contravariant; + _InElem: Types.Contravariant; + _InDone: Types.Contravariant; + _OutErr: Types.Covariant; + _OutElem: Types.Covariant; + _OutDone: Types.Covariant; + } +} +/** + * @since 2.0.0 + * @category symbols + */ +export declare const ChannelExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ChannelExceptionTypeId = typeof ChannelExceptionTypeId; +/** + * Represents a generic checked exception which occurs when a `Channel` is + * executed. + * + * @since 2.0.0 + * @category models + */ +export interface ChannelException { + readonly _tag: "ChannelException"; + readonly [ChannelExceptionTypeId]: ChannelExceptionTypeId; + readonly error: E; +} +/** + * @since 3.5.4 + * @category refinements + */ +export declare const isChannel: (u: unknown) => u is Channel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const acquireUseRelease: (acquire: Effect.Effect, use: (a: Acquired) => Channel, release: (a: Acquired, exit: Exit.Exit) => Effect.Effect) => Channel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const acquireReleaseOut: { + /** + * @since 2.0.0 + * @category constructors + */ + (release: (z: Z, e: Exit.Exit) => Effect.Effect): (self: Effect.Effect) => Channel; + /** + * @since 2.0.0 + * @category constructors + */ + (self: Effect.Effect, release: (z: Z, e: Exit.Exit) => Effect.Effect): Channel; +}; +/** + * Returns a new channel that is the same as this one, except the terminal + * value of the channel is the specified constant value. + * + * This method produces the same result as mapping this channel to the + * specified constant value. + * + * @since 2.0.0 + * @category mapping + */ +export declare const as: { + /** + * Returns a new channel that is the same as this one, except the terminal + * value of the channel is the specified constant value. + * + * This method produces the same result as mapping this channel to the + * specified constant value. + * + * @since 2.0.0 + * @category mapping + */ + (value: OutDone2): (self: Channel) => Channel; + /** + * Returns a new channel that is the same as this one, except the terminal + * value of the channel is the specified constant value. + * + * This method produces the same result as mapping this channel to the + * specified constant value. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, value: OutDone2): Channel; +}; +/** + * @since 2.0.0 + * @category mapping + */ +export declare const asVoid: (self: Channel) => Channel; +/** + * Creates a channel backed by a buffer. When the buffer is empty, the channel + * will simply passthrough its input as output. However, when the buffer is + * non-empty, the value inside the buffer will be passed along as output. + * + * @since 2.0.0 + * @category constructors + */ +export declare const buffer: (options: { + readonly empty: InElem; + readonly isEmpty: Predicate; + readonly ref: Ref.Ref; +}) => Channel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const bufferChunk: (ref: Ref.Ref>) => Channel, Chunk.Chunk, InErr, InErr, InDone, InDone>; +/** + * Returns a new channel that is the same as this one, except if this channel + * errors for any typed error, then the returned channel will switch over to + * using the fallback channel returned by the specified error handler. + * + * @since 2.0.0 + * @category error handling + */ +export declare const catchAll: { + /** + * Returns a new channel that is the same as this one, except if this channel + * errors for any typed error, then the returned channel will switch over to + * using the fallback channel returned by the specified error handler. + * + * @since 2.0.0 + * @category error handling + */ + (f: (error: OutErr) => Channel): (self: Channel) => Channel; + /** + * Returns a new channel that is the same as this one, except if this channel + * errors for any typed error, then the returned channel will switch over to + * using the fallback channel returned by the specified error handler. + * + * @since 2.0.0 + * @category error handling + */ + (self: Channel, f: (error: OutErr) => Channel): Channel; +}; +/** + * Returns a new channel that is the same as this one, except if this channel + * errors for any typed error, then the returned channel will switch over to + * using the fallback channel returned by the specified error handler. + * + * @since 2.0.0 + * @category error handling + */ +export declare const catchAllCause: { + /** + * Returns a new channel that is the same as this one, except if this channel + * errors for any typed error, then the returned channel will switch over to + * using the fallback channel returned by the specified error handler. + * + * @since 2.0.0 + * @category error handling + */ + (f: (cause: Cause.Cause) => Channel): (self: Channel) => Channel; + /** + * Returns a new channel that is the same as this one, except if this channel + * errors for any typed error, then the returned channel will switch over to + * using the fallback channel returned by the specified error handler. + * + * @since 2.0.0 + * @category error handling + */ + (self: Channel, f: (cause: Cause.Cause) => Channel): Channel; +}; +/** + * Concat sequentially a channel of channels. + * + * @since 2.0.0 + * @category constructors + */ +export declare const concatAll: (channels: Channel, InElem, OutErr, InErr, any, InDone, Env>) => Channel; +/** + * Concat sequentially a channel of channels. + * + * @since 2.0.0 + * @category constructors + */ +export declare const concatAllWith: (channels: Channel, InElem, OutErr, InErr, OutDone2, InDone, Env>, f: (o: OutDone, o1: OutDone) => OutDone, g: (o: OutDone, o2: OutDone2) => OutDone3) => Channel; +/** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const concatMap: { + /** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. + * + * @since 2.0.0 + * @category utils + */ + (f: (o: OutElem) => Channel): (self: Channel) => Channel; + /** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (o: OutElem) => Channel): Channel; +}; +/** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. The provided merging function is used to + * merge the terminal values of all channels into the single terminal value of + * the returned channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const concatMapWith: { + /** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. The provided merging function is used to + * merge the terminal values of all channels into the single terminal value of + * the returned channel. + * + * @since 2.0.0 + * @category utils + */ + (f: (o: OutElem) => Channel, g: (o: OutDone, o1: OutDone) => OutDone, h: (o: OutDone, o2: OutDone2) => OutDone3): (self: Channel) => Channel; + /** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. The provided merging function is used to + * merge the terminal values of all channels into the single terminal value of + * the returned channel. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (o: OutElem) => Channel, g: (o: OutDone, o1: OutDone) => OutDone, h: (o: OutDone, o2: OutDone2) => OutDone3): Channel; +}; +/** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. The provided merging function is used to + * merge the terminal values of all channels into the single terminal value of + * the returned channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const concatMapWithCustom: { + /** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. The provided merging function is used to + * merge the terminal values of all channels into the single terminal value of + * the returned channel. + * + * @since 2.0.0 + * @category utils + */ + (f: (o: OutElem) => Channel, g: (o: OutDone, o1: OutDone) => OutDone, h: (o: OutDone, o2: OutDone2) => OutDone3, onPull: (upstreamPullRequest: UpstreamPullRequest.UpstreamPullRequest) => UpstreamPullStrategy.UpstreamPullStrategy, onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision): (self: Channel) => Channel; + /** + * Returns a new channel whose outputs are fed to the specified factory + * function, which creates new channels in response. These new channels are + * sequentially concatenated together, and all their outputs appear as outputs + * of the newly returned channel. The provided merging function is used to + * merge the terminal values of all channels into the single terminal value of + * the returned channel. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (o: OutElem) => Channel, g: (o: OutDone, o1: OutDone) => OutDone, h: (o: OutDone, o2: OutDone2) => OutDone3, onPull: (upstreamPullRequest: UpstreamPullRequest.UpstreamPullRequest) => UpstreamPullStrategy.UpstreamPullStrategy, onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision): Channel; +}; +/** + * Returns a new channel, which is the same as this one, except its outputs + * are filtered and transformed by the specified partial function. + * + * @since 2.0.0 + * @category utils + */ +export declare const collect: { + /** + * Returns a new channel, which is the same as this one, except its outputs + * are filtered and transformed by the specified partial function. + * + * @since 2.0.0 + * @category utils + */ + (pf: (o: OutElem) => Option.Option): (self: Channel) => Channel; + /** + * Returns a new channel, which is the same as this one, except its outputs + * are filtered and transformed by the specified partial function. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, pf: (o: OutElem) => Option.Option): Channel; +}; +/** + * Returns a new channel, which is the concatenation of all the channels that + * are written out by this channel. This method may only be called on channels + * that output other channels. + * + * @since 2.0.0 + * @category utils + */ +export declare const concatOut: (self: Channel, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel; +/** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's done value. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapInput: { + /** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's done value. + * + * @since 2.0.0 + * @category utils + */ + (f: (a: InDone0) => InDone): (self: Channel) => Channel; + /** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's done value. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (a: InDone0) => InDone): Channel; +}; +/** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's done value. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapInputEffect: { + /** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's done value. + * + * @since 2.0.0 + * @category utils + */ + (f: (i: InDone0) => Effect.Effect): (self: Channel) => Channel; + /** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's done value. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (i: InDone0) => Effect.Effect): Channel; +}; +/** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's error value. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapInputError: { + /** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's error value. + * + * @since 2.0.0 + * @category utils + */ + (f: (a: InErr0) => InErr): (self: Channel) => Channel; + /** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's error value. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (a: InErr0) => InErr): Channel; +}; +/** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's error value. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapInputErrorEffect: { + /** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's error value. + * + * @since 2.0.0 + * @category utils + */ + (f: (error: InErr0) => Effect.Effect): (self: Channel) => Channel; + /** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's error value. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (error: InErr0) => Effect.Effect): Channel; +}; +/** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's output elements. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapInputIn: { + /** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's output elements. + * + * @since 2.0.0 + * @category utils + */ + (f: (a: InElem0) => InElem): (self: Channel) => Channel; + /** + * Returns a new channel which is the same as this one but applies the given + * function to the input channel's output elements. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (a: InElem0) => InElem): Channel; +}; +/** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's output elements. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapInputInEffect: { + /** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's output elements. + * + * @since 2.0.0 + * @category utils + */ + (f: (a: InElem0) => Effect.Effect): (self: Channel) => Channel; + /** + * Returns a new channel which is the same as this one but applies the given + * effectual function to the input channel's output elements. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, f: (a: InElem0) => Effect.Effect): Channel; +}; +/** + * Returns a new channel, which is the same as this one, except that all the + * outputs are collected and bundled into a tuple together with the terminal + * value of this channel. + * + * As the channel returned from this channel collects all of this channel's + * output into an in- memory chunk, it is not safe to call this method on + * channels that output a large or unbounded number of values. + * + * @since 2.0.0 + * @category utils + */ +export declare const doneCollect: (self: Channel) => Channel, OutDone], InDone, Env>; +/** + * Returns a new channel which reads all the elements from upstream's output + * channel and ignores them, then terminates with the upstream result value. + * + * @since 2.0.0 + * @category utils + */ +export declare const drain: (self: Channel) => Channel; +/** + * Returns a new channel which connects the given `AsyncInputProducer` as + * this channel's input. + * + * @since 2.0.0 + * @category utils + */ +export declare const embedInput: { + /** + * Returns a new channel which connects the given `AsyncInputProducer` as + * this channel's input. + * + * @since 2.0.0 + * @category utils + */ + (input: SingleProducerAsyncInput.AsyncInputProducer): (self: Channel) => Channel; + /** + * Returns a new channel which connects the given `AsyncInputProducer` as + * this channel's input. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, input: SingleProducerAsyncInput.AsyncInputProducer): Channel; +}; +/** + * Returns a new channel that collects the output and terminal value of this + * channel, which it then writes as output of the returned channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const emitCollect: (self: Channel) => Channel<[Chunk.Chunk, OutDone], InElem, OutErr, InErr, void, InDone, Env>; +/** + * Returns a new channel with an attached finalizer. The finalizer is + * guaranteed to be executed so long as the channel begins execution (and + * regardless of whether or not it completes). + * + * @since 2.0.0 + * @category utils + */ +export declare const ensuring: { + /** + * Returns a new channel with an attached finalizer. The finalizer is + * guaranteed to be executed so long as the channel begins execution (and + * regardless of whether or not it completes). + * + * @since 2.0.0 + * @category utils + */ + (finalizer: Effect.Effect): (self: Channel) => Channel; + /** + * Returns a new channel with an attached finalizer. The finalizer is + * guaranteed to be executed so long as the channel begins execution (and + * regardless of whether or not it completes). + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, finalizer: Effect.Effect): Channel; +}; +/** + * Returns a new channel with an attached finalizer. The finalizer is + * guaranteed to be executed so long as the channel begins execution (and + * regardless of whether or not it completes). + * + * @since 2.0.0 + * @category utils + */ +export declare const ensuringWith: { + /** + * Returns a new channel with an attached finalizer. The finalizer is + * guaranteed to be executed so long as the channel begins execution (and + * regardless of whether or not it completes). + * + * @since 2.0.0 + * @category utils + */ + (finalizer: (e: Exit.Exit) => Effect.Effect): (self: Channel) => Channel; + /** + * Returns a new channel with an attached finalizer. The finalizer is + * guaranteed to be executed so long as the channel begins execution (and + * regardless of whether or not it completes). + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, finalizer: (e: Exit.Exit) => Effect.Effect): Channel; +}; +/** + * Accesses the whole context of the channel. + * + * @since 2.0.0 + * @category context + */ +export declare const context: () => Channel, unknown, Env>; +/** + * Accesses the context of the channel with the specified function. + * + * @since 2.0.0 + * @category context + */ +export declare const contextWith: (f: (env: Context.Context) => OutDone) => Channel; +/** + * Accesses the context of the channel in the context of a channel. + * + * @since 2.0.0 + * @category context + */ +export declare const contextWithChannel: (f: (env: Context.Context) => Channel) => Channel; +/** + * Accesses the context of the channel in the context of an effect. + * + * @since 2.0.0 + * @category context + */ +export declare const contextWithEffect: (f: (env: Context.Context) => Effect.Effect) => Channel; +/** + * Constructs a channel that fails immediately with the specified error. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fail: (error: E) => Channel; +/** + * Constructs a channel that succeeds immediately with the specified lazily + * evaluated value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const failSync: (evaluate: LazyArg) => Channel; +/** + * Constructs a channel that fails immediately with the specified `Cause`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const failCause: (cause: Cause.Cause) => Channel; +/** + * Constructs a channel that succeeds immediately with the specified lazily + * evaluated `Cause`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const failCauseSync: (evaluate: LazyArg>) => Channel; +/** + * Returns a new channel, which sequentially combines this channel, together + * with the provided factory function, which creates a second channel based on + * the terminal value of this channel. The result is a channel that will first + * perform the functions of this channel, before performing the functions of + * the created channel (including yielding its terminal value). + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatMap: { + /** + * Returns a new channel, which sequentially combines this channel, together + * with the provided factory function, which creates a second channel based on + * the terminal value of this channel. The result is a channel that will first + * perform the functions of this channel, before performing the functions of + * the created channel (including yielding its terminal value). + * + * @since 2.0.0 + * @category sequencing + */ + (f: (d: OutDone) => Channel): (self: Channel) => Channel; + /** + * Returns a new channel, which sequentially combines this channel, together + * with the provided factory function, which creates a second channel based on + * the terminal value of this channel. The result is a channel that will first + * perform the functions of this channel, before performing the functions of + * the created channel (including yielding its terminal value). + * + * @since 2.0.0 + * @category sequencing + */ + (self: Channel, f: (d: OutDone) => Channel): Channel; +}; +/** + * Returns a new channel, which flattens the terminal value of this channel. + * This function may only be called if the terminal value of this channel is + * another channel of compatible types. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatten: (self: Channel, InDone, Env>) => Channel; +/** + * Folds over the result of this channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const foldChannel: { + /** + * Folds over the result of this channel. + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly onFailure: (error: OutErr) => Channel; + readonly onSuccess: (done: OutDone) => Channel; + }): (self: Channel) => Channel; + /** + * Folds over the result of this channel. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, options: { + readonly onFailure: (error: OutErr) => Channel; + readonly onSuccess: (done: OutDone) => Channel; + }): Channel; +}; +/** + * Folds over the result of this channel including any cause of termination. + * + * @since 2.0.0 + * @category utils + */ +export declare const foldCauseChannel: { + /** + * Folds over the result of this channel including any cause of termination. + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly onFailure: (c: Cause.Cause) => Channel; + readonly onSuccess: (o: OutDone) => Channel; + }): (self: Channel) => Channel; + /** + * Folds over the result of this channel including any cause of termination. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, options: { + readonly onFailure: (c: Cause.Cause) => Channel; + readonly onSuccess: (o: OutDone) => Channel; + }): Channel; +}; +/** + * Use an effect to end a channel. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromEffect: (effect: Effect.Effect) => Channel; +/** + * Constructs a channel from an `Either`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromEither: (either: Either.Either) => Channel; +/** + * Construct a `Channel` from an `AsyncInputConsumer`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromInput: (input: SingleProducerAsyncInput.AsyncInputConsumer) => Channel; +/** + * Construct a `Channel` from a `PubSub`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromPubSub: (pubsub: PubSub.PubSub>>) => Channel; +/** + * Construct a `Channel` from a `PubSub` within a scoped effect. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromPubSubScoped: (pubsub: PubSub.PubSub>>) => Effect.Effect, never, Scope.Scope>; +/** + * Construct a `Channel` from an `Option`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromOption: (option: Option.Option) => Channel, unknown, A, unknown>; +/** + * Construct a `Channel` from a `Queue`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromQueue: (queue: Queue.Dequeue>>) => Channel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const identity: () => Channel; +/** + * Returns a new channel, which is the same as this one, except it will be + * interrupted when the specified effect completes. If the effect completes + * successfully before the underlying channel is done, then the returned + * channel will yield the success value of the effect as its terminal value. + * On the other hand, if the underlying channel finishes first, then the + * returned channel will yield the success value of the underlying channel as + * its terminal value. + * + * @since 2.0.0 + * @category utils + */ +export declare const interruptWhen: { + /** + * Returns a new channel, which is the same as this one, except it will be + * interrupted when the specified effect completes. If the effect completes + * successfully before the underlying channel is done, then the returned + * channel will yield the success value of the effect as its terminal value. + * On the other hand, if the underlying channel finishes first, then the + * returned channel will yield the success value of the underlying channel as + * its terminal value. + * + * @since 2.0.0 + * @category utils + */ + (effect: Effect.Effect): (self: Channel) => Channel; + /** + * Returns a new channel, which is the same as this one, except it will be + * interrupted when the specified effect completes. If the effect completes + * successfully before the underlying channel is done, then the returned + * channel will yield the success value of the effect as its terminal value. + * On the other hand, if the underlying channel finishes first, then the + * returned channel will yield the success value of the underlying channel as + * its terminal value. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, effect: Effect.Effect): Channel; +}; +/** + * Returns a new channel, which is the same as this one, except it will be + * interrupted when the specified deferred is completed. If the deferred is + * completed before the underlying channel is done, then the returned channel + * will yield the value of the deferred. Otherwise, if the underlying channel + * finishes first, then the returned channel will yield the value of the + * underlying channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const interruptWhenDeferred: { + /** + * Returns a new channel, which is the same as this one, except it will be + * interrupted when the specified deferred is completed. If the deferred is + * completed before the underlying channel is done, then the returned channel + * will yield the value of the deferred. Otherwise, if the underlying channel + * finishes first, then the returned channel will yield the value of the + * underlying channel. + * + * @since 2.0.0 + * @category utils + */ + (deferred: Deferred.Deferred): (self: Channel) => Channel; + /** + * Returns a new channel, which is the same as this one, except it will be + * interrupted when the specified deferred is completed. If the deferred is + * completed before the underlying channel is done, then the returned channel + * will yield the value of the deferred. Otherwise, if the underlying channel + * finishes first, then the returned channel will yield the value of the + * underlying channel. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, deferred: Deferred.Deferred): Channel; +}; +/** + * Returns a new channel, which is the same as this one, except the terminal + * value of the returned channel is created by applying the specified function + * to the terminal value of this channel. + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Returns a new channel, which is the same as this one, except the terminal + * value of the returned channel is created by applying the specified function + * to the terminal value of this channel. + * + * @since 2.0.0 + * @category mapping + */ + (f: (out: OutDone) => OutDone2): (self: Channel) => Channel; + /** + * Returns a new channel, which is the same as this one, except the terminal + * value of the returned channel is created by applying the specified function + * to the terminal value of this channel. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (out: OutDone) => OutDone2): Channel; +}; +/** + * Returns a new channel, which is the same as this one, except the terminal + * value of the returned channel is created by applying the specified + * effectful function to the terminal value of this channel. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapEffect: { + /** + * Returns a new channel, which is the same as this one, except the terminal + * value of the returned channel is created by applying the specified + * effectful function to the terminal value of this channel. + * + * @since 2.0.0 + * @category mapping + */ + (f: (o: OutDone) => Effect.Effect): (self: Channel) => Channel; + /** + * Returns a new channel, which is the same as this one, except the terminal + * value of the returned channel is created by applying the specified + * effectful function to the terminal value of this channel. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (o: OutDone) => Effect.Effect): Channel; +}; +/** + * Returns a new channel, which is the same as this one, except the failure + * value of the returned channel is created by applying the specified function + * to the failure value of this channel. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapError: { + /** + * Returns a new channel, which is the same as this one, except the failure + * value of the returned channel is created by applying the specified function + * to the failure value of this channel. + * + * @since 2.0.0 + * @category mapping + */ + (f: (err: OutErr) => OutErr2): (self: Channel) => Channel; + /** + * Returns a new channel, which is the same as this one, except the failure + * value of the returned channel is created by applying the specified function + * to the failure value of this channel. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (err: OutErr) => OutErr2): Channel; +}; +/** + * A more powerful version of `mapError` which also surfaces the `Cause` + * of the channel failure. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapErrorCause: { + /** + * A more powerful version of `mapError` which also surfaces the `Cause` + * of the channel failure. + * + * @since 2.0.0 + * @category mapping + */ + (f: (cause: Cause.Cause) => Cause.Cause): (self: Channel) => Channel; + /** + * A more powerful version of `mapError` which also surfaces the `Cause` + * of the channel failure. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (cause: Cause.Cause) => Cause.Cause): Channel; +}; +/** + * Maps the output of this channel using the specified function. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapOut: { + /** + * Maps the output of this channel using the specified function. + * + * @since 2.0.0 + * @category mapping + */ + (f: (o: OutElem) => OutElem2): (self: Channel) => Channel; + /** + * Maps the output of this channel using the specified function. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (o: OutElem) => OutElem2): Channel; +}; +/** + * Creates a channel that is like this channel but the given effectful function + * gets applied to each emitted output element. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapOutEffect: { + /** + * Creates a channel that is like this channel but the given effectful function + * gets applied to each emitted output element. + * + * @since 2.0.0 + * @category mapping + */ + (f: (o: OutElem) => Effect.Effect): (self: Channel) => Channel; + /** + * Creates a channel that is like this channel but the given effectful function + * gets applied to each emitted output element. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (o: OutElem) => Effect.Effect): Channel; +}; +/** + * Creates a channel that is like this channel but the given Effect function gets + * applied to each emitted output element, taking `n` elements at once and + * mapping them in parallel. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapOutEffectPar: { + /** + * Creates a channel that is like this channel but the given Effect function gets + * applied to each emitted output element, taking `n` elements at once and + * mapping them in parallel. + * + * @since 2.0.0 + * @category mapping + */ + (f: (o: OutElem) => Effect.Effect, n: number): (self: Channel) => Channel; + /** + * Creates a channel that is like this channel but the given Effect function gets + * applied to each emitted output element, taking `n` elements at once and + * mapping them in parallel. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (o: OutElem) => Effect.Effect, n: number): Channel; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const mergeAll: (options: { + readonly concurrency: number | "unbounded"; + readonly bufferSize?: number | undefined; + readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined; +}) => (channels: Channel, InElem, OutErr, InErr, unknown, InDone, Env>) => Channel; +/** + * @since 2.0.0 + * @category utils + */ +export declare const mergeAllUnbounded: (channels: Channel, InElem, OutErr, InErr, unknown, InDone, Env>) => Channel; +/** + * @since 2.0.0 + * @category utils + */ +export declare const mergeAllUnboundedWith: (channels: Channel, InElem, OutErr, InErr, OutDone, InDone, Env>, f: (o1: OutDone, o2: OutDone) => OutDone) => Channel; +/** + * @since 2.0.0 + * @category utils + */ +export declare const mergeAllWith: ({ bufferSize, concurrency, mergeStrategy }: { + readonly concurrency: number | "unbounded"; + readonly bufferSize?: number | undefined; + readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined; +}) => (channels: Channel, InElem, OutErr, InErr, OutDone, InDone, Env>, f: (o1: OutDone, o2: OutDone) => OutDone) => Channel; +/** + * Returns a new channel which creates a new channel for each emitted element + * and merges some of them together. Different merge strategies control what + * happens if there are more than the given maximum number of channels gets + * created. See `Channel.mergeAll`. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mergeMap: { + /** + * Returns a new channel which creates a new channel for each emitted element + * and merges some of them together. Different merge strategies control what + * happens if there are more than the given maximum number of channels gets + * created. See `Channel.mergeAll`. + * + * @since 2.0.0 + * @category mapping + */ + (f: (outElem: OutElem) => Channel, options: { + readonly concurrency: number | "unbounded"; + readonly bufferSize?: number | undefined; + readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined; + }): (self: Channel) => Channel; + /** + * Returns a new channel which creates a new channel for each emitted element + * and merges some of them together. Different merge strategies control what + * happens if there are more than the given maximum number of channels gets + * created. See `Channel.mergeAll`. + * + * @since 2.0.0 + * @category mapping + */ + (self: Channel, f: (outElem: OutElem) => Channel, options: { + readonly concurrency: number | "unbounded"; + readonly bufferSize?: number | undefined; + readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined; + }): Channel; +}; +/** + * Returns a new channel which merges a number of channels emitted by this + * channel using the back pressuring merge strategy. See `Channel.mergeAll`. + * + * @since 2.0.0 + * @category utils + */ +export declare const mergeOut: { + /** + * Returns a new channel which merges a number of channels emitted by this + * channel using the back pressuring merge strategy. See `Channel.mergeAll`. + * + * @since 2.0.0 + * @category utils + */ + (n: number): (self: Channel, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel; + /** + * Returns a new channel which merges a number of channels emitted by this + * channel using the back pressuring merge strategy. See `Channel.mergeAll`. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, InElem, OutErr, InErr, OutDone, InDone, Env>, n: number): Channel; +}; +/** + * Returns a new channel which merges a number of channels emitted by this + * channel using the back pressuring merge strategy and uses a given function + * to merge each completed subchannel's result value. See + * `Channel.mergeAll`. + * + * @since 2.0.0 + * @category utils + */ +export declare const mergeOutWith: { + /** + * Returns a new channel which merges a number of channels emitted by this + * channel using the back pressuring merge strategy and uses a given function + * to merge each completed subchannel's result value. See + * `Channel.mergeAll`. + * + * @since 2.0.0 + * @category utils + */ + (n: number, f: (o1: OutDone1, o2: OutDone1) => OutDone1): (self: Channel, InElem, OutErr, InErr, OutDone1, InDone, Env>) => Channel; + /** + * Returns a new channel which merges a number of channels emitted by this + * channel using the back pressuring merge strategy and uses a given function + * to merge each completed subchannel's result value. See + * `Channel.mergeAll`. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, InElem, OutErr, InErr, OutDone1, InDone, Env>, n: number, f: (o1: OutDone1, o2: OutDone1) => OutDone1): Channel; +}; +/** + * Returns a new channel, which is the merge of this channel and the specified + * channel, where the behavior of the returned channel on left or right early + * termination is decided by the specified `leftDone` and `rightDone` merge + * decisions. + * + * @since 2.0.0 + * @category utils + */ +export declare const mergeWith: { + /** + * Returns a new channel, which is the merge of this channel and the specified + * channel, where the behavior of the returned channel on left or right early + * termination is decided by the specified `leftDone` and `rightDone` merge + * decisions. + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly other: Channel; + readonly onSelfDone: (exit: Exit.Exit) => MergeDecision.MergeDecision; + readonly onOtherDone: (ex: Exit.Exit) => MergeDecision.MergeDecision; + }): (self: Channel) => Channel; + /** + * Returns a new channel, which is the merge of this channel and the specified + * channel, where the behavior of the returned channel on left or right early + * termination is decided by the specified `leftDone` and `rightDone` merge + * decisions. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, options: { + readonly other: Channel; + readonly onSelfDone: (exit: Exit.Exit) => MergeDecision.MergeDecision; + readonly onOtherDone: (ex: Exit.Exit) => MergeDecision.MergeDecision; + }): Channel; +}; +/** + * Returns a channel that never completes + * + * @since 2.0.0 + * @category constructors + */ +export declare const never: Channel; +/** + * Translates channel failure into death of the fiber, making all failures + * unchecked and not a part of the type of the channel. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orDie: { + /** + * Translates channel failure into death of the fiber, making all failures + * unchecked and not a part of the type of the channel. + * + * @since 2.0.0 + * @category error handling + */ + (error: LazyArg): (self: Channel) => Channel; + /** + * Translates channel failure into death of the fiber, making all failures + * unchecked and not a part of the type of the channel. + * + * @since 2.0.0 + * @category error handling + */ + (self: Channel, error: LazyArg): Channel; +}; +/** + * Keeps none of the errors, and terminates the fiber with them, using the + * specified function to convert the `OutErr` into a defect. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orDieWith: { + /** + * Keeps none of the errors, and terminates the fiber with them, using the + * specified function to convert the `OutErr` into a defect. + * + * @since 2.0.0 + * @category error handling + */ + (f: (e: OutErr) => unknown): (self: Channel) => Channel; + /** + * Keeps none of the errors, and terminates the fiber with them, using the + * specified function to convert the `OutErr` into a defect. + * + * @since 2.0.0 + * @category error handling + */ + (self: Channel, f: (e: OutErr) => unknown): Channel; +}; +/** + * Returns a new channel that will perform the operations of this one, until + * failure, and then it will switch over to the operations of the specified + * fallback channel. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orElse: { + /** + * Returns a new channel that will perform the operations of this one, until + * failure, and then it will switch over to the operations of the specified + * fallback channel. + * + * @since 2.0.0 + * @category error handling + */ + (that: LazyArg>): (self: Channel) => Channel; + /** + * Returns a new channel that will perform the operations of this one, until + * failure, and then it will switch over to the operations of the specified + * fallback channel. + * + * @since 2.0.0 + * @category error handling + */ + (self: Channel, that: LazyArg>): Channel; +}; +/** + * Returns a new channel that pipes the output of this channel into the + * specified channel. The returned channel has the input type of this channel, + * and the output type of the specified channel, terminating with the value of + * the specified channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const pipeTo: { + /** + * Returns a new channel that pipes the output of this channel into the + * specified channel. The returned channel has the input type of this channel, + * and the output type of the specified channel, terminating with the value of + * the specified channel. + * + * @since 2.0.0 + * @category utils + */ + (that: Channel): (self: Channel) => Channel; + /** + * Returns a new channel that pipes the output of this channel into the + * specified channel. The returned channel has the input type of this channel, + * and the output type of the specified channel, terminating with the value of + * the specified channel. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, that: Channel): Channel; +}; +/** + * Returns a new channel that pipes the output of this channel into the + * specified channel and preserves this channel's failures without providing + * them to the other channel for observation. + * + * @since 2.0.0 + * @category utils + */ +export declare const pipeToOrFail: { + /** + * Returns a new channel that pipes the output of this channel into the + * specified channel and preserves this channel's failures without providing + * them to the other channel for observation. + * + * @since 2.0.0 + * @category utils + */ + (that: Channel): (self: Channel) => Channel; + /** + * Returns a new channel that pipes the output of this channel into the + * specified channel and preserves this channel's failures without providing + * them to the other channel for observation. + * + * @since 2.0.0 + * @category utils + */ + (self: Channel, that: Channel): Channel; +}; +/** + * Provides the channel with its required context, which eliminates its + * dependency on `Env`. + * + * @since 2.0.0 + * @category context + */ +export declare const provideContext: { + /** + * Provides the channel with its required context, which eliminates its + * dependency on `Env`. + * + * @since 2.0.0 + * @category context + */ + (env: Context.Context): (self: Channel) => Channel; + /** + * Provides the channel with its required context, which eliminates its + * dependency on `Env`. + * + * @since 2.0.0 + * @category context + */ + (self: Channel, env: Context.Context): Channel; +}; +/** + * Provides a layer to the channel, which translates it to another level. + * + * @since 2.0.0 + * @category context + */ +export declare const provideLayer: { + /** + * Provides a layer to the channel, which translates it to another level. + * + * @since 2.0.0 + * @category context + */ + (layer: Layer.Layer): (self: Channel) => Channel; + /** + * Provides a layer to the channel, which translates it to another level. + * + * @since 2.0.0 + * @category context + */ + (self: Channel, layer: Layer.Layer): Channel; +}; +/** + * Transforms the context being provided to the channel with the specified + * function. + * + * @since 2.0.0 + * @category context + */ +export declare const mapInputContext: { + /** + * Transforms the context being provided to the channel with the specified + * function. + * + * @since 2.0.0 + * @category context + */ + (f: (env: Context.Context) => Context.Context): (self: Channel) => Channel; + /** + * Transforms the context being provided to the channel with the specified + * function. + * + * @since 2.0.0 + * @category context + */ + (self: Channel, f: (env: Context.Context) => Context.Context): Channel; +}; +/** + * Splits the context into two parts, providing one part using the + * specified layer and leaving the remainder `Env0`. + * + * @since 2.0.0 + * @category context + */ +export declare const provideSomeLayer: { + /** + * Splits the context into two parts, providing one part using the + * specified layer and leaving the remainder `Env0`. + * + * @since 2.0.0 + * @category context + */ + (layer: Layer.Layer): (self: Channel) => Channel>; + /** + * Splits the context into two parts, providing one part using the + * specified layer and leaving the remainder `Env0`. + * + * @since 2.0.0 + * @category context + */ + (self: Channel, layer: Layer.Layer): Channel>; +}; +/** + * Provides the effect with the single service it requires. If the effect + * requires more than one service use `provideContext` instead. + * + * @since 2.0.0 + * @category context + */ +export declare const provideService: { + /** + * Provides the effect with the single service it requires. If the effect + * requires more than one service use `provideContext` instead. + * + * @since 2.0.0 + * @category context + */ + (tag: Context.Tag, service: Types.NoInfer): (self: Channel) => Channel>; + /** + * Provides the effect with the single service it requires. If the effect + * requires more than one service use `provideContext` instead. + * + * @since 2.0.0 + * @category context + */ + (self: Channel, tag: Context.Tag, service: Types.NoInfer): Channel>; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const read: () => Channel, unknown, In, unknown>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const readOrFail: (error: E) => Channel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const readWith: (options: { + readonly onInput: (input: InElem) => Channel; + readonly onFailure: (error: InErr) => Channel; + readonly onDone: (done: InDone) => Channel; +}) => Channel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const readWithCause: (options: { + readonly onInput: (input: InElem) => Channel; + readonly onFailure: (cause: Cause.Cause) => Channel; + readonly onDone: (done: InDone) => Channel; +}) => Channel; +/** + * Creates a channel which repeatedly runs this channel. + * + * @since 2.0.0 + * @category utils + */ +export declare const repeated: (self: Channel) => Channel; +/** + * Runs a channel until the end is received. + * + * @since 2.0.0 + * @category destructors + */ +export declare const run: (self: Channel) => Effect.Effect; +/** + * Run the channel until it finishes with a done value or fails with an error + * and collects its emitted output elements. + * + * The channel must not read any input. + * + * @since 2.0.0 + * @category destructors + */ +export declare const runCollect: (self: Channel) => Effect.Effect<[Chunk.Chunk, OutDone], OutErr, Env>; +/** + * Runs a channel until the end is received. + * + * @since 2.0.0 + * @category destructors + */ +export declare const runDrain: (self: Channel) => Effect.Effect; +/** + * Run the channel until it finishes with a done value or fails with an error. + * The channel must not read any input or write any output. + * + * Closing the channel, which includes execution of all the finalizers + * attached to the channel will be added to the current scope as a finalizer. + * + * @since 3.11.0 + * @category destructors + */ +export declare const runScoped: (self: Channel) => Effect.Effect; +/** + * Use a scoped effect to emit an output element. + * + * @since 2.0.0 + * @category constructors + */ +export declare const scoped: (effect: Effect.Effect) => Channel>; +/** + * Use a function that receives a scope and returns an effect to emit an output + * element. The output element will be the result of the returned effect, if + * successful. + * + * @since 3.11.0 + * @category constructors + */ +export declare const scopedWith: (f: (scope: Scope.Scope) => Effect.Effect) => Channel; +/** + * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX + * newlines (`\n`). + * + * @since 2.0.0 + * @category combinators + */ +export declare const splitLines: () => Channel, Chunk.Chunk, Err, Err, Done, Done, never>; +/** + * Constructs a channel that succeeds immediately with the specified value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const succeed: (value: A) => Channel; +/** + * Lazily constructs a channel from the given side effect. + * + * @since 2.0.0 + * @category constructors + */ +export declare const suspend: (evaluate: LazyArg>) => Channel; +/** + * Constructs a channel that succeeds immediately with the specified lazy value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const sync: (evaluate: LazyArg) => Channel; +/** + * Converts a `Channel` to a `PubSub`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const toPubSub: (pubsub: PubSub.PubSub>>) => Channel; +/** + * Returns a scoped `Effect` that can be used to repeatedly pull elements from + * the constructed `Channel`. The pull effect fails with the channel's failure + * in case the channel fails, or returns either the channel's done value or an + * emitted element. + * + * @since 2.0.0 + * @category destructors + */ +export declare const toPull: (self: Channel) => Effect.Effect, OutErr, Env>, never, Scope.Scope | Env>; +/** + * Returns an `Effect` that can be used to repeatedly pull elements from the + * constructed `Channel` within the provided `Scope`. The pull effect fails + * with the channel's failure in case the channel fails, or returns either the + * channel's done value or an emitted element. + * + * @since 3.11.0 + * @category destructors + */ +export declare const toPullIn: { + /** + * Returns an `Effect` that can be used to repeatedly pull elements from the + * constructed `Channel` within the provided `Scope`. The pull effect fails + * with the channel's failure in case the channel fails, or returns either the + * channel's done value or an emitted element. + * + * @since 3.11.0 + * @category destructors + */ + (scope: Scope.Scope): (self: Channel) => Effect.Effect, OutErr, Env>, never, Env>; + /** + * Returns an `Effect` that can be used to repeatedly pull elements from the + * constructed `Channel` within the provided `Scope`. The pull effect fails + * with the channel's failure in case the channel fails, or returns either the + * channel's done value or an emitted element. + * + * @since 3.11.0 + * @category destructors + */ + (self: Channel, scope: Scope.Scope): Effect.Effect, OutErr, Env>, never, Env>; +}; +/** + * Converts a `Channel` to a `Queue`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const toQueue: (queue: Queue.Enqueue>>) => Channel; +/** Converts this channel to a `Sink`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const toSink: (self: Channel, Chunk.Chunk, OutErr, InErr, OutDone, unknown, Env>) => Sink.Sink; +/** + * Converts this channel to a `Stream`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const toStream: (self: Channel, unknown, OutErr, unknown, OutDone, unknown, Env>) => Stream.Stream; +declare const void_: Channel; +export { +/** + * @since 2.0.0 + * @category constructors + */ +void_ as void }; +/** + * Constructs a `Channel` from an effect that will result in a `Channel` if + * successful. + * + * @since 2.0.0 + * @category constructors + */ +export declare const unwrap: (channel: Effect.Effect, E, R>) => Channel; +/** + * Constructs a `Channel` from a scoped effect that will result in a + * `Channel` if successful. + * + * @since 2.0.0 + * @category constructors + */ +export declare const unwrapScoped: (self: Effect.Effect, E, R>) => Channel>; +/** + * Constructs a `Channel` from a function which receives a `Scope` and returns + * an effect that will result in a `Channel` if successful. + * + * @since 3.11.0 + * @category constructors + */ +export declare const unwrapScopedWith: (f: (scope: Scope.Scope) => Effect.Effect, E, R>) => Channel; +/** + * Updates a service in the context of this channel. + * + * @since 2.0.0 + * @category context + */ +export declare const updateService: { + /** + * Updates a service in the context of this channel. + * + * @since 2.0.0 + * @category context + */ + (tag: Context.Tag, f: (resource: Types.NoInfer) => Types.NoInfer): (self: Channel) => Channel; + /** + * Updates a service in the context of this channel. + * + * @since 2.0.0 + * @category context + */ + (self: Channel, tag: Context.Tag, f: (resource: Types.NoInfer) => Types.NoInfer): Channel; +}; +/** + * Wraps the channel with a new span for tracing. + * + * @since 2.0.0 + * @category tracing + */ +export declare const withSpan: { + /** + * Wraps the channel with a new span for tracing. + * + * @since 2.0.0 + * @category tracing + */ + (name: string, options?: Tracer.SpanOptions | undefined): (self: Channel) => Channel>; + /** + * Wraps the channel with a new span for tracing. + * + * @since 2.0.0 + * @category tracing + */ + (self: Channel, name: string, options?: Tracer.SpanOptions | undefined): Channel>; +}; +/** + * Writes a single value to the channel. + * + * @since 2.0.0 + * @category constructors + */ +export declare const write: (out: OutElem) => Channel; +/** + * Writes a sequence of values to the channel. + * + * @since 2.0.0 + * @category constructors + */ +export declare const writeAll: >(...outs: OutElems) => Channel; +/** + * Writes a `Chunk` of values to the channel. + * + * @since 2.0.0 + * @category constructors + */ +export declare const writeChunk: (outs: Chunk.Chunk) => Channel; +/** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with a tuple of + * the terminal values of both channels. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zip: { + /** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with a tuple of + * the terminal values of both channels. + * + * @since 2.0.0 + * @category zipping + */ + (that: Channel, options?: { + readonly concurrent?: boolean | undefined; + } | undefined): (self: Channel) => Channel; + /** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with a tuple of + * the terminal values of both channels. + * + * @since 2.0.0 + * @category zipping + */ + (self: Channel, that: Channel, options?: { + readonly concurrent?: boolean | undefined; + } | undefined): Channel; +}; +/** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with the + * terminal value of this channel. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipLeft: { + /** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with the + * terminal value of this channel. + * + * @since 2.0.0 + * @category zipping + */ + (that: Channel, options?: { + readonly concurrent?: boolean | undefined; + } | undefined): (self: Channel) => Channel; + /** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with the + * terminal value of this channel. + * + * @since 2.0.0 + * @category zipping + */ + (self: Channel, that: Channel, options?: { + readonly concurrent?: boolean | undefined; + } | undefined): Channel; +}; +/** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with the + * terminal value of that channel. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipRight: { + /** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with the + * terminal value of that channel. + * + * @since 2.0.0 + * @category zipping + */ + (that: Channel, options?: { + readonly concurrent?: boolean | undefined; + }): (self: Channel) => Channel; + /** + * Returns a new channel that is the sequential composition of this channel + * and the specified channel. The returned channel terminates with the + * terminal value of that channel. + * + * @since 2.0.0 + * @category zipping + */ + (self: Channel, that: Channel, options?: { + readonly concurrent?: boolean | undefined; + }): Channel; +}; +/** + * Represents a generic checked exception which occurs when a `Channel` is + * executed. + * + * @since 2.0.0 + * @category errors + */ +export declare const ChannelException: (error: E) => ChannelException; +/** + * Returns `true` if the specified value is an `ChannelException`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isChannelException: (u: unknown) => u is ChannelException; +//# sourceMappingURL=Channel.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ChildExecutorDecision.d.ts.map b/backend/node_modules/effect/dist/dts/ChildExecutorDecision.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..7c44321043bbc9b74c07b979e40fd8bc72461cfd --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ChildExecutorDecision.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ChildExecutorDecision.d.ts","sourceRoot":"","sources":["../../src/ChildExecutorDecision.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,OAAO,MAA6C,CAAA;AAE9F;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA;AAE5E;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAA;AAE5D;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,qBAAqB,CAAC;IAC7C;;;OAGG;IACH,UAAiB,KAAK;QACpB,QAAQ,CAAC,CAAC,2BAA2B,CAAC,EAAE,2BAA2B,CAAA;KACpE;CACF;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAS,SAAQ,qBAAqB,CAAC,KAAK;IAC3D,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,KAAM,SAAQ,qBAAqB,CAAC,KAAK;IACxD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,KAAM,SAAQ,qBAAqB,CAAC,KAAK;IACxD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,qBAAyC,CAAA;AAE7E;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,qBAAsC,CAAA;AAE9E;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,qBAAsC,CAAA;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,qBAAwD,CAAA;AAEnH;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,IAAI,QAA8B,CAAA;AAEhG;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,IAAI,KAAwB,CAAA;AAEvF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,IAAI,KAAwB,CAAA;AAEvF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;OAKG;IACH,CAAC,CAAC,EACD,OAAO,EAAE;QACP,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;QAC5B,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAA;QACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;KAC1B,GACC,CAAC,IAAI,EAAE,qBAAqB,KAAK,CAAC,CAAA;IACrC;;;;;OAKG;IACH,CAAC,CAAC,EACD,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE;QACP,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;QAC5B,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAA;QACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;KAC1B,GACC,CAAC,CAAA;CACY,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Chunk.d.ts b/backend/node_modules/effect/dist/dts/Chunk.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a4134b374d110d55c3eb427cbcd07344fd3abfc0 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Chunk.d.ts @@ -0,0 +1,1709 @@ +/** + * @since 2.0.0 + */ +import * as RA from "./Array.js"; +import type { NonEmptyReadonlyArray } from "./Array.js"; +import type { Either } from "./Either.js"; +import * as Equal from "./Equal.js"; +import * as Equivalence from "./Equivalence.js"; +import type { TypeLambda } from "./HKT.js"; +import { type Inspectable } from "./Inspectable.js"; +import type { NonEmptyIterable } from "./NonEmptyIterable.js"; +import type { Option } from "./Option.js"; +import * as Order from "./Order.js"; +import type { Pipeable } from "./Pipeable.js"; +import { type Predicate, type Refinement } from "./Predicate.js"; +import type { Covariant, NoInfer } from "./Types.js"; +declare const TypeId: unique symbol; +/** + * @category symbol + * @since 2.0.0 + */ +export type TypeId = typeof TypeId; +/** + * @category models + * @since 2.0.0 + */ +export interface Chunk extends Iterable, Equal.Equal, Pipeable, Inspectable { + readonly [TypeId]: { + readonly _A: Covariant; + }; + readonly length: number; +} +/** + * @category model + * @since 2.0.0 + */ +export interface NonEmptyChunk extends Chunk, NonEmptyIterable { +} +/** + * @category type lambdas + * @since 2.0.0 + */ +export interface ChunkTypeLambda extends TypeLambda { + readonly type: Chunk; +} +/** + * Compares the two chunks of equal length using the specified function + * + * @category equivalence + * @since 2.0.0 + */ +export declare const getEquivalence: (isEquivalent: Equivalence.Equivalence) => Equivalence.Equivalence>; +/** + * Checks if `u` is a `Chunk` + * + * @category constructors + * @since 2.0.0 + */ +export declare const isChunk: { + /** + * Checks if `u` is a `Chunk` + * + * @category constructors + * @since 2.0.0 + */ + (u: Iterable): u is Chunk; + /** + * Checks if `u` is a `Chunk` + * + * @category constructors + * @since 2.0.0 + */ + (u: unknown): u is Chunk; +}; +/** + * @category constructors + * @since 2.0.0 + */ +export declare const empty: () => Chunk; +/** + * Builds a `NonEmptyChunk` from an non-empty collection of elements. + * + * @category constructors + * @since 2.0.0 + */ +export declare const make: ]>(...as: As) => NonEmptyChunk; +/** + * Builds a `NonEmptyChunk` from a single element. + * + * @category constructors + * @since 2.0.0 + */ +export declare const of: (a: A) => NonEmptyChunk; +/** + * Creates a new `Chunk` from an iterable collection of values. + * + * @category constructors + * @since 2.0.0 + */ +export declare const fromIterable: (self: Iterable) => Chunk; +/** + * Converts a `Chunk` into an `Array`. If the provided `Chunk` is non-empty + * (`NonEmptyChunk`), the function will return a `NonEmptyArray`, ensuring the + * non-empty property is preserved. + * + * @category conversions + * @since 2.0.0 + */ +export declare const toArray: >(self: S) => S extends NonEmptyChunk ? RA.NonEmptyArray> : Array>; +/** + * Converts a `Chunk` into a `ReadonlyArray`. If the provided `Chunk` is + * non-empty (`NonEmptyChunk`), the function will return a + * `NonEmptyReadonlyArray`, ensuring the non-empty property is preserved. + * + * @category conversions + * @since 2.0.0 + */ +export declare const toReadonlyArray: >(self: S) => S extends NonEmptyChunk ? RA.NonEmptyReadonlyArray> : ReadonlyArray>; +/** + * Reverses the order of elements in a `Chunk`. + * Importantly, if the input chunk is a `NonEmptyChunk`, the reversed chunk will also be a `NonEmptyChunk`. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const chunk = Chunk.make(1, 2, 3) + * const result = Chunk.reverse(chunk) + * + * console.log(result) + * // { _id: 'Chunk', values: [ 3, 2, 1 ] } + * ``` + * + * @since 2.0.0 + * @category elements + */ +export declare const reverse: >(self: S) => Chunk.With>; +/** + * This function provides a safe way to read a value at a particular index from a `Chunk`. + * + * @category elements + * @since 2.0.0 + */ +export declare const get: { + /** + * This function provides a safe way to read a value at a particular index from a `Chunk`. + * + * @category elements + * @since 2.0.0 + */ + (index: number): (self: Chunk) => Option; + /** + * This function provides a safe way to read a value at a particular index from a `Chunk`. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, index: number): Option; +}; +/** + * Wraps an array into a chunk without copying, unsafe on mutable arrays + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeFromArray: (self: ReadonlyArray) => Chunk; +/** + * Wraps an array into a chunk without copying, unsafe on mutable arrays + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeFromNonEmptyArray: (self: NonEmptyReadonlyArray) => NonEmptyChunk; +/** + * Gets an element unsafely, will throw on out of bounds + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeGet: { + /** + * Gets an element unsafely, will throw on out of bounds + * + * @since 2.0.0 + * @category unsafe + */ + (index: number): (self: Chunk) => A; + /** + * Gets an element unsafely, will throw on out of bounds + * + * @since 2.0.0 + * @category unsafe + */ + (self: Chunk, index: number): A; +}; +/** + * Appends the specified element to the end of the `Chunk`. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const append: { + /** + * Appends the specified element to the end of the `Chunk`. + * + * @category concatenating + * @since 2.0.0 + */ + (a: A2): (self: Chunk) => NonEmptyChunk; + /** + * Appends the specified element to the end of the `Chunk`. + * + * @category concatenating + * @since 2.0.0 + */ + (self: Chunk, a: A2): NonEmptyChunk; +}; +/** + * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prepend: { + /** + * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`. + * + * @category concatenating + * @since 2.0.0 + */ + (elem: B): (self: Chunk) => NonEmptyChunk; + /** + * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`. + * + * @category concatenating + * @since 2.0.0 + */ + (self: Chunk, elem: B): NonEmptyChunk; +}; +/** + * Takes the first up to `n` elements from the chunk + * + * @since 2.0.0 + */ +export declare const take: { + /** + * Takes the first up to `n` elements from the chunk + * + * @since 2.0.0 + */ + (n: number): (self: Chunk) => Chunk; + /** + * Takes the first up to `n` elements from the chunk + * + * @since 2.0.0 + */ + (self: Chunk, n: number): Chunk; +}; +/** + * Drops the first up to `n` elements from the chunk + * + * @since 2.0.0 + */ +export declare const drop: { + /** + * Drops the first up to `n` elements from the chunk + * + * @since 2.0.0 + */ + (n: number): (self: Chunk) => Chunk; + /** + * Drops the first up to `n` elements from the chunk + * + * @since 2.0.0 + */ + (self: Chunk, n: number): Chunk; +}; +/** + * Drops the last `n` elements. + * + * @since 2.0.0 + */ +export declare const dropRight: { + /** + * Drops the last `n` elements. + * + * @since 2.0.0 + */ + (n: number): (self: Chunk) => Chunk; + /** + * Drops the last `n` elements. + * + * @since 2.0.0 + */ + (self: Chunk, n: number): Chunk; +}; +/** + * Drops all elements so long as the predicate returns true. + * + * @since 2.0.0 + */ +export declare const dropWhile: { + /** + * Drops all elements so long as the predicate returns true. + * + * @since 2.0.0 + */ + (predicate: Predicate>): (self: Chunk) => Chunk; + /** + * Drops all elements so long as the predicate returns true. + * + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): Chunk; +}; +/** + * Prepends the specified prefix chunk to the beginning of the specified chunk. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ "a", "b", 1, 2 ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prependAll: { + /** + * Prepends the specified prefix chunk to the beginning of the specified chunk. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ "a", "b", 1, 2 ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + , T extends Chunk>(that: T): (self: S) => Chunk.OrNonEmpty | Chunk.Infer>; + /** + * Prepends the specified prefix chunk to the beginning of the specified chunk. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ "a", "b", 1, 2 ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Chunk, that: NonEmptyChunk): NonEmptyChunk; + /** + * Prepends the specified prefix chunk to the beginning of the specified chunk. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ "a", "b", 1, 2 ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: NonEmptyChunk, that: Chunk): NonEmptyChunk; + /** + * Prepends the specified prefix chunk to the beginning of the specified chunk. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ "a", "b", 1, 2 ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Chunk, that: Chunk): Chunk; +}; +/** + * Concatenates two chunks, combining their elements. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ 1, 2, "a", "b" ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const appendAll: { + /** + * Concatenates two chunks, combining their elements. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ 1, 2, "a", "b" ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + , T extends Chunk>(that: T): (self: S) => Chunk.OrNonEmpty | Chunk.Infer>; + /** + * Concatenates two chunks, combining their elements. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ 1, 2, "a", "b" ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Chunk, that: NonEmptyChunk): NonEmptyChunk; + /** + * Concatenates two chunks, combining their elements. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ 1, 2, "a", "b" ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: NonEmptyChunk, that: Chunk): NonEmptyChunk; + /** + * Concatenates two chunks, combining their elements. + * If either chunk is non-empty, the result is also a non-empty chunk. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray) + * + * console.log(result) + * // [ 1, 2, "a", "b" ] + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Chunk, that: Chunk): Chunk; +}; +/** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterMap: { + /** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ + (f: (a: A, i: number) => Option): (self: Chunk) => Chunk; + /** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ + (self: Chunk, f: (a: A, i: number) => Option): Chunk; +}; +/** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filter: { + /** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ + (refinement: Refinement, B>): (self: Chunk) => Chunk; + /** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ + (predicate: Predicate>): (self: Chunk) => Chunk; + /** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ + (self: Chunk, refinement: Refinement): Chunk; + /** + * Returns a filtered and mapped subset of the elements. + * + * @since 2.0.0 + * @category filtering + */ + (self: Chunk, predicate: Predicate): Chunk; +}; +/** + * Transforms all elements of the chunk for as long as the specified function returns some value + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterMapWhile: { + /** + * Transforms all elements of the chunk for as long as the specified function returns some value + * + * @since 2.0.0 + * @category filtering + */ + (f: (a: A) => Option): (self: Chunk) => Chunk; + /** + * Transforms all elements of the chunk for as long as the specified function returns some value + * + * @since 2.0.0 + * @category filtering + */ + (self: Chunk, f: (a: A) => Option): Chunk; +}; +/** + * Filter out optional values + * + * @since 2.0.0 + * @category filtering + */ +export declare const compact: (self: Chunk>) => Chunk; +/** + * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatMap: { + /** + * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ + , T extends Chunk>(f: (a: Chunk.Infer, i: number) => T): (self: S) => Chunk.AndNonEmpty>; + /** + * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ + (self: NonEmptyChunk, f: (a: A, i: number) => NonEmptyChunk): NonEmptyChunk; + /** + * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ + (self: Chunk, f: (a: A, i: number) => Chunk): Chunk; +}; +/** + * Iterates over each element of a `Chunk` and applies a function to it. + * + * **Details** + * + * This function processes every element of the given `Chunk`, calling the + * provided function `f` on each element. It does not return a new value; + * instead, it is primarily used for side effects, such as logging or + * accumulating data in an external variable. + * + * @since 2.0.0 + * @category combinators + */ +export declare const forEach: { + /** + * Iterates over each element of a `Chunk` and applies a function to it. + * + * **Details** + * + * This function processes every element of the given `Chunk`, calling the + * provided function `f` on each element. It does not return a new value; + * instead, it is primarily used for side effects, such as logging or + * accumulating data in an external variable. + * + * @since 2.0.0 + * @category combinators + */ + (f: (a: A, index: number) => B): (self: Chunk) => void; + /** + * Iterates over each element of a `Chunk` and applies a function to it. + * + * **Details** + * + * This function processes every element of the given `Chunk`, calling the + * provided function `f` on each element. It does not return a new value; + * instead, it is primarily used for side effects, such as logging or + * accumulating data in an external variable. + * + * @since 2.0.0 + * @category combinators + */ + (self: Chunk, f: (a: A, index: number) => B): void; +}; +/** + * Flattens a chunk of chunks into a single chunk by concatenating all chunks. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatten: >>(self: S) => Chunk.Flatten; +/** + * Groups elements in chunks of up to `n` elements. + * + * @since 2.0.0 + * @category elements + */ +export declare const chunksOf: { + /** + * Groups elements in chunks of up to `n` elements. + * + * @since 2.0.0 + * @category elements + */ + (n: number): (self: Chunk) => Chunk>; + /** + * Groups elements in chunks of up to `n` elements. + * + * @since 2.0.0 + * @category elements + */ + (self: Chunk, n: number): Chunk>; +}; +/** + * Creates a Chunk of unique values that are included in all given Chunks. + * + * The order and references of result values are determined by the Chunk. + * + * @since 2.0.0 + * @category elements + */ +export declare const intersection: { + /** + * Creates a Chunk of unique values that are included in all given Chunks. + * + * The order and references of result values are determined by the Chunk. + * + * @since 2.0.0 + * @category elements + */ + (that: Chunk): (self: Chunk) => Chunk; + /** + * Creates a Chunk of unique values that are included in all given Chunks. + * + * The order and references of result values are determined by the Chunk. + * + * @since 2.0.0 + * @category elements + */ + (self: Chunk, that: Chunk): Chunk; +}; +/** + * Determines if the chunk is empty. + * + * @since 2.0.0 + * @category elements + */ +export declare const isEmpty: (self: Chunk) => boolean; +/** + * Determines if the chunk is not empty. + * + * @since 2.0.0 + * @category elements + */ +export declare const isNonEmpty: (self: Chunk) => self is NonEmptyChunk; +/** + * Returns the first element of this chunk if it exists. + * + * @since 2.0.0 + * @category elements + */ +export declare const head: (self: Chunk) => Option; +/** + * Returns the first element of this chunk. + * + * It will throw an error if the chunk is empty. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeHead: (self: Chunk) => A; +/** + * Returns the first element of this non empty chunk. + * + * @since 2.0.0 + * @category elements + */ +export declare const headNonEmpty: (self: NonEmptyChunk) => A; +/** + * Returns the last element of this chunk if it exists. + * + * @since 2.0.0 + * @category elements + */ +export declare const last: (self: Chunk) => Option; +/** + * Returns the last element of this chunk. + * + * It will throw an error if the chunk is empty. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeLast: (self: Chunk) => A; +/** + * Returns the last element of this non empty chunk. + * + * @since 3.4.0 + * @category elements + */ +export declare const lastNonEmpty: (self: NonEmptyChunk) => A; +/** + * @since 2.0.0 + */ +export declare namespace Chunk { + /** + * @since 2.0.0 + */ + type Infer> = S extends Chunk ? A : never; + /** + * @since 2.0.0 + */ + type With, A> = S extends NonEmptyChunk ? NonEmptyChunk : Chunk; + /** + * @since 2.0.0 + */ + type OrNonEmpty, T extends Chunk, A> = S extends NonEmptyChunk ? NonEmptyChunk : T extends NonEmptyChunk ? NonEmptyChunk : Chunk; + /** + * @since 2.0.0 + */ + type AndNonEmpty, T extends Chunk, A> = S extends NonEmptyChunk ? T extends NonEmptyChunk ? NonEmptyChunk : Chunk : Chunk; + /** + * @since 2.0.0 + */ + type Flatten>> = T extends NonEmptyChunk> ? NonEmptyChunk : T extends Chunk> ? Chunk : never; +} +/** + * Transforms the elements of a chunk using the specified mapping function. + * If the input chunk is non-empty, the resulting chunk will also be non-empty. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1) + * + * console.log(result) + * // { _id: 'Chunk', values: [ 2, 3 ] } + * ``` + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Transforms the elements of a chunk using the specified mapping function. + * If the input chunk is non-empty, the resulting chunk will also be non-empty. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1) + * + * console.log(result) + * // { _id: 'Chunk', values: [ 2, 3 ] } + * ``` + * + * @since 2.0.0 + * @category mapping + */ + , B>(f: (a: Chunk.Infer, i: number) => B): (self: S) => Chunk.With; + /** + * Transforms the elements of a chunk using the specified mapping function. + * If the input chunk is non-empty, the resulting chunk will also be non-empty. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1) + * + * console.log(result) + * // { _id: 'Chunk', values: [ 2, 3 ] } + * ``` + * + * @since 2.0.0 + * @category mapping + */ + (self: NonEmptyChunk, f: (a: A, i: number) => B): NonEmptyChunk; + /** + * Transforms the elements of a chunk using the specified mapping function. + * If the input chunk is non-empty, the resulting chunk will also be non-empty. + * + * **Example** + * + * ```ts + * import { Chunk } from "effect" + * + * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1) + * + * console.log(result) + * // { _id: 'Chunk', values: [ 2, 3 ] } + * ``` + * + * @since 2.0.0 + * @category mapping + */ + (self: Chunk, f: (a: A, i: number) => B): Chunk; +}; +/** + * Statefully maps over the chunk, producing new elements of type `B`. + * + * @since 2.0.0 + * @category folding + */ +export declare const mapAccum: { + /** + * Statefully maps over the chunk, producing new elements of type `B`. + * + * @since 2.0.0 + * @category folding + */ + (s: S, f: (s: S, a: A) => readonly [S, B]): (self: Chunk) => [S, Chunk]; + /** + * Statefully maps over the chunk, producing new elements of type `B`. + * + * @since 2.0.0 + * @category folding + */ + (self: Chunk, s: S, f: (s: S, a: A) => readonly [S, B]): [S, Chunk]; +}; +/** + * Separate elements based on a predicate that also exposes the index of the element. + * + * @category filtering + * @since 2.0.0 + */ +export declare const partition: { + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * @category filtering + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Chunk) => [excluded: Chunk>, satisfying: Chunk]; + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * @category filtering + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Chunk) => [excluded: Chunk, satisfying: Chunk]; + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * @category filtering + * @since 2.0.0 + */ + (self: Chunk, refinement: (a: A, i: number) => a is B): [excluded: Chunk>, satisfying: Chunk]; + /** + * Separate elements based on a predicate that also exposes the index of the element. + * + * @category filtering + * @since 2.0.0 + */ + (self: Chunk, predicate: (a: A, i: number) => boolean): [excluded: Chunk, satisfying: Chunk]; +}; +/** + * Partitions the elements of this chunk into two chunks using f. + * + * @category filtering + * @since 2.0.0 + */ +export declare const partitionMap: { + /** + * Partitions the elements of this chunk into two chunks using f. + * + * @category filtering + * @since 2.0.0 + */ + (f: (a: A) => Either): (self: Chunk) => [left: Chunk, right: Chunk]; + /** + * Partitions the elements of this chunk into two chunks using f. + * + * @category filtering + * @since 2.0.0 + */ + (self: Chunk, f: (a: A) => Either): [left: Chunk, right: Chunk]; +}; +/** + * Partitions the elements of this chunk into two chunks. + * + * @category filtering + * @since 2.0.0 + */ +export declare const separate: (self: Chunk>) => [Chunk, Chunk]; +/** + * Retireves the size of the chunk + * + * @since 2.0.0 + * @category elements + */ +export declare const size: (self: Chunk) => number; +/** + * Sort the elements of a Chunk in increasing order, creating a new Chunk. + * + * @since 2.0.0 + * @category sorting + */ +export declare const sort: { + /** + * Sort the elements of a Chunk in increasing order, creating a new Chunk. + * + * @since 2.0.0 + * @category sorting + */ + (O: Order.Order): (self: Chunk) => Chunk; + /** + * Sort the elements of a Chunk in increasing order, creating a new Chunk. + * + * @since 2.0.0 + * @category sorting + */ + (self: Chunk, O: Order.Order): Chunk; +}; +/** + * @since 2.0.0 + * @category sorting + */ +export declare const sortWith: { + /** + * @since 2.0.0 + * @category sorting + */ + (f: (a: A) => B, order: Order.Order): (self: Chunk) => Chunk; + /** + * @since 2.0.0 + * @category sorting + */ + (self: Chunk, f: (a: A) => B, order: Order.Order): Chunk; +}; +/** + * Returns two splits of this chunk at the specified index. + * + * @since 2.0.0 + * @category splitting + */ +export declare const splitAt: { + /** + * Returns two splits of this chunk at the specified index. + * + * @since 2.0.0 + * @category splitting + */ + (n: number): (self: Chunk) => [beforeIndex: Chunk, fromIndex: Chunk]; + /** + * Returns two splits of this chunk at the specified index. + * + * @since 2.0.0 + * @category splitting + */ + (self: Chunk, n: number): [beforeIndex: Chunk, fromIndex: Chunk]; +}; +/** + * Splits a `NonEmptyChunk` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` must be `>= 1`. + * + * @category splitting + * @since 2.0.0 + */ +export declare const splitNonEmptyAt: { + /** + * Splits a `NonEmptyChunk` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` must be `>= 1`. + * + * @category splitting + * @since 2.0.0 + */ + (n: number): (self: NonEmptyChunk) => [beforeIndex: NonEmptyChunk, fromIndex: Chunk]; + /** + * Splits a `NonEmptyChunk` into two segments, with the first segment containing a maximum of `n` elements. + * The value of `n` must be `>= 1`. + * + * @category splitting + * @since 2.0.0 + */ + (self: NonEmptyChunk, n: number): [beforeIndex: NonEmptyChunk, fromIndex: Chunk]; +}; +/** + * Splits this chunk into `n` equally sized chunks. + * + * @since 2.0.0 + * @category splitting + */ +export declare const split: { + /** + * Splits this chunk into `n` equally sized chunks. + * + * @since 2.0.0 + * @category splitting + */ + (n: number): (self: Chunk) => Chunk>; + /** + * Splits this chunk into `n` equally sized chunks. + * + * @since 2.0.0 + * @category splitting + */ + (self: Chunk, n: number): Chunk>; +}; +/** + * Splits this chunk on the first element that matches this predicate. + * Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward. + * + * @category splitting + * @since 2.0.0 + */ +export declare const splitWhere: { + /** + * Splits this chunk on the first element that matches this predicate. + * Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward. + * + * @category splitting + * @since 2.0.0 + */ + (predicate: Predicate>): (self: Chunk) => [beforeMatch: Chunk, fromMatch: Chunk]; + /** + * Splits this chunk on the first element that matches this predicate. + * Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward. + * + * @category splitting + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): [beforeMatch: Chunk, fromMatch: Chunk]; +}; +/** + * Returns every elements after the first. + * + * @since 2.0.0 + * @category elements + */ +export declare const tail: (self: Chunk) => Option>; +/** + * Returns every elements after the first. + * + * @since 2.0.0 + * @category elements + */ +export declare const tailNonEmpty: (self: NonEmptyChunk) => Chunk; +/** + * Takes the last `n` elements. + * + * @since 2.0.0 + * @category elements + */ +export declare const takeRight: { + /** + * Takes the last `n` elements. + * + * @since 2.0.0 + * @category elements + */ + (n: number): (self: Chunk) => Chunk; + /** + * Takes the last `n` elements. + * + * @since 2.0.0 + * @category elements + */ + (self: Chunk, n: number): Chunk; +}; +/** + * Takes all elements so long as the predicate returns true. + * + * @since 2.0.0 + * @category elements + */ +export declare const takeWhile: { + /** + * Takes all elements so long as the predicate returns true. + * + * @since 2.0.0 + * @category elements + */ + (refinement: Refinement, B>): (self: Chunk) => Chunk; + /** + * Takes all elements so long as the predicate returns true. + * + * @since 2.0.0 + * @category elements + */ + (predicate: Predicate>): (self: Chunk) => Chunk; + /** + * Takes all elements so long as the predicate returns true. + * + * @since 2.0.0 + * @category elements + */ + (self: Chunk, refinement: Refinement): Chunk; + /** + * Takes all elements so long as the predicate returns true. + * + * @since 2.0.0 + * @category elements + */ + (self: Chunk, predicate: Predicate): Chunk; +}; +/** + * Creates a Chunks of unique values, in order, from all given Chunks. + * + * @since 2.0.0 + * @category elements + */ +export declare const union: { + /** + * Creates a Chunks of unique values, in order, from all given Chunks. + * + * @since 2.0.0 + * @category elements + */ + (that: Chunk): (self: Chunk) => Chunk; + /** + * Creates a Chunks of unique values, in order, from all given Chunks. + * + * @since 2.0.0 + * @category elements + */ + (self: Chunk, that: Chunk): Chunk; +}; +/** + * Remove duplicates from an array, keeping the first occurrence of an element. + * + * @since 2.0.0 + * @category elements + */ +export declare const dedupe: (self: Chunk) => Chunk; +/** + * Deduplicates adjacent elements that are identical. + * + * @since 2.0.0 + * @category filtering + */ +export declare const dedupeAdjacent: (self: Chunk) => Chunk; +/** + * Takes a `Chunk` of pairs and return two corresponding `Chunk`s. + * + * Note: The function is reverse of `zip`. + * + * @since 2.0.0 + * @category elements + */ +export declare const unzip: (self: Chunk) => [Chunk, Chunk]; +/** + * Zips this chunk pointwise with the specified chunk using the specified combiner. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipWith: { + /** + * Zips this chunk pointwise with the specified chunk using the specified combiner. + * + * @since 2.0.0 + * @category zipping + */ + (that: Chunk, f: (a: A, b: B) => C): (self: Chunk) => Chunk; + /** + * Zips this chunk pointwise with the specified chunk using the specified combiner. + * + * @since 2.0.0 + * @category zipping + */ + (self: Chunk, that: Chunk, f: (a: A, b: B) => C): Chunk; +}; +/** + * Zips this chunk pointwise with the specified chunk. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zip: { + /** + * Zips this chunk pointwise with the specified chunk. + * + * @since 2.0.0 + * @category zipping + */ + (that: Chunk): (self: Chunk) => Chunk<[A, B]>; + /** + * Zips this chunk pointwise with the specified chunk. + * + * @since 2.0.0 + * @category zipping + */ + (self: Chunk, that: Chunk): Chunk<[A, B]>; +}; +/** + * Delete the element at the specified index, creating a new `Chunk`. + * + * @since 2.0.0 + */ +export declare const remove: { + /** + * Delete the element at the specified index, creating a new `Chunk`. + * + * @since 2.0.0 + */ + (i: number): (self: Chunk) => Chunk; + /** + * Delete the element at the specified index, creating a new `Chunk`. + * + * @since 2.0.0 + */ + (self: Chunk, i: number): Chunk; +}; +/** + * @since 3.16.0 + */ +export declare const removeOption: { + /** + * @since 3.16.0 + */ + (i: number): (self: Chunk) => Option>; + /** + * @since 3.16.0 + */ + (self: Chunk, i: number): Option>; +}; +/** + * @since 2.0.0 + */ +export declare const modifyOption: { + /** + * @since 2.0.0 + */ + (i: number, f: (a: A) => B): (self: Chunk) => Option>; + /** + * @since 2.0.0 + */ + (self: Chunk, i: number, f: (a: A) => B): Option>; +}; +/** + * Apply a function to the element at the specified index, creating a new `Chunk`, + * or returning the input if the index is out of bounds. + * + * @since 2.0.0 + */ +export declare const modify: { + /** + * Apply a function to the element at the specified index, creating a new `Chunk`, + * or returning the input if the index is out of bounds. + * + * @since 2.0.0 + */ + (i: number, f: (a: A) => B): (self: Chunk) => Chunk; + /** + * Apply a function to the element at the specified index, creating a new `Chunk`, + * or returning the input if the index is out of bounds. + * + * @since 2.0.0 + */ + (self: Chunk, i: number, f: (a: A) => B): Chunk; +}; +/** + * Change the element at the specified index, creating a new `Chunk`, + * or returning the input if the index is out of bounds. + * + * @since 2.0.0 + */ +export declare const replace: { + /** + * Change the element at the specified index, creating a new `Chunk`, + * or returning the input if the index is out of bounds. + * + * @since 2.0.0 + */ + (i: number, b: B): (self: Chunk) => Chunk; + /** + * Change the element at the specified index, creating a new `Chunk`, + * or returning the input if the index is out of bounds. + * + * @since 2.0.0 + */ + (self: Chunk, i: number, b: B): Chunk; +}; +/** + * @since 2.0.0 + */ +export declare const replaceOption: { + /** + * @since 2.0.0 + */ + (i: number, b: B): (self: Chunk) => Option>; + /** + * @since 2.0.0 + */ + (self: Chunk, i: number, b: B): Option>; +}; +/** + * Return a Chunk of length n with element i initialized with f(i). + * + * **Note**. `n` is normalized to an integer >= 1. + * + * @category constructors + * @since 2.0.0 + */ +export declare const makeBy: { + /** + * Return a Chunk of length n with element i initialized with f(i). + * + * **Note**. `n` is normalized to an integer >= 1. + * + * @category constructors + * @since 2.0.0 + */ + (f: (i: number) => A): (n: number) => NonEmptyChunk; + /** + * Return a Chunk of length n with element i initialized with f(i). + * + * **Note**. `n` is normalized to an integer >= 1. + * + * @category constructors + * @since 2.0.0 + */ + (n: number, f: (i: number) => A): NonEmptyChunk; +}; +/** + * Create a non empty `Chunk` containing a range of integers, including both endpoints. + * + * @category constructors + * @since 2.0.0 + */ +export declare const range: (start: number, end: number) => NonEmptyChunk; +/** + * Returns a function that checks if a `Chunk` contains a given value using the default `Equivalence`. + * + * @category elements + * @since 2.0.0 + */ +export declare const contains: { + /** + * Returns a function that checks if a `Chunk` contains a given value using the default `Equivalence`. + * + * @category elements + * @since 2.0.0 + */ + (a: A): (self: Chunk) => boolean; + /** + * Returns a function that checks if a `Chunk` contains a given value using the default `Equivalence`. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, a: A): boolean; +}; +/** + * Returns a function that checks if a `Chunk` contains a given value using a provided `isEquivalent` function. + * + * @category elements + * @since 2.0.0 + */ +export declare const containsWith: (isEquivalent: (self: A, that: A) => boolean) => { + (a: A): (self: Chunk) => boolean; + (self: Chunk, a: A): boolean; +}; +/** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirst: { + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (refinement: Refinement, B>): (self: Chunk) => Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (predicate: Predicate>): (self: Chunk) => Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, refinement: Refinement): Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): Option; +}; +/** + * Return the first index for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirstIndex: { + /** + * Return the first index for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (predicate: Predicate): (self: Chunk) => Option; + /** + * Return the first index for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): Option; +}; +/** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ +export declare const findLast: { + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (refinement: Refinement, B>): (self: Chunk) => Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (predicate: Predicate>): (self: Chunk) => Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, refinement: Refinement): Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): Option; +}; +/** + * Return the last index for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ +export declare const findLastIndex: { + /** + * Return the last index for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (predicate: Predicate): (self: Chunk) => Option; + /** + * Return the last index for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): Option; +}; +/** + * Check if a predicate holds true for every `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ +export declare const every: { + /** + * Check if a predicate holds true for every `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ + (refinement: Refinement, B>): (self: Chunk) => self is Chunk; + /** + * Check if a predicate holds true for every `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ + (predicate: Predicate): (self: Chunk) => boolean; + /** + * Check if a predicate holds true for every `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, refinement: Refinement): self is Chunk; + /** + * Check if a predicate holds true for every `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): boolean; +}; +/** + * Check if a predicate holds true for some `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ +export declare const some: { + /** + * Check if a predicate holds true for some `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ + (predicate: Predicate>): (self: Chunk) => self is NonEmptyChunk; + /** + * Check if a predicate holds true for some `Chunk` element. + * + * @category elements + * @since 2.0.0 + */ + (self: Chunk, predicate: Predicate): self is NonEmptyChunk; +}; +/** + * Joins the elements together with "sep" in the middle. + * + * @category folding + * @since 2.0.0 + */ +export declare const join: { + /** + * Joins the elements together with "sep" in the middle. + * + * @category folding + * @since 2.0.0 + */ + (sep: string): (self: Chunk) => string; + /** + * Joins the elements together with "sep" in the middle. + * + * @category folding + * @since 2.0.0 + */ + (self: Chunk, sep: string): string; +}; +/** + * @category folding + * @since 2.0.0 + */ +export declare const reduce: { + /** + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A, i: number) => B): (self: Chunk) => B; + /** + * @category folding + * @since 2.0.0 + */ + (self: Chunk, b: B, f: (b: B, a: A, i: number) => B): B; +}; +/** + * @category folding + * @since 2.0.0 + */ +export declare const reduceRight: { + /** + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A, i: number) => B): (self: Chunk) => B; + /** + * @category folding + * @since 2.0.0 + */ + (self: Chunk, b: B, f: (b: B, a: A, i: number) => B): B; +}; +/** + * Creates a `Chunk` of values not included in the other given `Chunk` using the provided `isEquivalent` function. + * The order and references of result values are determined by the first `Chunk`. + * + * @since 3.2.0 + */ +export declare const differenceWith: (isEquivalent: (self: A, that: A) => boolean) => { + (that: Chunk): (self: Chunk) => Chunk; + (self: Chunk, that: Chunk): Chunk; +}; +/** + * Creates a `Chunk` of values not included in the other given `Chunk`. + * The order and references of result values are determined by the first `Chunk`. + * + * @since 3.2.0 + */ +export declare const difference: { + /** + * Creates a `Chunk` of values not included in the other given `Chunk`. + * The order and references of result values are determined by the first `Chunk`. + * + * @since 3.2.0 + */ + (that: Chunk): (self: Chunk) => Chunk; + /** + * Creates a `Chunk` of values not included in the other given `Chunk`. + * The order and references of result values are determined by the first `Chunk`. + * + * @since 3.2.0 + */ + (self: Chunk, that: Chunk): Chunk; +}; +export {}; +//# sourceMappingURL=Chunk.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Chunk.d.ts.map b/backend/node_modules/effect/dist/dts/Chunk.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..617252799df693060dec75fdf7055b914c15987f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Chunk.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Chunk.d.ts","sourceRoot":"","sources":["../../src/Chunk.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Clock.d.ts.map b/backend/node_modules/effect/dist/dts/Clock.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e66d7d0d2542266baa7a5ecc0dad2be78cfd04eb --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Clock.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Clock.d.ts","sourceRoot":"","sources":["../../src/Clock.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAI1C;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,MAA6B,CAAA;AAE9D;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAA;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,CAAC,WAAW,CAAC,EAAE,WAAW,CAAA;IACnC;;OAEG;IACH,uBAAuB,IAAI,MAAM,CAAA;IACjC;;OAEG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACjD;;OAEG;IACH,sBAAsB,IAAI,MAAM,CAAA;IAChC;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAChD;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CACxD;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,CAAA;AAEvC;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;AAE7B;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,GAAG,WAAW,CAAA;CACrE;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,KAAqB,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAyB,CAAA;AAErG;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAqC,CAAA;AAEzF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAoC,CAAA;AAEvF;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAC5E,CAAA;AAE3B;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAqB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Config.d.ts b/backend/node_modules/effect/dist/dts/Config.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2a2ad5ae9a710f5d67f617dbddf52a6bd8ce7ba0 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Config.d.ts @@ -0,0 +1,667 @@ +/** + * @since 2.0.0 + */ +import type * as Brand from "./Brand.js"; +import type * as Chunk from "./Chunk.js"; +import type * as ConfigError from "./ConfigError.js"; +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type { LazyArg } from "./Function.js"; +import type * as HashMap from "./HashMap.js"; +import type * as HashSet from "./HashSet.js"; +import type * as LogLevel from "./LogLevel.js"; +import type * as Option from "./Option.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import type * as Redacted from "./Redacted.js"; +import type * as Secret from "./Secret.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const ConfigTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ConfigTypeId = typeof ConfigTypeId; +/** + * A `Config` describes the structure of some configuration data. + * + * @since 2.0.0 + * @category models + */ +export interface Config extends Config.Variance, Effect.Effect { +} +/** + * @since 2.0.0 + */ +export declare namespace Config { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [ConfigTypeId]: { + readonly _A: Types.Covariant; + }; + } + /** + * @since 2.5.0 + * @category models + */ + type Success> = [T] extends [Config] ? _A : never; + /** + * @since 2.0.0 + * @category models + */ + interface Primitive extends Config { + readonly description: string; + parse(text: string): Either.Either; + } + /** + * Wraps a nested structure, converting all primitives to a `Config`. + * + * `Config.Wrap<{ key: string }>` becomes `{ key: Config }` + * + * To create the resulting config, use the `unwrap` constructor. + * + * @since 2.0.0 + * @category models + */ + type Wrap = [NonNullable] extends [infer T] ? [IsPlainObject] extends [true] ? { + readonly [K in keyof A]: Wrap; + } | Config : Config : Config; + type IsPlainObject = [A] extends [Record] ? [keyof A] extends [never] ? false : [keyof A] extends [string] ? true : false : false; +} +/** + * @since 2.0.0 + * @category models + */ +export type LiteralValue = string | number | boolean | null | bigint; +/** + * Constructs a config from a tuple / struct / arguments of configs. + * + * @since 2.0.0 + * @category constructors + */ +export declare const all: > | Record>>(arg: Arg) => Config<[ + Arg +] extends [ReadonlyArray>] ? { + -readonly [K in keyof Arg]: [Arg[K]] extends [Config] ? A : never; +} : [Arg] extends [Iterable>] ? Array : [Arg] extends [Record>] ? { + -readonly [K in keyof Arg]: [Arg[K]] extends [Config] ? A : never; +} : never>; +/** + * Constructs a config for an array of values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const array: (config: Config, name?: string) => Config>; +/** + * Constructs a config for a boolean value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const boolean: (name?: string) => Config; +/** + * Constructs a config for a network port [1, 65535]. + * + * @since 3.16.0 + * @category constructors + */ +export declare const port: (name?: string) => Config; +/** + * Constructs a config for an URL value. + * + * @since 3.11.0 + * @category constructors + */ +export declare const url: (name?: string) => Config; +/** + * Constructs a config for a sequence of values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const chunk: (config: Config, name?: string) => Config>; +/** + * Constructs a config for a date value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const date: (name?: string) => Config; +/** + * Constructs a config that fails with the specified message. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fail: (message: string) => Config; +/** + * Constructs a config for a float value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const number: (name?: string) => Config; +/** + * Constructs a config for a integer value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const integer: (name?: string) => Config; +/** + * Constructs a config for a literal value. + * + * **Example** + * + * ```ts + * import { Config } from "effect" + * + * const config = Config.literal("http", "https")("PROTOCOL") + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const literal: >(...literals: Literals) => (name?: string) => Config; +/** + * Constructs a config for a `LogLevel` value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const logLevel: (name?: string) => Config; +/** + * Constructs a config for a duration value. + * + * @since 2.5.0 + * @category constructors + */ +export declare const duration: (name?: string) => Config; +/** + * This function returns `true` if the specified value is an `Config` value, + * `false` otherwise. + * + * This function can be useful for checking the type of a value before + * attempting to operate on it as an `Config` value. For example, you could + * use `isConfig` to check the type of a value before using it as an + * argument to a function that expects an `Config` value. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isConfig: (u: unknown) => u is Config; +/** + * Returns a config whose structure is the same as this one, but which produces + * a different value, constructed using the specified function. + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Returns a config whose structure is the same as this one, but which produces + * a different value, constructed using the specified function. + * + * @since 2.0.0 + * @category mapping + */ + (f: (a: A) => B): (self: Config) => Config; + /** + * Returns a config whose structure is the same as this one, but which produces + * a different value, constructed using the specified function. + * + * @since 2.0.0 + * @category mapping + */ + (self: Config, f: (a: A) => B): Config; +}; +/** + * Returns a config whose structure is the same as this one, but which may + * produce a different value, constructed using the specified function, which + * may throw exceptions that will be translated into validation errors. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapAttempt: { + /** + * Returns a config whose structure is the same as this one, but which may + * produce a different value, constructed using the specified function, which + * may throw exceptions that will be translated into validation errors. + * + * @since 2.0.0 + * @category utils + */ + (f: (a: A) => B): (self: Config) => Config; + /** + * Returns a config whose structure is the same as this one, but which may + * produce a different value, constructed using the specified function, which + * may throw exceptions that will be translated into validation errors. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, f: (a: A) => B): Config; +}; +/** + * Returns a new config whose structure is the samea as this one, but which + * may produce a different value, constructed using the specified fallible + * function. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapOrFail: { + /** + * Returns a new config whose structure is the samea as this one, but which + * may produce a different value, constructed using the specified fallible + * function. + * + * @since 2.0.0 + * @category utils + */ + (f: (a: A) => Either.Either): (self: Config) => Config; + /** + * Returns a new config whose structure is the samea as this one, but which + * may produce a different value, constructed using the specified fallible + * function. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, f: (a: A) => Either.Either): Config; +}; +/** + * Returns a config that has this configuration nested as a property of the + * specified name. + * + * @since 2.0.0 + * @category utils + */ +export declare const nested: { + /** + * Returns a config that has this configuration nested as a property of the + * specified name. + * + * @since 2.0.0 + * @category utils + */ + (name: string): (self: Config) => Config; + /** + * Returns a config that has this configuration nested as a property of the + * specified name. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, name: string): Config; +}; +/** + * Returns a config whose structure is preferentially described by this + * config, but which falls back to the specified config if there is an issue + * reading from this config. + * + * @since 2.0.0 + * @category utils + */ +export declare const orElse: { + /** + * Returns a config whose structure is preferentially described by this + * config, but which falls back to the specified config if there is an issue + * reading from this config. + * + * @since 2.0.0 + * @category utils + */ + (that: LazyArg>): (self: Config) => Config; + /** + * Returns a config whose structure is preferentially described by this + * config, but which falls back to the specified config if there is an issue + * reading from this config. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, that: LazyArg>): Config; +}; +/** + * Returns configuration which reads from this configuration, but which falls + * back to the specified configuration if reading from this configuration + * fails with an error satisfying the specified predicate. + * + * @since 2.0.0 + * @category utils + */ +export declare const orElseIf: { + /** + * Returns configuration which reads from this configuration, but which falls + * back to the specified configuration if reading from this configuration + * fails with an error satisfying the specified predicate. + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly if: Predicate; + readonly orElse: LazyArg>; + }): (self: Config) => Config; + /** + * Returns configuration which reads from this configuration, but which falls + * back to the specified configuration if reading from this configuration + * fails with an error satisfying the specified predicate. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, options: { + readonly if: Predicate; + readonly orElse: LazyArg>; + }): Config; +}; +/** + * Returns an optional version of this config, which will be `None` if the + * data is missing from configuration, and `Some` otherwise. + * + * @since 2.0.0 + * @category utils + */ +export declare const option: (self: Config) => Config>; +/** + * Constructs a new primitive config. + * + * @since 2.0.0 + * @category constructors + */ +export declare const primitive: (description: string, parse: (text: string) => Either.Either) => Config; +/** + * Returns a config that describes a sequence of values, each of which has the + * structure of this config. + * + * @since 2.0.0 + * @category utils + */ +export declare const repeat: (self: Config) => Config>; +/** + * Constructs a config for a secret value. + * + * @since 2.0.0 + * @category constructors + * @deprecated + */ +export declare const secret: (name?: string) => Config; +/** + * Constructs a config for a redacted value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const redacted: { + /** + * Constructs a config for a redacted value. + * + * @since 2.0.0 + * @category constructors + */ + (name?: string): Config; + /** + * Constructs a config for a redacted value. + * + * @since 2.0.0 + * @category constructors + */ + (config: Config): Config>; +}; +/** + * Constructs a config for a branded value. + * + * @since 3.16.0 + * @category constructors + */ +export declare const branded: { + /** + * Constructs a config for a branded value. + * + * @since 3.16.0 + * @category constructors + */ + >(constructor: Brand.Brand.Constructor): (config: Config) => Config; + /** + * Constructs a config for a branded value. + * + * @since 3.16.0 + * @category constructors + */ + >(name: string | undefined, constructor: Brand.Brand.Constructor): Config; + /** + * Constructs a config for a branded value. + * + * @since 3.16.0 + * @category constructors + */ + >(config: Config, constructor: Brand.Brand.Constructor): Config; +}; +/** + * Constructs a config for a sequence of values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const hashSet: (config: Config, name?: string) => Config>; +/** + * Constructs a config for a string value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const string: (name?: string) => Config; +/** + * Constructs a config for a non-empty string value. + * + * @since 3.7.0 + * @category constructors + */ +export declare const nonEmptyString: (name?: string) => Config; +/** + * Constructs a config which contains the specified value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const succeed: (value: A) => Config; +/** + * Lazily constructs a config. + * + * @since 2.0.0 + * @category constructors + */ +export declare const suspend: (config: LazyArg>) => Config; +/** + * Constructs a config which contains the specified lazy value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const sync: (value: LazyArg) => Config; +/** + * Constructs a config for a sequence of values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const hashMap: (config: Config, name?: string) => Config>; +/** + * Constructs a config from some configuration wrapped with the `Wrap` utility type. + * + * For example: + * + * ``` + * import { Config, unwrap } from "./Config" + * + * interface Options { key: string } + * + * const makeConfig = (config: Config.Wrap): Config => unwrap(config) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const unwrap: (wrapped: Config.Wrap) => Config; +/** + * Returns a config that describes the same structure as this one, but which + * performs validation during loading. + * + * @since 2.0.0 + * @category utils + */ +export declare const validate: { + /** + * Returns a config that describes the same structure as this one, but which + * performs validation during loading. + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly message: string; + readonly validation: Refinement; + }): (self: Config) => Config; + /** + * Returns a config that describes the same structure as this one, but which + * performs validation during loading. + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly message: string; + readonly validation: Predicate; + }): (self: Config) => Config; + /** + * Returns a config that describes the same structure as this one, but which + * performs validation during loading. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, options: { + readonly message: string; + readonly validation: Refinement; + }): Config; + /** + * Returns a config that describes the same structure as this one, but which + * performs validation during loading. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, options: { + readonly message: string; + readonly validation: Predicate; + }): Config; +}; +/** + * Returns a config that describes the same structure as this one, but has the + * specified default value in case the information cannot be found. + * + * @since 2.0.0 + * @category utils + */ +export declare const withDefault: { + /** + * Returns a config that describes the same structure as this one, but has the + * specified default value in case the information cannot be found. + * + * @since 2.0.0 + * @category utils + */ + (def: A2): (self: Config) => Config; + /** + * Returns a config that describes the same structure as this one, but has the + * specified default value in case the information cannot be found. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, def: A2): Config; +}; +/** + * Adds a description to this configuration, which is intended for humans. + * + * @since 2.0.0 + * @category utils + */ +export declare const withDescription: { + /** + * Adds a description to this configuration, which is intended for humans. + * + * @since 2.0.0 + * @category utils + */ + (description: string): (self: Config) => Config; + /** + * Adds a description to this configuration, which is intended for humans. + * + * @since 2.0.0 + * @category utils + */ + (self: Config, description: string): Config; +}; +/** + * Returns a config that is the composition of this config and the specified + * config. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zip: { + /** + * Returns a config that is the composition of this config and the specified + * config. + * + * @since 2.0.0 + * @category zipping + */ + (that: Config): (self: Config) => Config<[A, B]>; + /** + * Returns a config that is the composition of this config and the specified + * config. + * + * @since 2.0.0 + * @category zipping + */ + (self: Config, that: Config): Config<[A, B]>; +}; +/** + * Returns a config that is the composes this config and the specified config + * using the provided function. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipWith: { + /** + * Returns a config that is the composes this config and the specified config + * using the provided function. + * + * @since 2.0.0 + * @category zipping + */ + (that: Config, f: (a: A, b: B) => C): (self: Config) => Config; + /** + * Returns a config that is the composes this config and the specified config + * using the provided function. + * + * @since 2.0.0 + * @category zipping + */ + (self: Config, that: Config, f: (a: A, b: B) => C): Config; +}; +//# sourceMappingURL=Config.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Config.d.ts.map b/backend/node_modules/effect/dist/dts/Config.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6272ab04eeed47fddc9cc5d1d661e91fdd18969f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Config.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/Config.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ConfigError.d.ts b/backend/node_modules/effect/dist/dts/ConfigError.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2f532ed6e132d6f5540bbb78330b1c9d624c765f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ConfigError.d.ts @@ -0,0 +1,238 @@ +/** + * @since 2.0.0 + */ +import type * as Cause from "./Cause.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const ConfigErrorTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ConfigErrorTypeId = typeof ConfigErrorTypeId; +/** + * The possible ways that loading configuration data may fail. + * + * @since 2.0.0 + * @category models + */ +export type ConfigError = And | Or | InvalidData | MissingData | SourceUnavailable | Unsupported; +/** + * @since 2.0.0 + */ +export declare namespace ConfigError { + /** + * @since 2.0.0 + * @category models + */ + interface Proto { + readonly _tag: "ConfigError"; + readonly [ConfigErrorTypeId]: ConfigErrorTypeId; + } + /** + * @since 2.0.0 + * @category models + */ + type Reducer = ConfigErrorReducer; +} +/** + * @since 2.0.0 + * @category models + */ +export interface ConfigErrorReducer { + andCase(context: C, left: Z, right: Z): Z; + orCase(context: C, left: Z, right: Z): Z; + invalidDataCase(context: C, path: Array, message: string): Z; + missingDataCase(context: C, path: Array, message: string): Z; + sourceUnavailableCase(context: C, path: Array, message: string, cause: Cause.Cause): Z; + unsupportedCase(context: C, path: Array, message: string): Z; +} +/** + * @since 2.0.0 + * @category models + */ +export interface And extends ConfigError.Proto { + readonly _op: "And"; + readonly left: ConfigError; + readonly right: ConfigError; + readonly message: string; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Or extends ConfigError.Proto { + readonly _op: "Or"; + readonly left: ConfigError; + readonly right: ConfigError; + readonly message: string; +} +/** + * @since 2.0.0 + * @category models + */ +export interface InvalidData extends ConfigError.Proto { + readonly _op: "InvalidData"; + readonly path: Array; + readonly message: string; +} +/** + * @since 2.0.0 + * @category models + */ +export interface MissingData extends ConfigError.Proto { + readonly _op: "MissingData"; + readonly path: Array; + readonly message: string; +} +/** + * @since 2.0.0 + * @category models + */ +export interface SourceUnavailable extends ConfigError.Proto { + readonly _op: "SourceUnavailable"; + readonly path: Array; + readonly message: string; + readonly cause: Cause.Cause; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Unsupported extends ConfigError.Proto { + readonly _op: "Unsupported"; + readonly path: Array; + readonly message: string; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Options { + readonly pathDelim: string; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const And: (self: ConfigError, that: ConfigError) => ConfigError; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Or: (self: ConfigError, that: ConfigError) => ConfigError; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const MissingData: (path: Array, message: string, options?: Options) => ConfigError; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const InvalidData: (path: Array, message: string, options?: Options) => ConfigError; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const SourceUnavailable: (path: Array, message: string, cause: Cause.Cause, options?: Options) => ConfigError; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Unsupported: (path: Array, message: string, options?: Options) => ConfigError; +/** + * Returns `true` if the specified value is a `ConfigError`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isConfigError: (u: unknown) => u is ConfigError; +/** + * Returns `true` if the specified `ConfigError` is an `And`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isAnd: (self: ConfigError) => self is And; +/** + * Returns `true` if the specified `ConfigError` is an `Or`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isOr: (self: ConfigError) => self is Or; +/** + * Returns `true` if the specified `ConfigError` is an `InvalidData`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isInvalidData: (self: ConfigError) => self is InvalidData; +/** + * Returns `true` if the specified `ConfigError` is an `MissingData`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isMissingData: (self: ConfigError) => self is MissingData; +/** + * Returns `true` if the specified `ConfigError` contains only `MissingData` errors, `false` otherwise. + * + * @since 2.0.0 + * @categer getters + */ +export declare const isMissingDataOnly: (self: ConfigError) => boolean; +/** + * Returns `true` if the specified `ConfigError` is a `SourceUnavailable`, + * `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isSourceUnavailable: (self: ConfigError) => self is SourceUnavailable; +/** + * Returns `true` if the specified `ConfigError` is an `Unsupported`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isUnsupported: (self: ConfigError) => self is Unsupported; +/** + * @since 2.0.0 + * @category utils + */ +export declare const prefixed: { + /** + * @since 2.0.0 + * @category utils + */ + (prefix: Array): (self: ConfigError) => ConfigError; + /** + * @since 2.0.0 + * @category utils + */ + (self: ConfigError, prefix: Array): ConfigError; +}; +/** + * @since 2.0.0 + * @category folding + */ +export declare const reduceWithContext: { + /** + * @since 2.0.0 + * @category folding + */ + (context: C, reducer: ConfigErrorReducer): (self: ConfigError) => Z; + /** + * @since 2.0.0 + * @category folding + */ + (self: ConfigError, context: C, reducer: ConfigErrorReducer): Z; +}; +//# sourceMappingURL=ConfigError.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ConfigProvider.d.ts b/backend/node_modules/effect/dist/dts/ConfigProvider.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5be2999d8e48fe0f86c2ca1767320d34cb70b17a --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ConfigProvider.d.ts @@ -0,0 +1,372 @@ +/** + * @since 2.0.0 + */ +import type * as Config from "./Config.js"; +import type * as ConfigError from "./ConfigError.js"; +import type * as PathPatch from "./ConfigProviderPathPatch.js"; +import type * as Context from "./Context.js"; +import type * as Effect from "./Effect.js"; +import type { LazyArg } from "./Function.js"; +import type * as HashSet from "./HashSet.js"; +import type { Pipeable } from "./Pipeable.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const ConfigProviderTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ConfigProviderTypeId = typeof ConfigProviderTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FlatConfigProviderTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FlatConfigProviderTypeId = typeof FlatConfigProviderTypeId; +/** + * A ConfigProvider is a service that provides configuration given a description + * of the structure of that configuration. + * + * @since 2.0.0 + * @category models + */ +export interface ConfigProvider extends ConfigProvider.Proto, Pipeable { + /** + * Loads the specified configuration, or fails with a config error. + */ + load(config: Config.Config): Effect.Effect; + /** + * Flattens this config provider into a simplified config provider that knows + * only how to deal with flat (key/value) properties. + */ + readonly flattened: ConfigProvider.Flat; +} +/** + * @since 2.0.0 + */ +export declare namespace ConfigProvider { + /** + * @since 2.0.0 + * @category models + */ + interface Proto { + readonly [ConfigProviderTypeId]: ConfigProviderTypeId; + } + /** + * A simplified config provider that knows only how to deal with flat + * (key/value) properties. Because these providers are common, there is + * special support for implementing them. + * + * @since 2.0.0 + * @category models + */ + interface Flat { + readonly [FlatConfigProviderTypeId]: FlatConfigProviderTypeId; + readonly patch: PathPatch.PathPatch; + load(path: ReadonlyArray, config: Config.Config.Primitive, split?: boolean): Effect.Effect, ConfigError.ConfigError>; + enumerateChildren(path: ReadonlyArray): Effect.Effect, ConfigError.ConfigError>; + } + /** + * @since 2.0.0 + * @category models + */ + interface FromMapConfig { + readonly pathDelim: string; + readonly seqDelim: string; + } + /** + * @since 2.0.0 + * @category models + */ + interface FromEnvConfig { + readonly pathDelim: string; + readonly seqDelim: string; + } + /** + * @since 1.0.0 + * @category models + */ + type KeyComponent = KeyName | KeyIndex; + /** + * @since 1.0.0 + * @category models + */ + interface KeyName { + readonly _tag: "KeyName"; + readonly name: string; + } + /** + * @since 1.0.0 + * @category models + */ + interface KeyIndex { + readonly _tag: "KeyIndex"; + readonly index: number; + } +} +/** + * The service tag for `ConfigProvider`. + * + * @since 2.0.0 + * @category context + */ +export declare const ConfigProvider: Context.Tag; +/** + * Creates a new config provider. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (options: { + readonly load: (config: Config.Config) => Effect.Effect; + readonly flattened: ConfigProvider.Flat; +}) => ConfigProvider; +/** + * Creates a new flat config provider. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeFlat: (options: { + readonly load: (path: ReadonlyArray, config: Config.Config.Primitive, split: boolean) => Effect.Effect, ConfigError.ConfigError>; + readonly enumerateChildren: (path: ReadonlyArray) => Effect.Effect, ConfigError.ConfigError>; + readonly patch: PathPatch.PathPatch; +}) => ConfigProvider.Flat; +/** + * A config provider that loads configuration from context variables + * + * **Options**: + * + * - `pathDelim`: The delimiter for the path segments (default: `"_"`). + * - `seqDelim`: The delimiter for the sequence of values (default: `","`). + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromEnv: (options?: Partial) => ConfigProvider; +/** + * Constructs a new `ConfigProvider` from a key/value (flat) provider, where + * nesting is embedded into the string keys. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromFlat: (flat: ConfigProvider.Flat) => ConfigProvider; +/** + * Constructs a new `ConfigProvider` from a JSON object. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromJson: (json: unknown) => ConfigProvider; +/** + * Constructs a ConfigProvider using a map and the specified delimiter string, + * which determines how to split the keys in the map into path segments. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromMap: (map: Map, config?: Partial) => ConfigProvider; +/** + * Returns a new config provider that will automatically convert all property + * names to constant case. This can be utilized to adapt the names of + * configuration properties from the default naming convention of camel case + * to the naming convention of a config provider. + * + * @since 2.0.0 + * @category combinators + */ +export declare const constantCase: (self: ConfigProvider) => ConfigProvider; +/** + * Returns a new config provider that will automatically tranform all path + * configuration names with the specified function. This can be utilized to + * adapt the names of configuration properties from one naming convention to + * another. + * + * @since 2.0.0 + * @category utils + */ +export declare const mapInputPath: { + /** + * Returns a new config provider that will automatically tranform all path + * configuration names with the specified function. This can be utilized to + * adapt the names of configuration properties from one naming convention to + * another. + * + * @since 2.0.0 + * @category utils + */ + (f: (path: string) => string): (self: ConfigProvider) => ConfigProvider; + /** + * Returns a new config provider that will automatically tranform all path + * configuration names with the specified function. This can be utilized to + * adapt the names of configuration properties from one naming convention to + * another. + * + * @since 2.0.0 + * @category utils + */ + (self: ConfigProvider, f: (path: string) => string): ConfigProvider; +}; +/** + * Returns a new config provider that will automatically convert all property + * names to kebab case. This can be utilized to adapt the names of + * configuration properties from the default naming convention of camel case + * to the naming convention of a config provider. + * + * @since 2.0.0 + * @category combinators + */ +export declare const kebabCase: (self: ConfigProvider) => ConfigProvider; +/** + * Returns a new config provider that will automatically convert all property + * names to lower case. This can be utilized to adapt the names of + * configuration properties from the default naming convention of camel case + * to the naming convention of a config provider. + * + * @since 2.0.0 + * @category combinators + */ +export declare const lowerCase: (self: ConfigProvider) => ConfigProvider; +/** + * Returns a new config provider that will automatically nest all + * configuration under the specified property name. This can be utilized to + * aggregate separate configuration sources that are all required to load a + * single configuration value. + * + * @since 2.0.0 + * @category utils + */ +export declare const nested: { + /** + * Returns a new config provider that will automatically nest all + * configuration under the specified property name. This can be utilized to + * aggregate separate configuration sources that are all required to load a + * single configuration value. + * + * @since 2.0.0 + * @category utils + */ + (name: string): (self: ConfigProvider) => ConfigProvider; + /** + * Returns a new config provider that will automatically nest all + * configuration under the specified property name. This can be utilized to + * aggregate separate configuration sources that are all required to load a + * single configuration value. + * + * @since 2.0.0 + * @category utils + */ + (self: ConfigProvider, name: string): ConfigProvider; +}; +/** + * Returns a new config provider that preferentially loads configuration data + * from this one, but which will fall back to the specified alternate provider + * if there are any issues loading the configuration from this provider. + * + * @since 2.0.0 + * @category utils + */ +export declare const orElse: { + /** + * Returns a new config provider that preferentially loads configuration data + * from this one, but which will fall back to the specified alternate provider + * if there are any issues loading the configuration from this provider. + * + * @since 2.0.0 + * @category utils + */ + (that: LazyArg): (self: ConfigProvider) => ConfigProvider; + /** + * Returns a new config provider that preferentially loads configuration data + * from this one, but which will fall back to the specified alternate provider + * if there are any issues loading the configuration from this provider. + * + * @since 2.0.0 + * @category utils + */ + (self: ConfigProvider, that: LazyArg): ConfigProvider; +}; +/** + * Returns a new config provider that will automatically un-nest all + * configuration under the specified property name. This can be utilized to + * de-aggregate separate configuration sources that are all required to load a + * single configuration value. + * + * @since 2.0.0 + * @category utils + */ +export declare const unnested: { + /** + * Returns a new config provider that will automatically un-nest all + * configuration under the specified property name. This can be utilized to + * de-aggregate separate configuration sources that are all required to load a + * single configuration value. + * + * @since 2.0.0 + * @category utils + */ + (name: string): (self: ConfigProvider) => ConfigProvider; + /** + * Returns a new config provider that will automatically un-nest all + * configuration under the specified property name. This can be utilized to + * de-aggregate separate configuration sources that are all required to load a + * single configuration value. + * + * @since 2.0.0 + * @category utils + */ + (self: ConfigProvider, name: string): ConfigProvider; +}; +/** + * Returns a new config provider that will automatically convert all property + * names to upper case. This can be utilized to adapt the names of + * configuration properties from the default naming convention of camel case + * to the naming convention of a config provider. + * + * @since 2.0.0 + * @category combinators + */ +export declare const snakeCase: (self: ConfigProvider) => ConfigProvider; +/** + * Returns a new config provider that will automatically convert all property + * names to upper case. This can be utilized to adapt the names of + * configuration properties from the default naming convention of camel case + * to the naming convention of a config provider. + * + * @since 2.0.0 + * @category combinators + */ +export declare const upperCase: (self: ConfigProvider) => ConfigProvider; +/** + * Returns a new config provider that transforms the config provider with the + * specified function within the specified path. + * + * @since 2.0.0 + * @category combinators + */ +export declare const within: { + /** + * Returns a new config provider that transforms the config provider with the + * specified function within the specified path. + * + * @since 2.0.0 + * @category combinators + */ + (path: ReadonlyArray, f: (self: ConfigProvider) => ConfigProvider): (self: ConfigProvider) => ConfigProvider; + /** + * Returns a new config provider that transforms the config provider with the + * specified function within the specified path. + * + * @since 2.0.0 + * @category combinators + */ + (self: ConfigProvider, path: ReadonlyArray, f: (self: ConfigProvider) => ConfigProvider): ConfigProvider; +}; +//# sourceMappingURL=ConfigProvider.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ConfigProvider.d.ts.map b/backend/node_modules/effect/dist/dts/ConfigProvider.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..ffd7bf7b89f40bb3ace063015998ea72163eebcf --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ConfigProvider.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ConfigProvider.d.ts","sourceRoot":"","sources":["../../src/ConfigProvider.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Console.d.ts b/backend/node_modules/effect/dist/dts/Console.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..60c94c0837d39d1d014735912d8ab374484e2321 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Console.d.ts @@ -0,0 +1,224 @@ +/** + * @since 2.0.0 + */ +import type * as Context from "./Context.js"; +import type { Effect } from "./Effect.js"; +import type * as Layer from "./Layer.js"; +import type { Scope } from "./Scope.js"; +/** + * @since 2.0.0 + * @category type ids + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category type ids + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category model + */ +export interface Console { + readonly [TypeId]: TypeId; + assert(condition: boolean, ...args: ReadonlyArray): Effect; + readonly clear: Effect; + count(label?: string): Effect; + countReset(label?: string): Effect; + debug(...args: ReadonlyArray): Effect; + dir(item: any, options?: any): Effect; + dirxml(...args: ReadonlyArray): Effect; + error(...args: ReadonlyArray): Effect; + group(options?: { + readonly label?: string | undefined; + readonly collapsed?: boolean | undefined; + }): Effect; + readonly groupEnd: Effect; + info(...args: ReadonlyArray): Effect; + log(...args: ReadonlyArray): Effect; + table(tabularData: any, properties?: ReadonlyArray): Effect; + time(label?: string): Effect; + timeEnd(label?: string): Effect; + timeLog(label?: string, ...args: ReadonlyArray): Effect; + trace(...args: ReadonlyArray): Effect; + warn(...args: ReadonlyArray): Effect; + readonly unsafe: UnsafeConsole; +} +/** + * @since 2.0.0 + * @category model + */ +export interface UnsafeConsole { + assert(condition: boolean, ...args: ReadonlyArray): void; + clear(): void; + count(label?: string): void; + countReset(label?: string): void; + debug(...args: ReadonlyArray): void; + dir(item: any, options?: any): void; + dirxml(...args: ReadonlyArray): void; + error(...args: ReadonlyArray): void; + group(...args: ReadonlyArray): void; + groupCollapsed(...args: ReadonlyArray): void; + groupEnd(): void; + info(...args: ReadonlyArray): void; + log(...args: ReadonlyArray): void; + table(tabularData: any, properties?: ReadonlyArray): void; + time(label?: string): void; + timeEnd(label?: string): void; + timeLog(label?: string, ...args: ReadonlyArray): void; + trace(...args: ReadonlyArray): void; + warn(...args: ReadonlyArray): void; +} +/** + * @since 2.0.0 + * @category context + */ +export declare const Console: Context.Tag; +/** + * @since 2.0.0 + * @category default services + */ +export declare const withConsole: { + /** + * @since 2.0.0 + * @category default services + */ + (console: C): (effect: Effect) => Effect; + /** + * @since 2.0.0 + * @category default services + */ + (effect: Effect, console: C): Effect; +}; +/** + * @since 2.0.0 + * @category default services + */ +export declare const setConsole: (console: A) => Layer.Layer; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const consoleWith: (f: (console: Console) => Effect) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const assert: (condition: boolean, ...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const clear: Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const count: (label?: string) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const countReset: (label?: string) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const debug: (...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const dir: (item: any, options?: any) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const dirxml: (...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const error: (...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const group: (options?: { + label?: string | undefined; + collapsed?: boolean | undefined; +} | undefined) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const info: (...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const log: (...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const table: (tabularData: any, properties?: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const time: (label?: string | undefined) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const timeLog: (label?: string, ...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const trace: (...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const warn: (...args: ReadonlyArray) => Effect; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const withGroup: { + /** + * @since 2.0.0 + * @category accessor + */ + (options?: { + readonly label?: string | undefined; + readonly collapsed?: boolean | undefined; + }): (self: Effect) => Effect; + /** + * @since 2.0.0 + * @category accessor + */ + (self: Effect, options?: { + readonly label?: string | undefined; + readonly collapsed?: boolean | undefined; + }): Effect; +}; +/** + * @since 2.0.0 + * @category accessor + */ +export declare const withTime: { + /** + * @since 2.0.0 + * @category accessor + */ + (label?: string): (self: Effect) => Effect; + /** + * @since 2.0.0 + * @category accessor + */ + (self: Effect, label?: string): Effect; +}; +//# sourceMappingURL=Console.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Console.d.ts.map b/backend/node_modules/effect/dist/dts/Console.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..5da7c192199689d0949dbbef09cbc084b9ca458c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Console.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Console.d.ts","sourceRoot":"","sources":["../../src/Console.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGzC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,MAA8B,CAAA;AAE1D;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAA;AAElC;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACzB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IACrE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;IAC5B,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IACnC,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IACxC,KAAK,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAChD,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAC3C,MAAM,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IACjD,KAAK,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAChD,KAAK,CAAC,OAAO,CAAC,EAAE;QACd,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACzC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAChB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;IAC/B,IAAI,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAC/C,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAC9C,KAAK,CAAC,WAAW,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IACzE,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAClC,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IACrC,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAClE,KAAK,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAChD,IAAI,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAC/C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IAC7D,KAAK,IAAI,IAAI,CAAA;IACb,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,KAAK,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACxC,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;IACnC,MAAM,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACzC,KAAK,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACxC,KAAK,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACxC,cAAc,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACjD,QAAQ,IAAI,IAAI,CAAA;IAChB,IAAI,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACvC,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACtC,KAAK,CAAC,WAAW,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,CAAA;IACjE,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IAC1D,KAAK,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACxC,IAAI,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;CACxC;AAED;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAA6B,CAAA;AAE/E;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;OAGG;IACH,CAAC,CAAC,SAAS,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IACtF;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAC5D,CAAA;AAExB;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,SAAS,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,KAAK,CAAuB,CAAA;AAEpG;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAwB,CAAA;AAEvH;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAmB,CAAA;AAExG;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,IAAI,CAAkB,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,IAAI,CAAkB,CAAA;AAErE;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,IAAI,CAAuB,CAAA;AAE/E;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAkB,CAAA;AAElF;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,MAAM,CAAC,IAAI,CAAgB,CAAA;AAE3E;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAmB,CAAA;AAEpF;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAkB,CAAA;AAElF;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAClB,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,KAClF,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAkB,CAAA;AAEhD;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAiB,CAAA;AAEhF;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAgB,CAAA;AAE9E;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,WAAW,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,IAAI,CAAkB,CAAA;AAE3G;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAiB,CAAA;AAE7F;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAoB,CAAA;AAEtG;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAkB,CAAA;AAElF;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAiB,CAAA;AAEhF;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;OAGG;IACH,CACC,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACzC,GACC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IACtD;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACrB,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACzC,GACC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACE,CAAA;AAEtB;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;OAGG;IACH,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IACrE;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAC9C,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Context.d.ts b/backend/node_modules/effect/dist/dts/Context.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0ae6d343e9bc61a37561a611fa0efd555b01e750 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Context.d.ts @@ -0,0 +1,823 @@ +/** + * This module provides a data structure called `Context` that can be used for dependency injection in effectful + * programs. It is essentially a table mapping `Tag`s to their implementations (called `Service`s), and can be used to + * manage dependencies in a type-safe way. The `Context` data structure is essentially a way of providing access to a set + * of related services that can be passed around as a single unit. This module provides functions to create, modify, and + * query the contents of a `Context`, as well as a number of utility types for working with tags and services. + * + * @since 2.0.0 + */ +import type * as Effect from "./Effect.js"; +import type { Equal } from "./Equal.js"; +import type { LazyArg } from "./Function.js"; +import type { Inspectable } from "./Inspectable.js"; +import type { Option } from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 2.0.0 + * @category symbol + */ +export declare const TagTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TagTypeId = typeof TagTypeId; +/** + * @since 3.5.9 + * @category models + */ +export interface Tag extends Pipeable, Inspectable, ReadonlyTag { + readonly _op: "Tag"; + readonly Service: Value; + readonly Identifier: Id; + readonly [TagTypeId]: { + readonly _Service: Types.Invariant; + readonly _Identifier: Types.Invariant; + }; + of(self: Value): Value; + context(self: Value): Context; + readonly stack?: string | undefined; + readonly key: string; + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: TagUnify; + [Unify.ignoreSymbol]?: TagUnifyIgnore; +} +/** + * @since 3.5.9 + * @category models + */ +export interface ReadonlyTag extends Pipeable, Inspectable, Effect.Effect { + readonly _op: "Tag"; + readonly Service: Value; + readonly Identifier: Id; + readonly [TagTypeId]: { + readonly _Service: Types.Covariant; + readonly _Identifier: Types.Invariant; + }; + readonly stack?: string | undefined; + readonly key: string; +} +/** + * @since 3.11.0 + * @category symbol + */ +export declare const ReferenceTypeId: unique symbol; +/** + * @since 3.11.0 + * @category symbol + */ +export type ReferenceTypeId = typeof ReferenceTypeId; +/** + * @since 3.11.0 + * @category models + */ +export interface Reference extends Pipeable, Inspectable { + readonly [ReferenceTypeId]: ReferenceTypeId; + readonly defaultValue: () => Value; + readonly _op: "Tag"; + readonly Service: Value; + readonly Identifier: Id; + readonly [TagTypeId]: { + readonly _Service: Types.Invariant; + readonly _Identifier: Types.Invariant; + }; + of(self: Value): Value; + context(self: Value): Context; + readonly stack?: string | undefined; + readonly key: string; + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: TagUnify; + [Unify.ignoreSymbol]?: TagUnifyIgnore; +} +/** + * @since 2.0.0 + * @category models + */ +export interface TagClassShape { + readonly [TagTypeId]: TagTypeId; + readonly Type: Shape; + readonly Id: Id; +} +/** + * @since 2.0.0 + * @category models + */ +export interface TagClass extends Tag { + new (_: never): TagClassShape; + readonly key: Id; +} +/** + * @since 3.11.0 + * @category models + */ +export interface ReferenceClass extends Reference { + new (_: never): TagClassShape; + readonly key: Id; +} +/** + * @category models + * @since 2.0.0 + */ +export interface TagUnify { + Tag?: () => Extract>; +} +/** + * @category models + * @since 2.0.0 + */ +export interface TagUnifyIgnore { +} +/** + * @since 2.0.0 + */ +export declare namespace Tag { + /** + * @since 2.0.0 + */ + type Service | TagClassShape> = T extends Tag ? T["Service"] : T extends TagClassShape ? A : never; + /** + * @since 2.0.0 + */ + type Identifier | TagClassShape> = T extends Tag ? T["Identifier"] : T extends TagClassShape ? T : never; +} +/** + * Creates a new `Tag` instance with an optional key parameter. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * assert.strictEqual(Context.GenericTag("PORT").key === Context.GenericTag("PORT").key, true) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const GenericTag: (key: string) => Tag; +declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export type ValidTagsById = R extends infer S ? Tag : never; +/** + * @since 2.0.0 + * @category models + */ +export interface Context extends Equal, Pipeable, Inspectable { + readonly [TypeId]: { + readonly _Services: Types.Contravariant; + }; + readonly unsafeMap: Map; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeMake: (unsafeMap: Map) => Context; +/** + * Checks if the provided argument is a `Context`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * assert.strictEqual(Context.isContext(Context.empty()), true) + * ``` + * + * @since 2.0.0 + * @category guards + */ +export declare const isContext: (input: unknown) => input is Context; +/** + * Checks if the provided argument is a `Tag`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * assert.strictEqual(Context.isTag(Context.GenericTag("Tag")), true) + * ``` + * + * @since 2.0.0 + * @category guards + */ +export declare const isTag: (input: unknown) => input is Tag; +/** + * Checks if the provided argument is a `Reference`. + * + * @since 3.11.0 + * @category guards + * @experimental + */ +export declare const isReference: (u: unknown) => u is Reference; +/** + * Returns an empty `Context`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * assert.strictEqual(Context.isContext(Context.empty()), true) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const empty: () => Context; +/** + * Creates a new `Context` with a single service associated to the tag. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * + * const Services = Context.make(Port, { PORT: 8080 }) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (tag: Tag, service: Types.NoInfer) => Context; +/** + * Adds a service to a given `Context`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context, pipe } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const someContext = Context.make(Port, { PORT: 8080 }) + * + * const Services = pipe( + * someContext, + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + */ +export declare const add: { + /** + * Adds a service to a given `Context`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context, pipe } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const someContext = Context.make(Port, { PORT: 8080 }) + * + * const Services = pipe( + * someContext, + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + */ + (tag: Tag, service: Types.NoInfer): (self: Context) => Context; + /** + * Adds a service to a given `Context`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context, pipe } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const someContext = Context.make(Port, { PORT: 8080 }) + * + * const Services = pipe( + * someContext, + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + */ + (self: Context, tag: Tag, service: Types.NoInfer): Context; +}; +/** + * Get a service from the context that corresponds to the given tag. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = pipe( + * Context.make(Port, { PORT: 8080 }), + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + * @category getters + */ +export declare const get: { + /** + * Get a service from the context that corresponds to the given tag. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = pipe( + * Context.make(Port, { PORT: 8080 }), + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + * @category getters + */ + (tag: Reference): (self: Context) => S; + /** + * Get a service from the context that corresponds to the given tag. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = pipe( + * Context.make(Port, { PORT: 8080 }), + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + * @category getters + */ + (tag: Tag): (self: Context) => S; + /** + * Get a service from the context that corresponds to the given tag. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = pipe( + * Context.make(Port, { PORT: 8080 }), + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + * @category getters + */ + (self: Context, tag: Reference): S; + /** + * Get a service from the context that corresponds to the given tag. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = pipe( + * Context.make(Port, { PORT: 8080 }), + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + * @category getters + */ + (self: Context, tag: Tag): S; +}; +/** + * Get a service from the context that corresponds to the given tag, or + * use the fallback value. + * + * @since 3.7.0 + * @category getters + */ +export declare const getOrElse: { + /** + * Get a service from the context that corresponds to the given tag, or + * use the fallback value. + * + * @since 3.7.0 + * @category getters + */ + (tag: Tag, orElse: LazyArg): (self: Context) => S | B; + /** + * Get a service from the context that corresponds to the given tag, or + * use the fallback value. + * + * @since 3.7.0 + * @category getters + */ + (self: Context, tag: Tag, orElse: LazyArg): S | B; +}; +/** + * Get a service from the context that corresponds to the given tag. + * This function is unsafe because if the tag is not present in the context, a runtime error will be thrown. + * + * For a safer version see {@link getOption}. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = Context.make(Port, { PORT: 8080 }) + * + * assert.deepStrictEqual(Context.unsafeGet(Services, Port), { PORT: 8080 }) + * assert.throws(() => Context.unsafeGet(Services, Timeout)) + * ``` + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeGet: { + /** + * Get a service from the context that corresponds to the given tag. + * This function is unsafe because if the tag is not present in the context, a runtime error will be thrown. + * + * For a safer version see {@link getOption}. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = Context.make(Port, { PORT: 8080 }) + * + * assert.deepStrictEqual(Context.unsafeGet(Services, Port), { PORT: 8080 }) + * assert.throws(() => Context.unsafeGet(Services, Timeout)) + * ``` + * + * @since 2.0.0 + * @category unsafe + */ + (tag: Tag): (self: Context) => S; + /** + * Get a service from the context that corresponds to the given tag. + * This function is unsafe because if the tag is not present in the context, a runtime error will be thrown. + * + * For a safer version see {@link getOption}. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = Context.make(Port, { PORT: 8080 }) + * + * assert.deepStrictEqual(Context.unsafeGet(Services, Port), { PORT: 8080 }) + * assert.throws(() => Context.unsafeGet(Services, Timeout)) + * ``` + * + * @since 2.0.0 + * @category unsafe + */ + (self: Context, tag: Tag): S; +}; +/** + * Get the value associated with the specified tag from the context wrapped in an `Option` object. If the tag is not + * found, the `Option` object will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context, Option } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = Context.make(Port, { PORT: 8080 }) + * + * assert.deepStrictEqual(Context.getOption(Services, Port), Option.some({ PORT: 8080 })) + * assert.deepStrictEqual(Context.getOption(Services, Timeout), Option.none()) + * ``` + * + * @since 2.0.0 + * @category getters + */ +export declare const getOption: { + /** + * Get the value associated with the specified tag from the context wrapped in an `Option` object. If the tag is not + * found, the `Option` object will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context, Option } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = Context.make(Port, { PORT: 8080 }) + * + * assert.deepStrictEqual(Context.getOption(Services, Port), Option.some({ PORT: 8080 })) + * assert.deepStrictEqual(Context.getOption(Services, Timeout), Option.none()) + * ``` + * + * @since 2.0.0 + * @category getters + */ + (tag: Tag): (self: Context) => Option; + /** + * Get the value associated with the specified tag from the context wrapped in an `Option` object. If the tag is not + * found, the `Option` object will be `None`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context, Option } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const Services = Context.make(Port, { PORT: 8080 }) + * + * assert.deepStrictEqual(Context.getOption(Services, Port), Option.some({ PORT: 8080 })) + * assert.deepStrictEqual(Context.getOption(Services, Timeout), Option.none()) + * ``` + * + * @since 2.0.0 + * @category getters + */ + (self: Context, tag: Tag): Option; +}; +/** + * Merges two `Context`s, returning a new `Context` containing the services of both. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const firstContext = Context.make(Port, { PORT: 8080 }) + * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 }) + * + * const Services = Context.merge(firstContext, secondContext) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + */ +export declare const merge: { + /** + * Merges two `Context`s, returning a new `Context` containing the services of both. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const firstContext = Context.make(Port, { PORT: 8080 }) + * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 }) + * + * const Services = Context.merge(firstContext, secondContext) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + */ + (that: Context): (self: Context) => Context; + /** + * Merges two `Context`s, returning a new `Context` containing the services of both. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const firstContext = Context.make(Port, { PORT: 8080 }) + * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 }) + * + * const Services = Context.merge(firstContext, secondContext) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * ``` + * + * @since 2.0.0 + */ + (self: Context, that: Context): Context; +}; +/** + * Merges any number of `Context`s, returning a new `Context` containing the services of all. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * const Host = Context.GenericTag<{ HOST: string }>("Host") + * + * const firstContext = Context.make(Port, { PORT: 8080 }) + * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 }) + * const thirdContext = Context.make(Host, { HOST: "localhost" }) + * + * const Services = Context.mergeAll(firstContext, secondContext, thirdContext) + * + * assert.deepStrictEqual(Context.get(Services, Port), { PORT: 8080 }) + * assert.deepStrictEqual(Context.get(Services, Timeout), { TIMEOUT: 5000 }) + * assert.deepStrictEqual(Context.get(Services, Host), { HOST: "localhost" }) + * ``` + * + * @since 3.12.0 + */ +export declare const mergeAll: >(...ctxs: [...{ + [K in keyof T]: Context; +}]) => Context; +/** + * Returns a new `Context` that contains only the specified services. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Context, Option } from "effect" + * + * const Port = Context.GenericTag<{ PORT: number }>("Port") + * const Timeout = Context.GenericTag<{ TIMEOUT: number }>("Timeout") + * + * const someContext = pipe( + * Context.make(Port, { PORT: 8080 }), + * Context.add(Timeout, { TIMEOUT: 5000 }) + * ) + * + * const Services = pipe(someContext, Context.pick(Port)) + * + * assert.deepStrictEqual(Context.getOption(Services, Port), Option.some({ PORT: 8080 })) + * assert.deepStrictEqual(Context.getOption(Services, Timeout), Option.none()) + * ``` + * + * @since 2.0.0 + */ +export declare const pick: >>(...tags: Tags) => (self: Context) => Context>; +/** + * @since 2.0.0 + */ +export declare const omit: >>(...tags: Tags) => (self: Context) => Context>>; +/** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Context, Layer } from "effect" + * + * class MyTag extends Context.Tag("MyTag")< + * MyTag, + * { readonly myNum: number } + * >() { + * static Live = Layer.succeed(this, { myNum: 108 }) + * } + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const Tag: (id: Id) => () => TagClass; +/** + * Creates a context tag with a default value. + * + * **Details** + * + * `Context.Reference` allows you to create a tag that can hold a value. You can + * provide a default value for the service, which will automatically be used + * when the context is accessed, or override it with a custom implementation + * when needed. + * + * **Example** (Declaring a Tag with a default value) + * + * ```ts + * import * as assert from "node:assert" + * import { Context, Effect } from "effect" + * + * class SpecialNumber extends Context.Reference()( + * "SpecialNumber", + * { defaultValue: () => 2048 } + * ) {} + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const specialNumber = yield* SpecialNumber + * console.log(`The special number is ${specialNumber}`) + * }) + * + * // No need to provide the SpecialNumber implementation + * Effect.runPromise(program) + * // Output: The special number is 2048 + * ``` + * + * **Example** (Overriding the default value) + * + * ```ts + * import { Context, Effect } from "effect" + * + * class SpecialNumber extends Context.Reference()( + * "SpecialNumber", + * { defaultValue: () => 2048 } + * ) {} + * + * const program = Effect.gen(function* () { + * const specialNumber = yield* SpecialNumber + * console.log(`The special number is ${specialNumber}`) + * }) + * + * Effect.runPromise(program.pipe(Effect.provideService(SpecialNumber, -1))) + * // Output: The special number is -1 + * ``` + * + * @since 3.11.0 + * @category constructors + * @experimental + */ +export declare const Reference: () => (id: Id, options: { + readonly defaultValue: () => Service; +}) => ReferenceClass; +export {}; +//# sourceMappingURL=Context.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Cron.d.ts b/backend/node_modules/effect/dist/dts/Cron.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..68b490259ef807877cc611f334f1190fe4672e8c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Cron.d.ts @@ -0,0 +1,254 @@ +import type * as DateTime from "./DateTime.js"; +import * as Either from "./Either.js"; +import * as Equal from "./Equal.js"; +import * as equivalence from "./Equivalence.js"; +import { type Inspectable } from "./Inspectable.js"; +import * as Option from "./Option.js"; +import { type Pipeable } from "./Pipeable.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface Cron extends Pipeable, Equal.Equal, Inspectable { + readonly [TypeId]: TypeId; + readonly tz: Option.Option; + readonly seconds: ReadonlySet; + readonly minutes: ReadonlySet; + readonly hours: ReadonlySet; + readonly days: ReadonlySet; + readonly months: ReadonlySet; + readonly weekdays: ReadonlySet; +} +/** + * Checks if a given value is a `Cron` instance. + * + * @since 2.0.0 + * @category guards + */ +export declare const isCron: (u: unknown) => u is Cron; +/** + * Creates a `Cron` instance. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (values: { + readonly seconds?: Iterable | undefined; + readonly minutes: Iterable; + readonly hours: Iterable; + readonly days: Iterable; + readonly months: Iterable; + readonly weekdays: Iterable; + readonly tz?: DateTime.TimeZone | undefined; +}) => Cron; +/** + * @since 2.0.0 + * @category symbol + */ +export declare const ParseErrorTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ParseErrorTypeId = typeof ParseErrorTypeId; +declare const ParseError_base: new = {}>(args: import("./Types.js").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("./Cause.js").YieldableError & { + readonly _tag: "CronParseError"; +} & Readonly; +/** + * Represents a checked exception which occurs when decoding fails. + * + * @since 2.0.0 + * @category models + */ +export declare class ParseError extends ParseError_base<{ + readonly message: string; + readonly input?: string; +}> { + /** + * @since 2.0.0 + */ + readonly [ParseErrorTypeId]: symbol; +} +/** + * Returns `true` if the specified value is an `ParseError`, `false` otherwise. + * + * @since 2.0.0 + * @category guards + */ +export declare const isParseError: (u: unknown) => u is ParseError; +/** + * Parses a cron expression into a `Cron` instance. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Cron, Either } from "effect" + * + * // At 04:00 on every day-of-month from 8 through 14. + * assert.deepStrictEqual(Cron.parse("0 0 4 8-14 * *"), Either.right(Cron.make({ + * seconds: [0], + * minutes: [0], + * hours: [4], + * days: [8, 9, 10, 11, 12, 13, 14], + * months: [], + * weekdays: [] + * }))) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const parse: (cron: string, tz?: DateTime.TimeZone | string) => Either.Either; +/** + * Parses a cron expression into a `Cron` instance. + * + * **Details** + * + * This function takes a cron expression as a string and attempts to parse it + * into a `Cron` instance. If the expression is valid, the resulting `Cron` + * instance will represent the schedule defined by the cron expression. + * + * If the expression is invalid, the function throws a `ParseError`. + * + * You can optionally provide a time zone (`tz`) to interpret the cron + * expression in a specific time zone. If no time zone is provided, the cron + * expression will use the default time zone. + * + * @example + * ```ts + * import { Cron } from "effect" + * + * // At 04:00 on every day-of-month from 8 through 14. + * console.log(Cron.unsafeParse("0 4 8-14 * *")) + * // Output: + * // { + * // _id: 'Cron', + * // tz: { _id: 'Option', _tag: 'None' }, + * // seconds: [ 0 ], + * // minutes: [ 0 ], + * // hours: [ 4 ], + * // days: [ + * // 8, 9, 10, 11, + * // 12, 13, 14 + * // ], + * // months: [], + * // weekdays: [] + * // } + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeParse: (cron: string, tz?: DateTime.TimeZone | string) => Cron; +/** + * Checks if a given `Date` falls within an active `Cron` time window. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Cron, Either } from "effect" + * + * const cron = Either.getOrThrow(Cron.parse("0 4 8-14 * *")) + * assert.deepStrictEqual(Cron.match(cron, new Date("2021-01-08 04:00:00")), true) + * assert.deepStrictEqual(Cron.match(cron, new Date("2021-01-08 05:00:00")), false) + * ``` + * + * @throws `IllegalArgumentException` if the given `DateTime.Input` is invalid. + * + * @since 2.0.0 + */ +export declare const match: (cron: Cron, date: DateTime.DateTime.Input) => boolean; +/** + * Returns the next run `Date` for the given `Cron` instance. + * + * Uses the current time as a starting point if no value is provided for `startFrom`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Cron, Either } from "effect" + * + * const after = new Date("2021-01-01 00:00:00") + * const cron = Either.getOrThrow(Cron.parse("0 4 8-14 * *")) + * assert.deepStrictEqual(Cron.next(cron, after), new Date("2021-01-08 04:00:00")) + * ``` + * + * @throws `IllegalArgumentException` if the given `DateTime.Input` is invalid. + * @throws `Error` if the next run date cannot be found within 10,000 iterations. + * + * @since 2.0.0 + */ +export declare const next: (cron: Cron, startFrom?: DateTime.DateTime.Input) => Date; +/** + * Returns the previous run `Date` for the given `Cron` instance. + * + * Uses the current time as a starting point if no value is provided for `startFrom`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Cron, Either } from "effect" + * + * const before = new Date("2021-01-15 00:00:00") + * const cron = Either.getOrThrow(Cron.parse("0 4 8-14 * *")) + * assert.deepStrictEqual(Cron.prev(cron, before), new Date("2021-01-14 04:00:00")) + * ``` + * + * @throws `IllegalArgumentException` if the given `DateTime.Input` is invalid. + * @throws `Error` if the previous run date cannot be found within 10,000 iterations. + * + * @since 3.20.0 + */ +export declare const prev: (cron: Cron, startFrom?: DateTime.DateTime.Input) => Date; +/** + * Returns an `IterableIterator` which yields the sequence of `Date`s that match the `Cron` instance. + * + * @since 2.0.0 + */ +export declare const sequence: (cron: Cron, startFrom?: DateTime.DateTime.Input) => IterableIterator; +/** + * Returns an `IterableIterator` which yields the sequence of `Date`s that match the `Cron` instance, + * in reverse direction. + * + * @since 3.20.0 + */ +export declare const sequenceReverse: (cron: Cron, startFrom?: DateTime.DateTime.Input) => IterableIterator; +/** + * @category instances + * @since 2.0.0 + */ +export declare const Equivalence: equivalence.Equivalence; +/** + * Checks if two `Cron`s are equal. + * + * @since 2.0.0 + * @category predicates + */ +export declare const equals: { + /** + * Checks if two `Cron`s are equal. + * + * @since 2.0.0 + * @category predicates + */ + (that: Cron): (self: Cron) => boolean; + /** + * Checks if two `Cron`s are equal. + * + * @since 2.0.0 + * @category predicates + */ + (self: Cron, that: Cron): boolean; +}; +export {}; +//# sourceMappingURL=Cron.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Cron.d.ts.map b/backend/node_modules/effect/dist/dts/Cron.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..4d48758cf2834ff66a939dfac69be2bffbc0fa61 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Cron.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Cron.d.ts","sourceRoot":"","sources":["../../src/Cron.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Data.d.ts b/backend/node_modules/effect/dist/dts/Data.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..eb31aaf57e7066a8b93a7d1f319c8f52c3d83635 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Data.d.ts @@ -0,0 +1,613 @@ +/** + * @since 2.0.0 + */ +import type * as Cause from "./Cause.js"; +import type * as Types from "./Types.js"; +import type { Unify } from "./Unify.js"; +/** + * @since 2.0.0 + */ +export declare namespace Case { + /** + * @since 2.0.0 + * @category models + */ + interface Constructor { + (args: Types.VoidIfEmpty<{ + readonly [P in keyof A as P extends Tag ? never : P]: A[P]; + }>): A; + } +} +/** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Data, Equal } from "effect" + * + * const alice = Data.struct({ name: "Alice", age: 30 }) + * + * const bob = Data.struct({ name: "Bob", age: 40 }) + * + * assert.deepStrictEqual(Equal.equals(alice, alice), true) + * assert.deepStrictEqual(Equal.equals(alice, Data.struct({ name: "Alice", age: 30 })), true) + * + * assert.deepStrictEqual(Equal.equals(alice, { name: "Alice", age: 30 }), false) + * assert.deepStrictEqual(Equal.equals(alice, bob), false) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const struct: >(a: A) => { + readonly [P in keyof A]: A[P]; +}; +/** + * @category constructors + * @since 2.0.0 + */ +export declare const unsafeStruct: >(as: A) => { readonly [P in keyof A]: A[P]; }; +/** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Data, Equal } from "effect" + * + * const alice = Data.tuple("Alice", 30) + * + * const bob = Data.tuple("Bob", 40) + * + * assert.deepStrictEqual(Equal.equals(alice, alice), true) + * assert.deepStrictEqual(Equal.equals(alice, Data.tuple("Alice", 30)), true) + * + * assert.deepStrictEqual(Equal.equals(alice, ["Alice", 30]), false) + * assert.deepStrictEqual(Equal.equals(alice, bob), false) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const tuple: >(...as: As) => Readonly; +/** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Data, Equal } from "effect" + * + * const alice = Data.struct({ name: "Alice", age: 30 }) + * const bob = Data.struct({ name: "Bob", age: 40 }) + * + * const persons = Data.array([alice, bob]) + * + * assert.deepStrictEqual( + * Equal.equals( + * persons, + * Data.array([ + * Data.struct({ name: "Alice", age: 30 }), + * Data.struct({ name: "Bob", age: 40 }) + * ]) + * ), + * true + * ) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const array: >(as: As) => Readonly; +/** + * @category constructors + * @since 2.0.0 + */ +export declare const unsafeArray: >(as: As) => Readonly; +declare const _case: () => Case.Constructor; +export { +/** + * Provides a constructor for the specified `Case`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Data, Equal } from "effect" + * + * interface Person { + * readonly name: string + * } + * + * // Creating a constructor for the specified Case + * const Person = Data.case() + * + * // Creating instances of Person + * const mike1 = Person({ name: "Mike" }) + * const mike2 = Person({ name: "Mike" }) + * const john = Person({ name: "John" }) + * + * // Checking equality + * assert.deepStrictEqual(Equal.equals(mike1, mike2), true) + * assert.deepStrictEqual(Equal.equals(mike1, john), false) + * + * ``` + * @since 2.0.0 + * @category constructors + */ +_case as case }; +/** + * Provides a tagged constructor for the specified `Case`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Data } from "effect" + * + * interface Person { + * readonly _tag: "Person" // the tag + * readonly name: string + * } + * + * const Person = Data.tagged("Person") + * + * const mike = Person({ name: "Mike" }) + * + * assert.deepEqual(mike, { _tag: "Person", name: "Mike" }) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const tagged: (tag: A["_tag"]) => Case.Constructor; +/** + * Provides a constructor for a Case Class. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Data, Equal } from "effect" + * + * class Person extends Data.Class<{ readonly name: string }> {} + * + * // Creating instances of Person + * const mike1 = new Person({ name: "Mike" }) + * const mike2 = new Person({ name: "Mike" }) + * const john = new Person({ name: "John" }) + * + * // Checking equality + * assert.deepStrictEqual(Equal.equals(mike1, mike2), true) + * assert.deepStrictEqual(Equal.equals(mike1, john), false) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const Class: new = {}>(args: Types.VoidIfEmpty<{ + readonly [P in keyof A]: A[P]; +}>) => Readonly; +/** + * Provides a Tagged constructor for a Case Class. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Data, Equal } from "effect" + * + * class Person extends Data.TaggedClass("Person")<{ readonly name: string }> {} + * + * // Creating instances of Person + * const mike1 = new Person({ name: "Mike" }) + * const mike2 = new Person({ name: "Mike" }) + * const john = new Person({ name: "John" }) + * + * // Checking equality + * assert.deepStrictEqual(Equal.equals(mike1, mike2), true) + * assert.deepStrictEqual(Equal.equals(mike1, john), false) + * + * assert.deepStrictEqual(mike1._tag, "Person") + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const TaggedClass: (tag: Tag) => new = {}>(args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly & { + readonly _tag: Tag; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Structural: new (args: Types.VoidIfEmpty<{ + readonly [P in keyof A]: A[P]; +}>) => {}; +/** + * Create a tagged enum data type, which is a union of `Data` structs. + * + * ```ts + * import * as assert from "node:assert" + * import { Data } from "effect" + * + * type HttpError = Data.TaggedEnum<{ + * BadRequest: { readonly status: 400, readonly message: string } + * NotFound: { readonly status: 404, readonly message: string } + * }> + * + * // Equivalent to: + * type HttpErrorPlain = + * | { + * readonly _tag: "BadRequest" + * readonly status: 400 + * readonly message: string + * } + * | { + * readonly _tag: "NotFound" + * readonly status: 404 + * readonly message: string + * } + * ``` + * + * @since 2.0.0 + * @category models + */ +export type TaggedEnum> & UntaggedChildren> = keyof A extends infer Tag ? Tag extends keyof A ? Types.Simplify<{ + readonly _tag: Tag; +} & { + readonly [K in keyof A[Tag]]: A[Tag][K]; +}> : never : never; +type ChildrenAreTagged = keyof A extends infer K ? K extends keyof A ? "_tag" extends keyof A[K] ? true : false : never : never; +type UntaggedChildren = true extends ChildrenAreTagged ? "It looks like you're trying to create a tagged enum, but one or more of its members already has a `_tag` property." : unknown; +/** + * @since 2.0.0 + */ +export declare namespace TaggedEnum { + /** + * @since 2.0.0 + * @category models + */ + interface WithGenerics { + readonly taggedEnum: { + readonly _tag: string; + }; + readonly numberOfGenerics: Count; + readonly A: unknown; + readonly B: unknown; + readonly C: unknown; + readonly D: unknown; + } + /** + * @since 2.0.0 + * @category models + */ + type Kind, A = unknown, B = unknown, C = unknown, D = unknown> = (Z & { + readonly A: A; + readonly B: B; + readonly C: C; + readonly D: D; + })["taggedEnum"]; + /** + * @since 2.0.0 + */ + type Args> = { + readonly [K in keyof E as K extends "_tag" ? never : K]: E[K]; + } extends infer T ? Types.VoidIfEmpty : never; + /** + * @since 2.0.0 + */ + type Value = Extract; + /** + * @since 3.1.0 + */ + type Constructor = Types.Simplify<{ + readonly [Tag in A["_tag"]]: Case.Constructor, "_tag">; + } & { + readonly $is: (tag: Tag) => (u: unknown) => u is Extract; + readonly $match: { + ) => any; + }>(cases: Cases & { + [K in Exclude]: never; + }): (value: A) => Unify>; + ) => any; + }>(value: A, cases: Cases & { + [K in Exclude]: never; + }): Unify>; + }; + }>; + /** + * @since 3.2.0 + */ + interface GenericMatchers> { + readonly $is: (tag: Tag) => { + >(u: T): u is T & { + readonly _tag: Tag; + }; + (u: unknown): u is Extract, { + readonly _tag: Tag; + }>; + }; + readonly $match: { + , { + readonly _tag: Tag; + }>) => any; + }>(cases: Cases & { + [K in Exclude]: never; + }): (self: TaggedEnum.Kind) => Unify>; + , { + readonly _tag: Tag; + }>) => any; + }>(self: TaggedEnum.Kind, cases: Cases & { + [K in Exclude]: never; + }): Unify>; + }; + } +} +/** + * Create a constructor for a tagged union of `Data` structs. + * + * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to + * the constructor. + * + * @example + * ```ts + * import { Data } from "effect" + * + * const { BadRequest, NotFound } = Data.taggedEnum< + * | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string } + * | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string } + * >() + * + * const notFound = NotFound({ status: 404, message: "Not Found" }) + * ``` + * + * @example + * import { Data } from "effect" + * + * type MyResult = Data.TaggedEnum<{ + * Failure: { readonly error: E } + * Success: { readonly value: A } + * }> + * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> { + * readonly taggedEnum: MyResult + * } + * const { Failure, Success } = Data.taggedEnum() + * + * const success = Success({ value: 1 }) + * + * @category constructors + * @since 2.0.0 + */ +export declare const taggedEnum: { + /** + * Create a constructor for a tagged union of `Data` structs. + * + * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to + * the constructor. + * + * @example + * ```ts + * import { Data } from "effect" + * + * const { BadRequest, NotFound } = Data.taggedEnum< + * | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string } + * | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string } + * >() + * + * const notFound = NotFound({ status: 404, message: "Not Found" }) + * ``` + * + * @example + * import { Data } from "effect" + * + * type MyResult = Data.TaggedEnum<{ + * Failure: { readonly error: E } + * Success: { readonly value: A } + * }> + * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> { + * readonly taggedEnum: MyResult + * } + * const { Failure, Success } = Data.taggedEnum() + * + * const success = Success({ value: 1 }) + * + * @category constructors + * @since 2.0.0 + */ + >(): Types.Simplify<{ + readonly [Tag in Z["taggedEnum"]["_tag"]]: (args: TaggedEnum.Args, Tag, Extract, { + readonly _tag: Tag; + }>>) => TaggedEnum.Value, Tag>; + } & TaggedEnum.GenericMatchers>; + /** + * Create a constructor for a tagged union of `Data` structs. + * + * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to + * the constructor. + * + * @example + * ```ts + * import { Data } from "effect" + * + * const { BadRequest, NotFound } = Data.taggedEnum< + * | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string } + * | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string } + * >() + * + * const notFound = NotFound({ status: 404, message: "Not Found" }) + * ``` + * + * @example + * import { Data } from "effect" + * + * type MyResult = Data.TaggedEnum<{ + * Failure: { readonly error: E } + * Success: { readonly value: A } + * }> + * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> { + * readonly taggedEnum: MyResult + * } + * const { Failure, Success } = Data.taggedEnum() + * + * const success = Success({ value: 1 }) + * + * @category constructors + * @since 2.0.0 + */ + >(): Types.Simplify<{ + readonly [Tag in Z["taggedEnum"]["_tag"]]: (args: TaggedEnum.Args, Tag, Extract, { + readonly _tag: Tag; + }>>) => TaggedEnum.Value, Tag>; + } & TaggedEnum.GenericMatchers>; + /** + * Create a constructor for a tagged union of `Data` structs. + * + * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to + * the constructor. + * + * @example + * ```ts + * import { Data } from "effect" + * + * const { BadRequest, NotFound } = Data.taggedEnum< + * | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string } + * | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string } + * >() + * + * const notFound = NotFound({ status: 404, message: "Not Found" }) + * ``` + * + * @example + * import { Data } from "effect" + * + * type MyResult = Data.TaggedEnum<{ + * Failure: { readonly error: E } + * Success: { readonly value: A } + * }> + * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> { + * readonly taggedEnum: MyResult + * } + * const { Failure, Success } = Data.taggedEnum() + * + * const success = Success({ value: 1 }) + * + * @category constructors + * @since 2.0.0 + */ + >(): Types.Simplify<{ + readonly [Tag in Z["taggedEnum"]["_tag"]]: (args: TaggedEnum.Args, Tag, Extract, { + readonly _tag: Tag; + }>>) => TaggedEnum.Value, Tag>; + } & TaggedEnum.GenericMatchers>; + /** + * Create a constructor for a tagged union of `Data` structs. + * + * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to + * the constructor. + * + * @example + * ```ts + * import { Data } from "effect" + * + * const { BadRequest, NotFound } = Data.taggedEnum< + * | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string } + * | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string } + * >() + * + * const notFound = NotFound({ status: 404, message: "Not Found" }) + * ``` + * + * @example + * import { Data } from "effect" + * + * type MyResult = Data.TaggedEnum<{ + * Failure: { readonly error: E } + * Success: { readonly value: A } + * }> + * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> { + * readonly taggedEnum: MyResult + * } + * const { Failure, Success } = Data.taggedEnum() + * + * const success = Success({ value: 1 }) + * + * @category constructors + * @since 2.0.0 + */ + >(): Types.Simplify<{ + readonly [Tag in Z["taggedEnum"]["_tag"]]: (args: TaggedEnum.Args, Tag, Extract, { + readonly _tag: Tag; + }>>) => TaggedEnum.Value, Tag>; + } & TaggedEnum.GenericMatchers>; + /** + * Create a constructor for a tagged union of `Data` structs. + * + * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to + * the constructor. + * + * @example + * ```ts + * import { Data } from "effect" + * + * const { BadRequest, NotFound } = Data.taggedEnum< + * | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string } + * | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string } + * >() + * + * const notFound = NotFound({ status: 404, message: "Not Found" }) + * ``` + * + * @example + * import { Data } from "effect" + * + * type MyResult = Data.TaggedEnum<{ + * Failure: { readonly error: E } + * Success: { readonly value: A } + * }> + * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> { + * readonly taggedEnum: MyResult + * } + * const { Failure, Success } = Data.taggedEnum() + * + * const success = Success({ value: 1 }) + * + * @category constructors + * @since 2.0.0 + */ + (): TaggedEnum.Constructor; +}; +/** + * Provides a constructor for a Case Class. + * + * @since 2.0.0 + * @category constructors + */ +export declare const Error: new = {}>(args: Types.VoidIfEmpty<{ + readonly [P in keyof A]: A[P]; +}>) => Cause.YieldableError & Readonly; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const TaggedError: (tag: Tag) => new = {}>(args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & { + readonly _tag: Tag; +} & Readonly; +//# sourceMappingURL=Data.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Data.d.ts.map b/backend/node_modules/effect/dist/dts/Data.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..190be3e352e3243cbd0c94b10daaed15aa5d3f10 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Data.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Data.d.ts","sourceRoot":"","sources":["../../src/Data.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/DefaultServices.d.ts b/backend/node_modules/effect/dist/dts/DefaultServices.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..72da17b18c8073f55294fc7572bd82e662bf03f8 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/DefaultServices.d.ts @@ -0,0 +1,26 @@ +/** + * @since 2.0.0 + */ +import type * as Clock from "./Clock.js"; +import type * as ConfigProvider from "./ConfigProvider.js"; +import type * as Console from "./Console.js"; +import type * as Context from "./Context.js"; +import type * as FiberRef from "./FiberRef.js"; +import type * as Random from "./Random.js"; +import type * as Tracer from "./Tracer.js"; +/** + * @since 2.0.0 + * @category models + */ +export type DefaultServices = Clock.Clock | Console.Console | Random.Random | ConfigProvider.ConfigProvider | Tracer.Tracer; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const liveServices: Context.Context; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentServices: FiberRef.FiberRef>; +//# sourceMappingURL=DefaultServices.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Deferred.d.ts.map b/backend/node_modules/effect/dist/dts/Deferred.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..2a67227c30661b33884f623dc600ca7bf3728e7f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Deferred.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Deferred.d.ts","sourceRoot":"","sources":["../../src/Deferred.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Differ.d.ts b/backend/node_modules/effect/dist/dts/Differ.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e454a92f95f4ad62c45c7fb81508cf8ee560a1ca --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Differ.d.ts @@ -0,0 +1,420 @@ +/** + * @since 2.0.0 + */ +import type { Chunk } from "./Chunk.js"; +import type { Context } from "./Context.js"; +import type { Either } from "./Either.js"; +import type { Equal } from "./Equal.js"; +import type { HashMap } from "./HashMap.js"; +import type { HashSet } from "./HashSet.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbol + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * A `Differ` knows how to compare an old value and new value of + * type `Value` to produce a patch of type `Patch` that describes the + * differences between those values. A `Differ` also knows how to apply a patch + * to an old value to produce a new value that represents the old value updated + * with the changes described by the patch. + * + * A `Differ` can be used to construct a `FiberRef` supporting compositional + * updates using the `FiberRef.makePatch` constructor. + * + * The `Differ` companion object contains constructors for `Differ` values for + * common data types such as `Chunk`, `HashMap`, and `HashSet``. In addition, + * `Differ`values can be transformed using the `transform` operator and combined + * using the `orElseEither` and `zip` operators. This allows creating `Differ` + * values for arbitrarily complex data types compositionally. + * + * @since 2.0.0 + * @category models + */ +export interface Differ extends Pipeable { + readonly [TypeId]: { + readonly _V: Types.Invariant; + readonly _P: Types.Invariant; + }; + readonly empty: Patch; + diff(oldValue: Value, newValue: Value): Patch; + combine(first: Patch, second: Patch): Patch; + patch(patch: Patch, oldValue: Value): Value; +} +declare const ChunkPatchTypeId: unique symbol; +declare const ContextPatchTypeId: unique symbol; +declare const HashMapPatchTypeId: unique symbol; +declare const HashSetPatchTypeId: unique symbol; +declare const OrPatchTypeId: unique symbol; +declare const ReadonlyArrayPatchTypeId: unique symbol; +/** + * @since 2.0.0 + */ +export declare namespace Differ { + /** + * @since 2.0.0 + */ + namespace Context { + /** + * @since 2.0.0 + * @category symbol + */ + type TypeId = typeof ContextPatchTypeId; + /** + * A `Patch` describes an update that transforms a `Env` + * to a `Env` as a data structure. This allows combining updates to + * different services in the environment in a compositional way. + * + * @since 2.0.0 + * @category models + */ + interface Patch extends Equal { + readonly [ContextPatchTypeId]: { + readonly _Input: Types.Contravariant; + readonly _Output: Types.Covariant; + }; + } + } + /** + * @since 2.0.0 + */ + namespace Chunk { + /** + * @since 2.0.0 + * @category symbol + */ + type TypeId = typeof ChunkPatchTypeId; + /** + * A patch which describes updates to a chunk of values. + * + * @since 2.0.0 + * @category models + */ + interface Patch extends Equal { + readonly [ChunkPatchTypeId]: { + readonly _Value: Types.Invariant; + readonly _Patch: Types.Invariant; + }; + } + } + /** + * @since 2.0.0 + */ + namespace HashMap { + /** + * @since 2.0.0 + * @category symbol + */ + type TypeId = typeof HashMapPatchTypeId; + /** + * A patch which describes updates to a map of keys and values. + * + * @since 2.0.0 + * @category models + */ + interface Patch extends Equal { + readonly [HashMapPatchTypeId]: { + readonly _Key: Types.Invariant; + readonly _Value: Types.Invariant; + readonly _Patch: Types.Invariant; + }; + } + } + /** + * @since 2.0.0 + */ + namespace HashSet { + /** + * @since 2.0.0 + * @category symbol + */ + type TypeId = typeof HashSetPatchTypeId; + /** + * A patch which describes updates to a set of values. + * + * @since 2.0.0 + * @category models + */ + interface Patch extends Equal { + readonly [HashSetPatchTypeId]: { + readonly _Value: Types.Invariant; + }; + } + } + /** + * @since 2.0.0 + */ + namespace Or { + /** + * @since 2.0.0 + * @category symbol + */ + type TypeId = typeof OrPatchTypeId; + /** + * A patch which describes updates to either one value or another. + * + * @since 2.0.0 + * @category models + */ + interface Patch extends Equal { + readonly [OrPatchTypeId]: { + readonly _Value: Types.Invariant; + readonly _Value2: Types.Invariant; + readonly _Patch: Types.Invariant; + readonly _Patch2: Types.Invariant; + }; + } + } + /** + * @since 2.0.0 + */ + namespace ReadonlyArray { + /** + * @since 2.0.0 + * @category symbol + */ + type TypeId = typeof ReadonlyArrayPatchTypeId; + /** + * A patch which describes updates to a ReadonlyArray of values. + * + * @since 2.0.0 + * @category models + */ + interface Patch extends Equal { + readonly [ReadonlyArrayPatchTypeId]: { + readonly _Value: Types.Invariant; + readonly _Patch: Types.Invariant; + }; + } + } +} +/** + * An empty patch that describes no changes. + * + * @since 2.0.0 + * @category patch + */ +export declare const empty: (self: Differ) => Patch; +/** + * @since 2.0.0 + * @category patch + */ +export declare const diff: { + /** + * @since 2.0.0 + * @category patch + */ + (oldValue: Value, newValue: Value): (self: Differ) => Patch; + /** + * @since 2.0.0 + * @category patch + */ + (self: Differ, oldValue: Value, newValue: Value): Patch; +}; +/** + * Combines two patches to produce a new patch that describes the updates of + * the first patch and then the updates of the second patch. The combine + * operation should be associative. In addition, if the combine operation is + * commutative then joining multiple fibers concurrently will result in + * deterministic `FiberRef` values. + * + * @since 2.0.0 + * @category patch + */ +export declare const combine: { + /** + * Combines two patches to produce a new patch that describes the updates of + * the first patch and then the updates of the second patch. The combine + * operation should be associative. In addition, if the combine operation is + * commutative then joining multiple fibers concurrently will result in + * deterministic `FiberRef` values. + * + * @since 2.0.0 + * @category patch + */ + (first: Patch, second: Patch): (self: Differ) => Patch; + /** + * Combines two patches to produce a new patch that describes the updates of + * the first patch and then the updates of the second patch. The combine + * operation should be associative. In addition, if the combine operation is + * commutative then joining multiple fibers concurrently will result in + * deterministic `FiberRef` values. + * + * @since 2.0.0 + * @category patch + */ + (self: Differ, first: Patch, second: Patch): Patch; +}; +/** + * Applies a patch to an old value to produce a new value that is equal to the + * old value with the updates described by the patch. + * + * @since 2.0.0 + * @category patch + */ +export declare const patch: { + /** + * Applies a patch to an old value to produce a new value that is equal to the + * old value with the updates described by the patch. + * + * @since 2.0.0 + * @category patch + */ + (patch: Patch, oldValue: Value): (self: Differ) => Value; + /** + * Applies a patch to an old value to produce a new value that is equal to the + * old value with the updates described by the patch. + * + * @since 2.0.0 + * @category patch + */ + (self: Differ, patch: Patch, oldValue: Value): Value; +}; +/** + * Constructs a new `Differ`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (params: { + readonly empty: Patch; + readonly diff: (oldValue: Value, newValue: Value) => Patch; + readonly combine: (first: Patch, second: Patch) => Patch; + readonly patch: (patch: Patch, oldValue: Value) => Value; +}) => Differ; +/** + * Constructs a differ that knows how to diff `Env` values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const environment: () => Differ, Differ.Context.Patch>; +/** + * Constructs a differ that knows how to diff a `Chunk` of values given a + * differ that knows how to diff the values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const chunk: (differ: Differ) => Differ, Differ.Chunk.Patch>; +/** + * Constructs a differ that knows how to diff a `HashMap` of keys and values given + * a differ that knows how to diff the values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const hashMap: (differ: Differ) => Differ, Differ.HashMap.Patch>; +/** + * Constructs a differ that knows how to diff a `HashSet` of values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const hashSet: () => Differ, Differ.HashSet.Patch>; +/** + * Combines this differ and the specified differ to produce a differ that + * knows how to diff the sum of their values. + * + * @since 2.0.0 + */ +export declare const orElseEither: { + /** + * Combines this differ and the specified differ to produce a differ that + * knows how to diff the sum of their values. + * + * @since 2.0.0 + */ + (that: Differ): (self: Differ) => Differ, Differ.Or.Patch>; + /** + * Combines this differ and the specified differ to produce a differ that + * knows how to diff the sum of their values. + * + * @since 2.0.0 + */ + (self: Differ, that: Differ): Differ, Differ.Or.Patch>; +}; +/** + * Constructs a differ that knows how to diff a `ReadonlyArray` of values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const readonlyArray: (differ: Differ) => Differ, Differ.ReadonlyArray.Patch>; +/** + * Transforms the type of values that this differ knows how to differ using + * the specified functions that map the new and old value types to each other. + * + * @since 2.0.0 + */ +export declare const transform: { + /** + * Transforms the type of values that this differ knows how to differ using + * the specified functions that map the new and old value types to each other. + * + * @since 2.0.0 + */ + (options: { + readonly toNew: (value: Value) => Value2; + readonly toOld: (value: Value2) => Value; + }): (self: Differ) => Differ; + /** + * Transforms the type of values that this differ knows how to differ using + * the specified functions that map the new and old value types to each other. + * + * @since 2.0.0 + */ + (self: Differ, options: { + readonly toNew: (value: Value) => Value2; + readonly toOld: (value: Value2) => Value; + }): Differ; +}; +/** + * Constructs a differ that just diffs two values by returning a function that + * sets the value to the new value. This differ does not support combining + * multiple updates to the value compositionally and should only be used when + * there is no compositional way to update them. + * + * @since 2.0.0 + */ +export declare const update: () => Differ A>; +/** + * A variant of `update` that allows specifying the function that will be used + * to combine old values with new values. + * + * @since 2.0.0 + */ +export declare const updateWith: (f: (x: A, y: A) => A) => Differ A>; +/** + * Combines this differ and the specified differ to produce a new differ that + * knows how to diff the product of their values. + * + * @since 2.0.0 + */ +export declare const zip: { + /** + * Combines this differ and the specified differ to produce a new differ that + * knows how to diff the product of their values. + * + * @since 2.0.0 + */ + (that: Differ): (self: Differ) => Differ; + /** + * Combines this differ and the specified differ to produce a new differ that + * knows how to diff the product of their values. + * + * @since 2.0.0 + */ + (self: Differ, that: Differ): Differ; +}; +export {}; +//# sourceMappingURL=Differ.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Differ.d.ts.map b/backend/node_modules/effect/dist/dts/Differ.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..cedad83e607b7b4bc24bfa82a4f65df2cd0dfa96 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Differ.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Differ.d.ts","sourceRoot":"","sources":["../../src/Differ.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Duration.d.ts b/backend/node_modules/effect/dist/dts/Duration.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c01b42ef310e4bf3b2c305c79d8fc75ffe797844 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Duration.d.ts @@ -0,0 +1,557 @@ +/** + * @since 2.0.0 + */ +import * as Equal from "./Equal.js"; +import type * as equivalence from "./Equivalence.js"; +import type { Inspectable } from "./Inspectable.js"; +import * as Option from "./Option.js"; +import * as order from "./Order.js"; +import type { Pipeable } from "./Pipeable.js"; +declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface Duration extends Equal.Equal, Pipeable, Inspectable { + readonly [TypeId]: TypeId; + readonly value: DurationValue; +} +/** + * @since 2.0.0 + * @category models + */ +export type DurationValue = { + readonly _tag: "Millis"; + readonly millis: number; +} | { + readonly _tag: "Nanos"; + readonly nanos: bigint; +} | { + readonly _tag: "Infinity"; +}; +/** + * @since 2.0.0 + * @category models + */ +export type Unit = "nano" | "nanos" | "micro" | "micros" | "milli" | "millis" | "second" | "seconds" | "minute" | "minutes" | "hour" | "hours" | "day" | "days" | "week" | "weeks"; +/** + * @since 2.0.0 + * @category models + */ +export type DurationInput = Duration | number | bigint | readonly [seconds: number, nanos: number] | `${number} ${Unit}`; +/** + * @since 2.0.0 + */ +export declare const decode: (input: DurationInput) => Duration; +/** + * @since 2.5.0 + */ +export declare const decodeUnknown: (u: unknown) => Option.Option; +/** + * @since 2.0.0 + * @category guards + */ +export declare const isDuration: (u: unknown) => u is Duration; +/** + * @since 2.0.0 + * @category guards + */ +export declare const isFinite: (self: Duration) => boolean; +/** + * @since 3.5.0 + * @category guards + */ +export declare const isZero: (self: Duration) => boolean; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const zero: Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const infinity: Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const nanos: (nanos: bigint) => Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const micros: (micros: bigint) => Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const millis: (millis: number) => Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const seconds: (seconds: number) => Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const minutes: (minutes: number) => Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const hours: (hours: number) => Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const days: (days: number) => Duration; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const weeks: (weeks: number) => Duration; +/** + * @since 2.0.0 + * @category getters + */ +export declare const toMillis: (self: DurationInput) => number; +/** + * @since 2.0.0 + * @category getters + */ +export declare const toSeconds: (self: DurationInput) => number; +/** + * @since 3.8.0 + * @category getters + */ +export declare const toMinutes: (self: DurationInput) => number; +/** + * @since 3.8.0 + * @category getters + */ +export declare const toHours: (self: DurationInput) => number; +/** + * @since 3.8.0 + * @category getters + */ +export declare const toDays: (self: DurationInput) => number; +/** + * @since 3.8.0 + * @category getters + */ +export declare const toWeeks: (self: DurationInput) => number; +/** + * Get the duration in nanoseconds as a bigint. + * + * If the duration is infinite, returns `Option.none()` + * + * @since 2.0.0 + * @category getters + */ +export declare const toNanos: (self: DurationInput) => Option.Option; +/** + * Get the duration in nanoseconds as a bigint. + * + * If the duration is infinite, it throws an error. + * + * @since 2.0.0 + * @category getters + */ +export declare const unsafeToNanos: (self: DurationInput) => bigint; +/** + * @since 2.0.0 + * @category getters + */ +export declare const toHrTime: (self: DurationInput) => [seconds: number, nanos: number]; +/** + * @since 2.0.0 + * @category pattern matching + */ +export declare const match: { + /** + * @since 2.0.0 + * @category pattern matching + */ + (options: { + readonly onMillis: (millis: number) => A; + readonly onNanos: (nanos: bigint) => B; + }): (self: DurationInput) => A | B; + /** + * @since 2.0.0 + * @category pattern matching + */ + (self: DurationInput, options: { + readonly onMillis: (millis: number) => A; + readonly onNanos: (nanos: bigint) => B; + }): A | B; +}; +/** + * @since 2.0.0 + * @category pattern matching + */ +export declare const matchWith: { + /** + * @since 2.0.0 + * @category pattern matching + */ + (that: DurationInput, options: { + readonly onMillis: (self: number, that: number) => A; + readonly onNanos: (self: bigint, that: bigint) => B; + }): (self: DurationInput) => A | B; + /** + * @since 2.0.0 + * @category pattern matching + */ + (self: DurationInput, that: DurationInput, options: { + readonly onMillis: (self: number, that: number) => A; + readonly onNanos: (self: bigint, that: bigint) => B; + }): A | B; +}; +/** + * @category instances + * @since 2.0.0 + */ +export declare const Order: order.Order; +/** + * Checks if a `Duration` is between a `minimum` and `maximum` value. + * + * @category predicates + * @since 2.0.0 + */ +export declare const between: { + /** + * Checks if a `Duration` is between a `minimum` and `maximum` value. + * + * @category predicates + * @since 2.0.0 + */ + (options: { + minimum: DurationInput; + maximum: DurationInput; + }): (self: DurationInput) => boolean; + /** + * Checks if a `Duration` is between a `minimum` and `maximum` value. + * + * @category predicates + * @since 2.0.0 + */ + (self: DurationInput, options: { + minimum: DurationInput; + maximum: DurationInput; + }): boolean; +}; +/** + * @category instances + * @since 2.0.0 + */ +export declare const Equivalence: equivalence.Equivalence; +/** + * @since 2.0.0 + */ +export declare const min: { + /** + * @since 2.0.0 + */ + (that: DurationInput): (self: DurationInput) => Duration; + /** + * @since 2.0.0 + */ + (self: DurationInput, that: DurationInput): Duration; +}; +/** + * @since 2.0.0 + * @category order + */ +export declare const max: { + /** + * @since 2.0.0 + * @category order + */ + (that: DurationInput): (self: DurationInput) => Duration; + /** + * @since 2.0.0 + * @category order + */ + (self: DurationInput, that: DurationInput): Duration; +}; +/** + * @since 2.0.0 + * @category order + */ +export declare const clamp: { + /** + * @since 2.0.0 + * @category order + */ + (options: { + minimum: DurationInput; + maximum: DurationInput; + }): (self: DurationInput) => Duration; + /** + * @since 2.0.0 + * @category order + */ + (self: DurationInput, options: { + minimum: DurationInput; + maximum: DurationInput; + }): Duration; +}; +/** + * @since 2.4.19 + * @category math + */ +export declare const divide: { + /** + * @since 2.4.19 + * @category math + */ + (by: number): (self: DurationInput) => Option.Option; + /** + * @since 2.4.19 + * @category math + */ + (self: DurationInput, by: number): Option.Option; +}; +/** + * @since 2.4.19 + * @category math + */ +export declare const unsafeDivide: { + /** + * @since 2.4.19 + * @category math + */ + (by: number): (self: DurationInput) => Duration; + /** + * @since 2.4.19 + * @category math + */ + (self: DurationInput, by: number): Duration; +}; +/** + * @since 2.0.0 + * @category math + */ +export declare const times: { + /** + * @since 2.0.0 + * @category math + */ + (times: number): (self: DurationInput) => Duration; + /** + * @since 2.0.0 + * @category math + */ + (self: DurationInput, times: number): Duration; +}; +/** + * @since 2.0.0 + * @category math + */ +export declare const subtract: { + /** + * @since 2.0.0 + * @category math + */ + (that: DurationInput): (self: DurationInput) => Duration; + /** + * @since 2.0.0 + * @category math + */ + (self: DurationInput, that: DurationInput): Duration; +}; +/** + * @since 2.0.0 + * @category math + */ +export declare const sum: { + /** + * @since 2.0.0 + * @category math + */ + (that: DurationInput): (self: DurationInput) => Duration; + /** + * @since 2.0.0 + * @category math + */ + (self: DurationInput, that: DurationInput): Duration; +}; +/** + * @since 2.0.0 + * @category predicates + */ +export declare const lessThan: { + /** + * @since 2.0.0 + * @category predicates + */ + (that: DurationInput): (self: DurationInput) => boolean; + /** + * @since 2.0.0 + * @category predicates + */ + (self: DurationInput, that: DurationInput): boolean; +}; +/** + * @since 2.0.0 + * @category predicates + */ +export declare const lessThanOrEqualTo: { + /** + * @since 2.0.0 + * @category predicates + */ + (that: DurationInput): (self: DurationInput) => boolean; + /** + * @since 2.0.0 + * @category predicates + */ + (self: DurationInput, that: DurationInput): boolean; +}; +/** + * @since 2.0.0 + * @category predicates + */ +export declare const greaterThan: { + /** + * @since 2.0.0 + * @category predicates + */ + (that: DurationInput): (self: DurationInput) => boolean; + /** + * @since 2.0.0 + * @category predicates + */ + (self: DurationInput, that: DurationInput): boolean; +}; +/** + * @since 2.0.0 + * @category predicates + */ +export declare const greaterThanOrEqualTo: { + /** + * @since 2.0.0 + * @category predicates + */ + (that: DurationInput): (self: DurationInput) => boolean; + /** + * @since 2.0.0 + * @category predicates + */ + (self: DurationInput, that: DurationInput): boolean; +}; +/** + * @since 2.0.0 + * @category predicates + */ +export declare const equals: { + /** + * @since 2.0.0 + * @category predicates + */ + (that: DurationInput): (self: DurationInput) => boolean; + /** + * @since 2.0.0 + * @category predicates + */ + (self: DurationInput, that: DurationInput): boolean; +}; +/** + * Converts a `Duration` to its parts. + * + * @since 3.8.0 + * @category conversions + */ +export declare const parts: (self: DurationInput) => { + days: number; + hours: number; + minutes: number; + seconds: number; + millis: number; + nanos: number; +}; +/** + * Converts a `Duration` to a human readable string. + * + * @since 2.0.0 + * @category conversions + * @example + * ```ts + * import { Duration } from "effect" + * + * Duration.format(Duration.millis(1000)) // "1s" + * Duration.format(Duration.millis(1001)) // "1s 1ms" + * ``` + */ +export declare const format: (self: DurationInput) => string; +/** + * Formats a Duration into an ISO8601 duration string. + * + * Months are assumed to be 30 days and years are assumed to be 365 days. + * + * Milliseconds and nanoseconds are expressed as fractional seconds. + * + * @example + * ```ts + * import { Duration } from "effect" + * + * Duration.unsafeFormatIso(Duration.days(1)) // => "P1D" + * Duration.unsafeFormatIso(Duration.minutes(90)) // => "PT1H30M" + * Duration.unsafeFormatIso(Duration.millis(1500)) // => "PT1.5S" + * ``` + * + * @throws `RangeError` If the duration is not finite. + * + * @since 3.13.0 + * @category conversions + */ +export declare const unsafeFormatIso: (self: DurationInput) => string; +/** + * Formats a Duration into an ISO8601 duration string. + * + * Months are assumed to be 30 days and years are assumed to be 365 days. + * + * Returns `Option.none()` if the duration is infinite. + * + * @example + * ```ts + * import { Duration, Option } from "effect" + * + * Duration.formatIso(Duration.days(1)) // => Option.some("P1D") + * Duration.formatIso(Duration.minutes(90)) // => Option.some("PT1H30M") + * Duration.formatIso(Duration.millis(1500)) // => Option.some("PT1.5S") + * Duration.formatIso(Duration.infinity) // => Option.none() + * ``` + * + * @since 3.13.0 + * @category conversions + */ +export declare const formatIso: (self: DurationInput) => Option.Option; +/** + * Parses an ISO8601 duration string into a `Duration`. + * + * Months are assumed to be 30 days and years are assumed to be 365 days. + * + * @example + * ```ts + * import { Duration, Option } from "effect" + * + * Duration.fromIso("P1D") // => Option.some(Duration.days(1)) + * Duration.fromIso("PT1H") // => Option.some(Duration.hours(1)) + * Duration.fromIso("PT1M") // => Option.some(Duration.minutes(1)) + * Duration.fromIso("PT1.5S") // => Option.some(Duration.seconds(1.5)) + * ``` + * + * @since 3.13.0 + * @category conversions + */ +export declare const fromIso: (iso: string) => Option.Option; +export {}; +//# sourceMappingURL=Duration.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Duration.d.ts.map b/backend/node_modules/effect/dist/dts/Duration.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..27d86c25da3dd820b511333acdee44de16a8d359 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Duration.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Duration.d.ts","sourceRoot":"","sources":["../../src/Duration.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Effect.d.ts b/backend/node_modules/effect/dist/dts/Effect.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..22f72058487a1ba2e3478840d565e5c82a744ebc --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Effect.d.ts @@ -0,0 +1,26991 @@ +/** + * @since 2.0.0 + */ +import type * as RA from "./Array.js"; +import type * as Cause from "./Cause.js"; +import type * as Chunk from "./Chunk.js"; +import type * as Clock from "./Clock.js"; +import type { ConfigProvider } from "./ConfigProvider.js"; +import type { Console } from "./Console.js"; +import type * as Context from "./Context.js"; +import type * as Deferred from "./Deferred.js"; +import type * as Duration from "./Duration.js"; +import type * as Either from "./Either.js"; +import type { Equivalence } from "./Equivalence.js"; +import type { ExecutionPlan } from "./ExecutionPlan.js"; +import type { ExecutionStrategy } from "./ExecutionStrategy.js"; +import type * as Exit from "./Exit.js"; +import type * as Fiber from "./Fiber.js"; +import type * as FiberId from "./FiberId.js"; +import type * as FiberRef from "./FiberRef.js"; +import type * as FiberRefs from "./FiberRefs.js"; +import type * as FiberRefsPatch from "./FiberRefsPatch.js"; +import type * as FiberStatus from "./FiberStatus.js"; +import type { LazyArg } from "./Function.js"; +import type * as HashMap from "./HashMap.js"; +import type * as HashSet from "./HashSet.js"; +import type { TypeLambda } from "./HKT.js"; +import type * as Layer from "./Layer.js"; +import type * as LogLevel from "./LogLevel.js"; +import type * as ManagedRuntime from "./ManagedRuntime.js"; +import type * as Metric from "./Metric.js"; +import type * as MetricLabel from "./MetricLabel.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import * as Random from "./Random.js"; +import type * as Ref from "./Ref.js"; +import * as Request from "./Request.js"; +import type { RequestBlock } from "./RequestBlock.js"; +import type { RequestResolver } from "./RequestResolver.js"; +import type * as Runtime from "./Runtime.js"; +import type * as RuntimeFlags from "./RuntimeFlags.js"; +import type * as RuntimeFlagsPatch from "./RuntimeFlagsPatch.js"; +import type * as Schedule from "./Schedule.js"; +import * as Scheduler from "./Scheduler.js"; +import type * as Scope from "./Scope.js"; +import type * as Supervisor from "./Supervisor.js"; +import type * as Tracer from "./Tracer.js"; +import type { Concurrency, Contravariant, Covariant, EqualsWith, NoExcessProperties, NoInfer, NotFunction } from "./Types.js"; +import type * as Unify from "./Unify.js"; +import { type YieldWrap } from "./Utils.js"; +/** + * @since 2.0.0 + * @category Symbols + */ +export declare const EffectTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type EffectTypeId = typeof EffectTypeId; +/** + * The `Effect` interface defines a value that describes a workflow or job, + * which can succeed or fail. + * + * **Details** + * + * The `Effect` interface represents a computation that can model a workflow + * involving various types of operations, such as synchronous, asynchronous, + * concurrent, and parallel interactions. It operates within a context of type + * `R`, and the result can either be a success with a value of type `A` or a + * failure with an error of type `E`. The `Effect` is designed to handle complex + * interactions with external resources, offering advanced features such as + * fiber-based concurrency, scheduling, interruption handling, and scalability. + * This makes it suitable for tasks that require fine-grained control over + * concurrency and error management. + * + * To execute an `Effect` value, you need a `Runtime`, which provides the + * environment necessary to run and manage the computation. + * + * @since 2.0.0 + * @category Models + */ +export interface Effect extends Effect.Variance, Pipeable { + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: EffectUnify; + readonly [Unify.ignoreSymbol]?: EffectUnifyIgnore; + [Symbol.iterator](): EffectGenerator>; +} +/** + * @since 3.0.0 + * @category Models + */ +export interface EffectGenerator> { + next(...args: ReadonlyArray): IteratorResult, Effect.Success>; +} +/** + * @since 2.0.0 + * @category Models + */ +export interface EffectUnify extends Either.EitherUnify, Option.OptionUnify, Context.TagUnify { + Effect?: () => A[Unify.typeSymbol] extends Effect | infer _ ? Effect : never; +} +/** + * @category Models + * @since 2.0.0 + */ +export interface EffectUnifyIgnore { + Tag?: true; + Option?: true; + Either?: true; +} +/** + * @category Type lambdas + * @since 2.0.0 + */ +export interface EffectTypeLambda extends TypeLambda { + readonly type: Effect; +} +/** + * @since 2.0.0 + * @category Models + */ +export interface Blocked extends Effect { + readonly _op: "Blocked"; + readonly effect_instruction_i0: RequestBlock; + readonly effect_instruction_i1: Effect; +} +/** + * @since 2.0.0 + * @category Models + */ +declare module "./Context.js" { + interface Tag extends Effect { + [Symbol.iterator](): EffectGenerator>; + } + interface Reference extends Effect { + [Symbol.iterator](): EffectGenerator>; + } + interface TagUnifyIgnore { + Effect?: true; + Either?: true; + Option?: true; + } +} +/** + * @since 2.0.0 + * @category Models + */ +declare module "./Either.js" { + interface Left extends Effect { + readonly _tag: "Left"; + [Symbol.iterator](): EffectGenerator>; + } + interface Right extends Effect { + readonly _tag: "Right"; + [Symbol.iterator](): EffectGenerator>; + } + interface EitherUnifyIgnore { + Effect?: true; + Tag?: true; + Option?: true; + } +} +/** + * @since 2.0.0 + * @category Models + */ +declare module "./Option.js" { + interface None extends Effect { + readonly _tag: "None"; + [Symbol.iterator](): EffectGenerator>; + } + interface Some extends Effect { + readonly _tag: "Some"; + [Symbol.iterator](): EffectGenerator>; + } + interface OptionUnifyIgnore { + Effect?: true; + Tag?: true; + Either?: true; + } +} +/** + * @since 2.0.0 + */ +export declare namespace Effect { + /** + * @since 2.0.0 + * @category Models + */ + interface Variance { + readonly [EffectTypeId]: VarianceStruct; + } + /** + * @since 2.0.0 + * @category Models + */ + interface VarianceStruct { + readonly _V: string; + readonly _A: Covariant; + readonly _E: Covariant; + readonly _R: Covariant; + } + /** + * @since 2.0.0 + * @category Effect Type Extractors + */ + type Context> = [T] extends [Effect] ? _R : never; + /** + * @since 2.0.0 + * @category Effect Type Extractors + */ + type Error> = [T] extends [Effect] ? _E : never; + /** + * @since 2.0.0 + * @category Effect Type Extractors + */ + type Success> = [T] extends [Effect] ? _A : never; + /** + * @since 3.15.5 + * @category Effect Type Extractors + */ + type AsEffect> = Effect ? _A : never, T extends Effect ? _E : never, T extends Effect ? _R : never> extends infer Q ? Q : never; +} +/** + * Checks if a given value is an `Effect` value. + * + * **When to Use** + * + * This function can be useful for checking the type of a value before + * attempting to operate on it as an `Effect` value. For example, you could use + * `Effect.isEffect` to check the type of a value before using it as an argument + * to a function that expects an `Effect` value. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isEffect: (u: unknown) => u is Effect; +/** + * Returns an effect that caches its result for a specified `Duration`, + * known as "timeToLive" (TTL). + * + * **Details** + * + * This function is used to cache the result of an effect for a specified amount + * of time. This means that the first time the effect is evaluated, its result + * is computed and stored. + * + * If the effect is evaluated again within the specified `timeToLive`, the + * cached result will be used, avoiding recomputation. + * + * After the specified duration has passed, the cache expires, and the effect + * will be recomputed upon the next evaluation. + * + * **When to Use** + * + * Use this function when you have an effect that involves costly operations or + * computations, and you want to avoid repeating them within a short time frame. + * + * It's ideal for scenarios where the result of an effect doesn't change + * frequently and can be reused for a specified duration. + * + * By caching the result, you can improve efficiency and reduce unnecessary + * computations, especially in performance-critical applications. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * let i = 1 + * const expensiveTask = Effect.promise(() => { + * console.log("expensive task...") + * return new Promise((resolve) => { + * setTimeout(() => { + * resolve(`result ${i++}`) + * }, 100) + * }) + * }) + * + * const program = Effect.gen(function* () { + * const cached = yield* Effect.cachedWithTTL(expensiveTask, "150 millis") + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* Effect.sleep("100 millis") + * yield* cached.pipe(Effect.andThen(Console.log)) + * }) + * + * Effect.runFork(program) + * // Output: + * // expensive task... + * // result 1 + * // result 1 + * // expensive task... + * // result 2 + * ``` + * + * @see {@link cached} for a similar function that caches the result + * indefinitely. + * @see {@link cachedInvalidateWithTTL} for a similar function that includes an + * additional effect for manually invalidating the cached value. + * + * @since 2.0.0 + * @category Caching + */ +export declare const cachedWithTTL: { + /** + * Returns an effect that caches its result for a specified `Duration`, + * known as "timeToLive" (TTL). + * + * **Details** + * + * This function is used to cache the result of an effect for a specified amount + * of time. This means that the first time the effect is evaluated, its result + * is computed and stored. + * + * If the effect is evaluated again within the specified `timeToLive`, the + * cached result will be used, avoiding recomputation. + * + * After the specified duration has passed, the cache expires, and the effect + * will be recomputed upon the next evaluation. + * + * **When to Use** + * + * Use this function when you have an effect that involves costly operations or + * computations, and you want to avoid repeating them within a short time frame. + * + * It's ideal for scenarios where the result of an effect doesn't change + * frequently and can be reused for a specified duration. + * + * By caching the result, you can improve efficiency and reduce unnecessary + * computations, especially in performance-critical applications. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * let i = 1 + * const expensiveTask = Effect.promise(() => { + * console.log("expensive task...") + * return new Promise((resolve) => { + * setTimeout(() => { + * resolve(`result ${i++}`) + * }, 100) + * }) + * }) + * + * const program = Effect.gen(function* () { + * const cached = yield* Effect.cachedWithTTL(expensiveTask, "150 millis") + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* Effect.sleep("100 millis") + * yield* cached.pipe(Effect.andThen(Console.log)) + * }) + * + * Effect.runFork(program) + * // Output: + * // expensive task... + * // result 1 + * // result 1 + * // expensive task... + * // result 2 + * ``` + * + * @see {@link cached} for a similar function that caches the result + * indefinitely. + * @see {@link cachedInvalidateWithTTL} for a similar function that includes an + * additional effect for manually invalidating the cached value. + * + * @since 2.0.0 + * @category Caching + */ + (timeToLive: Duration.DurationInput): (self: Effect) => Effect, never, R>; + /** + * Returns an effect that caches its result for a specified `Duration`, + * known as "timeToLive" (TTL). + * + * **Details** + * + * This function is used to cache the result of an effect for a specified amount + * of time. This means that the first time the effect is evaluated, its result + * is computed and stored. + * + * If the effect is evaluated again within the specified `timeToLive`, the + * cached result will be used, avoiding recomputation. + * + * After the specified duration has passed, the cache expires, and the effect + * will be recomputed upon the next evaluation. + * + * **When to Use** + * + * Use this function when you have an effect that involves costly operations or + * computations, and you want to avoid repeating them within a short time frame. + * + * It's ideal for scenarios where the result of an effect doesn't change + * frequently and can be reused for a specified duration. + * + * By caching the result, you can improve efficiency and reduce unnecessary + * computations, especially in performance-critical applications. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * let i = 1 + * const expensiveTask = Effect.promise(() => { + * console.log("expensive task...") + * return new Promise((resolve) => { + * setTimeout(() => { + * resolve(`result ${i++}`) + * }, 100) + * }) + * }) + * + * const program = Effect.gen(function* () { + * const cached = yield* Effect.cachedWithTTL(expensiveTask, "150 millis") + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* Effect.sleep("100 millis") + * yield* cached.pipe(Effect.andThen(Console.log)) + * }) + * + * Effect.runFork(program) + * // Output: + * // expensive task... + * // result 1 + * // result 1 + * // expensive task... + * // result 2 + * ``` + * + * @see {@link cached} for a similar function that caches the result + * indefinitely. + * @see {@link cachedInvalidateWithTTL} for a similar function that includes an + * additional effect for manually invalidating the cached value. + * + * @since 2.0.0 + * @category Caching + */ + (self: Effect, timeToLive: Duration.DurationInput): Effect, never, R>; +}; +/** + * Caches an effect's result for a specified duration and allows manual + * invalidation before expiration. + * + * **Details** + * + * This function behaves similarly to {@link cachedWithTTL} by caching the + * result of an effect for a specified period of time. However, it introduces an + * additional feature: it provides an effect that allows you to manually + * invalidate the cached result before it naturally expires. + * + * This gives you more control over the cache, allowing you to refresh the + * result when needed, even if the original cache has not yet expired. + * + * Once the cache is invalidated, the next time the effect is evaluated, the + * result will be recomputed, and the cache will be refreshed. + * + * **When to Use** + * + * Use this function when you have an effect whose result needs to be cached for + * a certain period, but you also want the option to refresh the cache manually + * before the expiration time. + * + * This is useful when you need to ensure that the cached data remains valid for + * a certain period but still want to invalidate it if the underlying data + * changes or if you want to force a recomputation. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * let i = 1 + * const expensiveTask = Effect.promise(() => { + * console.log("expensive task...") + * return new Promise((resolve) => { + * setTimeout(() => { + * resolve(`result ${i++}`) + * }, 100) + * }) + * }) + * + * const program = Effect.gen(function* () { + * const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL( + * expensiveTask, + * "1 hour" + * ) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* invalidate + * yield* cached.pipe(Effect.andThen(Console.log)) + * }) + * + * Effect.runFork(program) + * // Output: + * // expensive task... + * // result 1 + * // result 1 + * // expensive task... + * // result 2 + * ``` + * + * @see {@link cached} for a similar function that caches the result + * indefinitely. + * @see {@link cachedWithTTL} for a similar function that caches the result for + * a specified duration but does not include an effect for manual invalidation. + * + * @since 2.0.0 + * @category Caching + */ +export declare const cachedInvalidateWithTTL: { + /** + * Caches an effect's result for a specified duration and allows manual + * invalidation before expiration. + * + * **Details** + * + * This function behaves similarly to {@link cachedWithTTL} by caching the + * result of an effect for a specified period of time. However, it introduces an + * additional feature: it provides an effect that allows you to manually + * invalidate the cached result before it naturally expires. + * + * This gives you more control over the cache, allowing you to refresh the + * result when needed, even if the original cache has not yet expired. + * + * Once the cache is invalidated, the next time the effect is evaluated, the + * result will be recomputed, and the cache will be refreshed. + * + * **When to Use** + * + * Use this function when you have an effect whose result needs to be cached for + * a certain period, but you also want the option to refresh the cache manually + * before the expiration time. + * + * This is useful when you need to ensure that the cached data remains valid for + * a certain period but still want to invalidate it if the underlying data + * changes or if you want to force a recomputation. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * let i = 1 + * const expensiveTask = Effect.promise(() => { + * console.log("expensive task...") + * return new Promise((resolve) => { + * setTimeout(() => { + * resolve(`result ${i++}`) + * }, 100) + * }) + * }) + * + * const program = Effect.gen(function* () { + * const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL( + * expensiveTask, + * "1 hour" + * ) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* invalidate + * yield* cached.pipe(Effect.andThen(Console.log)) + * }) + * + * Effect.runFork(program) + * // Output: + * // expensive task... + * // result 1 + * // result 1 + * // expensive task... + * // result 2 + * ``` + * + * @see {@link cached} for a similar function that caches the result + * indefinitely. + * @see {@link cachedWithTTL} for a similar function that caches the result for + * a specified duration but does not include an effect for manual invalidation. + * + * @since 2.0.0 + * @category Caching + */ + (timeToLive: Duration.DurationInput): (self: Effect) => Effect<[Effect, Effect], never, R>; + /** + * Caches an effect's result for a specified duration and allows manual + * invalidation before expiration. + * + * **Details** + * + * This function behaves similarly to {@link cachedWithTTL} by caching the + * result of an effect for a specified period of time. However, it introduces an + * additional feature: it provides an effect that allows you to manually + * invalidate the cached result before it naturally expires. + * + * This gives you more control over the cache, allowing you to refresh the + * result when needed, even if the original cache has not yet expired. + * + * Once the cache is invalidated, the next time the effect is evaluated, the + * result will be recomputed, and the cache will be refreshed. + * + * **When to Use** + * + * Use this function when you have an effect whose result needs to be cached for + * a certain period, but you also want the option to refresh the cache manually + * before the expiration time. + * + * This is useful when you need to ensure that the cached data remains valid for + * a certain period but still want to invalidate it if the underlying data + * changes or if you want to force a recomputation. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * let i = 1 + * const expensiveTask = Effect.promise(() => { + * console.log("expensive task...") + * return new Promise((resolve) => { + * setTimeout(() => { + * resolve(`result ${i++}`) + * }, 100) + * }) + * }) + * + * const program = Effect.gen(function* () { + * const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL( + * expensiveTask, + * "1 hour" + * ) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* invalidate + * yield* cached.pipe(Effect.andThen(Console.log)) + * }) + * + * Effect.runFork(program) + * // Output: + * // expensive task... + * // result 1 + * // result 1 + * // expensive task... + * // result 2 + * ``` + * + * @see {@link cached} for a similar function that caches the result + * indefinitely. + * @see {@link cachedWithTTL} for a similar function that caches the result for + * a specified duration but does not include an effect for manual invalidation. + * + * @since 2.0.0 + * @category Caching + */ + (self: Effect, timeToLive: Duration.DurationInput): Effect<[Effect, Effect], never, R>; +}; +/** + * Returns an effect that lazily computes a result and caches it for subsequent + * evaluations. + * + * **Details** + * + * This function wraps an effect and ensures that its result is computed only + * once. Once the result is computed, it is cached, meaning that subsequent + * evaluations of the same effect will return the cached result without + * re-executing the logic. + * + * **When to Use** + * + * Use this function when you have an expensive or time-consuming operation that + * you want to avoid repeating. The first evaluation will compute the result, + * and all following evaluations will immediately return the cached value, + * improving performance and reducing unnecessary work. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * let i = 1 + * const expensiveTask = Effect.promise(() => { + * console.log("expensive task...") + * return new Promise((resolve) => { + * setTimeout(() => { + * resolve(`result ${i++}`) + * }, 100) + * }) + * }) + * + * const program = Effect.gen(function* () { + * console.log("non-cached version:") + * yield* expensiveTask.pipe(Effect.andThen(Console.log)) + * yield* expensiveTask.pipe(Effect.andThen(Console.log)) + * console.log("cached version:") + * const cached = yield* Effect.cached(expensiveTask) + * yield* cached.pipe(Effect.andThen(Console.log)) + * yield* cached.pipe(Effect.andThen(Console.log)) + * }) + * + * Effect.runFork(program) + * // Output: + * // non-cached version: + * // expensive task... + * // result 1 + * // expensive task... + * // result 2 + * // cached version: + * // expensive task... + * // result 3 + * // result 3 + * ``` + * + * @see {@link cachedWithTTL} for a similar function that includes a + * time-to-live duration for the cached value. + * @see {@link cachedInvalidateWithTTL} for a similar function that includes an + * additional effect for manually invalidating the cached value. + * + * @since 2.0.0 + * @category Caching + */ +export declare const cached: (self: Effect) => Effect>; +/** + * Returns a memoized version of a function with effects, reusing results for + * the same inputs. + * + * **Details** + * + * This function creates a memoized version of a given function that performs an + * effect. Memoization ensures that once a result is computed for a specific + * input, it is stored and reused for subsequent calls with the same input, + * reducing the need to recompute the result. + * + * The function can optionally take an `Equivalence` parameter to + * determine how inputs are compared for caching purposes. + * + * **When to Use** + * + * Use this function when you have a function that performs an effect and you + * want to avoid recomputing the result for the same input multiple times. + * + * It's ideal for functions that produce deterministic results based on their + * inputs, and you want to improve performance by caching the output. + * + * This is particularly useful in scenarios where the function involves + * expensive calculations or operations that should be avoided after the first + * execution with the same parameters. + * + * **Example** + * + * ```ts + * import { Effect, Random } from "effect" + * + * const program = Effect.gen(function* () { + * const randomNumber = (n: number) => Random.nextIntBetween(1, n) + * console.log("non-memoized version:") + * console.log(yield* randomNumber(10)) + * console.log(yield* randomNumber(10)) + * + * console.log("memoized version:") + * const memoized = yield* Effect.cachedFunction(randomNumber) + * console.log(yield* memoized(10)) + * console.log(yield* memoized(10)) + * }) + * + * Effect.runFork(program) + * // Example Output: + * // non-memoized version: + * // 2 + * // 8 + * // memoized version: + * // 5 + * // 5 + * ``` + * + * @since 2.0.0 + * @category Caching + */ +export declare const cachedFunction: (f: (a: A) => Effect, eq?: Equivalence) => Effect<(a: A) => Effect>; +/** + * Returns an effect that executes only once, regardless of how many times it's + * called. + * + * **Details** + * + * This function ensures that a specific effect is executed only a single time, + * no matter how many times it is invoked. The result of the effect will be + * cached, and subsequent calls to the effect will immediately return the cached + * result without re-executing the original logic. + * + * **When to Use** + * + * Use this function when you need to perform a task only once, regardless of + * how many times the effect is triggered. It's particularly useful when you + * have initialization tasks, logging, or other one-time actions that should not + * be repeated. This can help optimize performance and avoid redundant actions. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * const program = Effect.gen(function* () { + * const task1 = Console.log("task1") + * yield* Effect.repeatN(task1, 2) + * const task2 = yield* Effect.once(Console.log("task2")) + * yield* Effect.repeatN(task2, 2) + * }) + * + * Effect.runFork(program) + * // Output: + * // task1 + * // task1 + * // task1 + * // task2 + * ``` + * + * @since 2.0.0 + * @category Caching + */ +export declare const once: (self: Effect) => Effect>; +/** + * Combines multiple effects into one, returning results based on the input + * structure. + * + * **Details** + * + * Use this function when you need to run multiple effects and combine their + * results into a single output. It supports tuples, iterables, structs, and + * records, making it flexible for different input types. + * + * For instance, if the input is a tuple: + * + * ```ts skip-type-checking + * // ┌─── a tuple of effects + * // ▼ + * Effect.all([effect1, effect2, ...]) + * ``` + * + * the effects are executed sequentially, and the result is a new effect + * containing the results as a tuple. The results in the tuple match the order + * of the effects passed to `Effect.all`. + * + * **Concurrency** + * + * You can control the execution order (e.g., sequential vs. concurrent) using + * the `concurrency` option. + * + * **Short-Circuiting Behavior** + * + * This function stops execution on the first error it encounters, this is + * called "short-circuiting". If any effect in the collection fails, the + * remaining effects will not run, and the error will be propagated. To change + * this behavior, you can use the `mode` option, which allows all effects to run + * and collect results as `Either` or `Option`. + * + * **The `mode` option** + * + * The `{ mode: "either" }` option changes the behavior of `Effect.all` to + * ensure all effects run, even if some fail. Instead of stopping on the first + * failure, this mode collects both successes and failures, returning an array + * of `Either` instances where each result is either a `Right` (success) or a + * `Left` (failure). + * + * Similarly, the `{ mode: "validate" }` option uses `Option` to indicate + * success or failure. Each effect returns `None` for success and `Some` with + * the error for failure. + * + * **Example** (Combining Effects in Tuples) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const tupleOfEffects = [ + * Effect.succeed(42).pipe(Effect.tap(Console.log)), + * Effect.succeed("Hello").pipe(Effect.tap(Console.log)) + * ] as const + * + * // ┌─── Effect<[number, string], never, never> + * // ▼ + * const resultsAsTuple = Effect.all(tupleOfEffects) + * + * Effect.runPromise(resultsAsTuple).then(console.log) + * // Output: + * // 42 + * // Hello + * // [ 42, 'Hello' ] + * ``` + * + * **Example** (Combining Effects in Iterables) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const iterableOfEffects: Iterable> = [1, 2, 3].map( + * (n) => Effect.succeed(n).pipe(Effect.tap(Console.log)) + * ) + * + * // ┌─── Effect + * // ▼ + * const resultsAsArray = Effect.all(iterableOfEffects) + * + * Effect.runPromise(resultsAsArray).then(console.log) + * // Output: + * // 1 + * // 2 + * // 3 + * // [ 1, 2, 3 ] + * ``` + * + * **Example** (Combining Effects in Structs) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const structOfEffects = { + * a: Effect.succeed(42).pipe(Effect.tap(Console.log)), + * b: Effect.succeed("Hello").pipe(Effect.tap(Console.log)) + * } + * + * // ┌─── Effect<{ a: number; b: string; }, never, never> + * // ▼ + * const resultsAsStruct = Effect.all(structOfEffects) + * + * Effect.runPromise(resultsAsStruct).then(console.log) + * // Output: + * // 42 + * // Hello + * // { a: 42, b: 'Hello' } + * ``` + * + * **Example** (Combining Effects in Records) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const recordOfEffects: Record> = { + * key1: Effect.succeed(1).pipe(Effect.tap(Console.log)), + * key2: Effect.succeed(2).pipe(Effect.tap(Console.log)) + * } + * + * // ┌─── Effect<{ [x: string]: number; }, never, never> + * // ▼ + * const resultsAsRecord = Effect.all(recordOfEffects) + * + * Effect.runPromise(resultsAsRecord).then(console.log) + * // Output: + * // 1 + * // 2 + * // { key1: 1, key2: 2 } + * ``` + * + * **Example** (Short-Circuiting Behavior) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const program = Effect.all([ + * Effect.succeed("Task1").pipe(Effect.tap(Console.log)), + * Effect.fail("Task2: Oh no!").pipe(Effect.tap(Console.log)), + * // Won't execute due to earlier failure + * Effect.succeed("Task3").pipe(Effect.tap(Console.log)) + * ]) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Task1 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Task2: Oh no!' } + * // } + * ``` + * + * **Example** (Collecting Results with `mode: "either"`) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const effects = [ + * Effect.succeed("Task1").pipe(Effect.tap(Console.log)), + * Effect.fail("Task2: Oh no!").pipe(Effect.tap(Console.log)), + * Effect.succeed("Task3").pipe(Effect.tap(Console.log)) + * ] + * + * const program = Effect.all(effects, { mode: "either" }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Task1 + * // Task3 + * // { + * // _id: 'Exit', + * // _tag: 'Success', + * // value: [ + * // { _id: 'Either', _tag: 'Right', right: 'Task1' }, + * // { _id: 'Either', _tag: 'Left', left: 'Task2: Oh no!' }, + * // { _id: 'Either', _tag: 'Right', right: 'Task3' } + * // ] + * // } + * ``` + * + * **Example** (Collecting Results with `mode: "validate"`) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const effects = [ + * Effect.succeed("Task1").pipe(Effect.tap(Console.log)), + * Effect.fail("Task2: Oh no!").pipe(Effect.tap(Console.log)), + * Effect.succeed("Task3").pipe(Effect.tap(Console.log)) + * ] + * + * const program = Effect.all(effects, { mode: "validate" }) + * + * Effect.runPromiseExit(program).then((result) => console.log("%o", result)) + * // Output: + * // Task1 + * // Task3 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: [ + * // { _id: 'Option', _tag: 'None' }, + * // { _id: 'Option', _tag: 'Some', value: 'Task2: Oh no!' }, + * // { _id: 'Option', _tag: 'None' } + * // ] + * // } + * // } + * ``` + * + * @see {@link forEach} for iterating over elements and applying an effect. + * @see {@link allWith} for a data-last version of this function. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const all: > | Record>, O extends NoExcessProperties<{ + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: boolean | undefined; + readonly mode?: "default" | "validate" | "either" | undefined; + readonly concurrentFinalizers?: boolean | undefined; +}, O>>(arg: Arg, options?: O) => All.Return; +/** + * A data-last version of {@link all}, designed for use in pipelines. + * + * **When to Use** + * + * This function enables you to combine multiple effects and customize execution + * options such as concurrency levels. This version is useful in functional + * pipelines where you first define your data and then apply operations to it. + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const program = pipe( + * [task1, task2], + * // Run both effects concurrently using the concurrent option + * Effect.allWith({ concurrency: 2 }) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#3 message="task2 done" + * // timestamp=... level=INFO fiber=#2 message="task1 done" + * // [ 1, 'hello' ] + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const allWith: >(options?: O) => > | Record>>(arg: Arg) => All.Return; +/** + * @since 2.0.0 + */ +export declare namespace All { + /** + * @since 2.0.0 + */ + type EffectAny = Effect; + /** + * @since 2.0.0 + */ + type ReturnIterable, Discard extends boolean, Mode> = [T] extends [ + Iterable> + ] ? Effect> : Array, Mode extends "either" ? never : Mode extends "validate" ? Array> : L0, R> : never; + /** + * @since 2.0.0 + */ + type ReturnTuple, Discard extends boolean, Mode> = Effect] ? Either.Either<_A, _E> : never; + } : { + -readonly [K in keyof T]: [T[K]] extends [Effect.Variance] ? _A : never; + }, Mode extends "either" ? never : T[number] extends never ? never : Mode extends "validate" ? { + -readonly [K in keyof T]: [T[K]] extends [Effect.Variance] ? Option.Option<_E> : never; + } : [T[number]] extends [{ + [EffectTypeId]: { + _E: (_: never) => infer E; + }; + }] ? E : never, T[number] extends never ? never : [T[number]] extends [{ + [EffectTypeId]: { + _R: (_: never) => infer R; + }; + }] ? R : never> extends infer X ? X : never; + /** + * @since 2.0.0 + */ + type ReturnObject = [T] extends [{ + [K: string]: EffectAny; + }] ? Effect] ? Either.Either<_A, _E> : never; + } : { + -readonly [K in keyof T]: [T[K]] extends [Effect.Variance] ? _A : never; + }, Mode extends "either" ? never : keyof T extends never ? never : Mode extends "validate" ? { + -readonly [K in keyof T]: [T[K]] extends [Effect.Variance] ? Option.Option<_E> : never; + } : [T[keyof T]] extends [{ + [EffectTypeId]: { + _E: (_: never) => infer E; + }; + }] ? E : never, keyof T extends never ? never : [T[keyof T]] extends [{ + [EffectTypeId]: { + _R: (_: never) => infer R; + }; + }] ? R : never> : never; + /** + * @since 2.0.0 + */ + type IsDiscard = [Extract] extends [never] ? false : true; + /** + * @since 2.0.0 + */ + type ExtractMode = [A] extends [{ + mode: infer M; + }] ? M : "default"; + /** + * @since 2.0.0 + */ + type Return | Record, O extends NoExcessProperties<{ + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: boolean | undefined; + readonly mode?: "default" | "validate" | "either" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }, O>> = [Arg] extends [ReadonlyArray] ? ReturnTuple, ExtractMode> : [Arg] extends [Iterable] ? ReturnIterable, ExtractMode> : [Arg] extends [Record] ? ReturnObject, ExtractMode> : never; +} +/** + * Evaluates and runs each effect in the iterable, collecting only the + * successful results while discarding failures. + * + * **Details** + * + * This function function processes an iterable of effects and runs each one. If + * an effect is successful, its result is collected; if it fails, the result is + * discarded. This ensures that only successful outcomes are kept. + * + * **Options** + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const tasks = [ + * Effect.succeed(1), + * Effect.fail("Error 1"), + * Effect.succeed(2), + * Effect.fail("Error 2") + * ] + * + * const program = Effect.gen(function*() { + * const successfulResults = yield* Effect.allSuccesses(tasks) + * console.log(successfulResults) + * }) + * + * Effect.runFork(program) + * // Output: [1, 2] + * + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const allSuccesses: >(elements: Iterable, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; +} | undefined) => Effect>, never, Effect.Context>; +/** + * Drops elements until the effectful predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses an effectful + * predicate to determine when to stop dropping elements. It drops elements from + * the beginning of the collection until the predicate returns `true`. + * + * The predicate is a function that takes an element and its index in the + * collection and returns an effect that evaluates to a boolean. + * + * Once the predicate returns `true`, the remaining elements of the collection + * are returned. + * + * **Note**: The first element for which the predicate returns `true` is also + * dropped. + * + * **When to Use** + * + * This function allows you to conditionally skip over a part of the collection + * based on some criteria defined in the predicate. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.dropUntil(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [5, 6] + * ``` + * + * @see {@link dropWhile} for a similar function that drops elements while the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const dropUntil: { + /** + * Drops elements until the effectful predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses an effectful + * predicate to determine when to stop dropping elements. It drops elements from + * the beginning of the collection until the predicate returns `true`. + * + * The predicate is a function that takes an element and its index in the + * collection and returns an effect that evaluates to a boolean. + * + * Once the predicate returns `true`, the remaining elements of the collection + * are returned. + * + * **Note**: The first element for which the predicate returns `true` is also + * dropped. + * + * **When to Use** + * + * This function allows you to conditionally skip over a part of the collection + * based on some criteria defined in the predicate. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.dropUntil(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [5, 6] + * ``` + * + * @see {@link dropWhile} for a similar function that drops elements while the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (predicate: (a: NoInfer, i: number) => Effect): (elements: Iterable) => Effect, E, R>; + /** + * Drops elements until the effectful predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses an effectful + * predicate to determine when to stop dropping elements. It drops elements from + * the beginning of the collection until the predicate returns `true`. + * + * The predicate is a function that takes an element and its index in the + * collection and returns an effect that evaluates to a boolean. + * + * Once the predicate returns `true`, the remaining elements of the collection + * are returned. + * + * **Note**: The first element for which the predicate returns `true` is also + * dropped. + * + * **When to Use** + * + * This function allows you to conditionally skip over a part of the collection + * based on some criteria defined in the predicate. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.dropUntil(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [5, 6] + * ``` + * + * @see {@link dropWhile} for a similar function that drops elements while the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, predicate: (a: A, i: number) => Effect): Effect, E, R>; +}; +/** + * Drops elements as long as the predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses a predicate to + * decide whether to drop an element. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * As long as the predicate returns `true`, elements will continue to be dropped + * from the collection. + * + * Once the predicate returns `false`, the remaining elements are kept. + * + * **When to Use** + * + * This function allows you to discard elements from the start of a collection + * based on a condition, and only keep the rest when the condition no longer + * holds. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n <= 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.dropWhile(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [4, 5, 6] + * ``` + * + * @see {@link dropUntil} for a similar function that drops elements until the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const dropWhile: { + /** + * Drops elements as long as the predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses a predicate to + * decide whether to drop an element. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * As long as the predicate returns `true`, elements will continue to be dropped + * from the collection. + * + * Once the predicate returns `false`, the remaining elements are kept. + * + * **When to Use** + * + * This function allows you to discard elements from the start of a collection + * based on a condition, and only keep the rest when the condition no longer + * holds. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n <= 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.dropWhile(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [4, 5, 6] + * ``` + * + * @see {@link dropUntil} for a similar function that drops elements until the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (predicate: (a: NoInfer, i: number) => Effect): (elements: Iterable) => Effect, E, R>; + /** + * Drops elements as long as the predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses a predicate to + * decide whether to drop an element. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * As long as the predicate returns `true`, elements will continue to be dropped + * from the collection. + * + * Once the predicate returns `false`, the remaining elements are kept. + * + * **When to Use** + * + * This function allows you to discard elements from the start of a collection + * based on a condition, and only keep the rest when the condition no longer + * holds. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n <= 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.dropWhile(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [4, 5, 6] + * ``` + * + * @see {@link dropUntil} for a similar function that drops elements until the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, predicate: (a: A, i: number) => Effect): Effect, E, R>; +}; +/** + * Takes elements from a collection until the effectful predicate returns + * `true`. + * + * **Details** + * + * This function processes a collection of elements and uses an effectful + * predicate to decide when to stop taking elements. The elements are taken from + * the beginning of the collection until the predicate returns `true`. + * + * The predicate is a function that takes an element and its index in the + * collection, and returns an effect that resolves to a boolean. + * + * Once the predicate returns `true`, the remaining elements of the collection + * are discarded, and the function stops taking more elements. + * + * **Note**: The first element for which the predicate returns `true` is also + * included in the result. + * + * **When to Use** + * + * Use this function when you want to conditionally take elements from a + * collection based on a dynamic condition. For example, you may want to collect + * numbers from a list until a certain threshold is reached, or gather items + * until a specific condition is met. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.takeUntil(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [ 1, 2, 3, 4 ] + * ``` + * + * @see {@link takeWhile} for a similar function that takes elements while the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const takeUntil: { + /** + * Takes elements from a collection until the effectful predicate returns + * `true`. + * + * **Details** + * + * This function processes a collection of elements and uses an effectful + * predicate to decide when to stop taking elements. The elements are taken from + * the beginning of the collection until the predicate returns `true`. + * + * The predicate is a function that takes an element and its index in the + * collection, and returns an effect that resolves to a boolean. + * + * Once the predicate returns `true`, the remaining elements of the collection + * are discarded, and the function stops taking more elements. + * + * **Note**: The first element for which the predicate returns `true` is also + * included in the result. + * + * **When to Use** + * + * Use this function when you want to conditionally take elements from a + * collection based on a dynamic condition. For example, you may want to collect + * numbers from a list until a certain threshold is reached, or gather items + * until a specific condition is met. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.takeUntil(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [ 1, 2, 3, 4 ] + * ``` + * + * @see {@link takeWhile} for a similar function that takes elements while the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (predicate: (a: NoInfer, i: number) => Effect): (elements: Iterable) => Effect, E, R>; + /** + * Takes elements from a collection until the effectful predicate returns + * `true`. + * + * **Details** + * + * This function processes a collection of elements and uses an effectful + * predicate to decide when to stop taking elements. The elements are taken from + * the beginning of the collection until the predicate returns `true`. + * + * The predicate is a function that takes an element and its index in the + * collection, and returns an effect that resolves to a boolean. + * + * Once the predicate returns `true`, the remaining elements of the collection + * are discarded, and the function stops taking more elements. + * + * **Note**: The first element for which the predicate returns `true` is also + * included in the result. + * + * **When to Use** + * + * Use this function when you want to conditionally take elements from a + * collection based on a dynamic condition. For example, you may want to collect + * numbers from a list until a certain threshold is reached, or gather items + * until a specific condition is met. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.takeUntil(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [ 1, 2, 3, 4 ] + * ``` + * + * @see {@link takeWhile} for a similar function that takes elements while the + * predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, predicate: (a: NoInfer, i: number) => Effect): Effect, E, R>; +}; +/** + * Takes elements as long as the predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses a predicate to + * decide whether to take an element. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * As long as the predicate returns `true`, elements will continue to be taken + * from the collection. + * + * Once the predicate returns `false`, the remaining elements are discarded. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n <= 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.takeWhile(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [1, 2, 3] + * ``` + * + * @see {@link takeUntil} for a similar function that takes elements until the predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const takeWhile: { + /** + * Takes elements as long as the predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses a predicate to + * decide whether to take an element. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * As long as the predicate returns `true`, elements will continue to be taken + * from the collection. + * + * Once the predicate returns `false`, the remaining elements are discarded. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n <= 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.takeWhile(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [1, 2, 3] + * ``` + * + * @see {@link takeUntil} for a similar function that takes elements until the predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (predicate: (a: NoInfer, i: number) => Effect): (elements: Iterable) => Effect, E, R>; + /** + * Takes elements as long as the predicate returns `true`. + * + * **Details** + * + * This function processes a collection of elements and uses a predicate to + * decide whether to take an element. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * As long as the predicate returns `true`, elements will continue to be taken + * from the collection. + * + * Once the predicate returns `false`, the remaining elements are discarded. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5, 6] + * const predicate = (n: number, i: number) => Effect.succeed(n <= 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.takeWhile(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [1, 2, 3] + * ``` + * + * @see {@link takeUntil} for a similar function that takes elements until the predicate returns `true`. + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, predicate: (a: NoInfer, i: number) => Effect): Effect, E, R>; +}; +/** + * Determines whether all elements of the iterable satisfy the effectful + * predicate. + * + * **Details** + * + * This function checks whether every element in a given collection (an + * iterable) satisfies a condition defined by an effectful predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function will process each element and return `true` if all elements + * satisfy the predicate; otherwise, it returns `false`. + * + * **When to Use** + * + * This function is useful when you need to verify that all items in a + * collection meet certain criteria, even when the evaluation of each item + * involves effects, such as asynchronous checks or complex computations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [2, 4, 6, 8] + * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0) + * + * const program = Effect.gen(function*() { + * const allEven = yield* Effect.every(numbers, predicate) + * console.log(allEven) + * }) + * + * Effect.runFork(program) + * // Output: true + * ``` + * + * @see {@link exists} for a similar function that returns a boolean indicating + * whether **any** element satisfies the predicate. + * + * @since 2.0.0 + * @category Condition Checking + */ +export declare const every: { + /** + * Determines whether all elements of the iterable satisfy the effectful + * predicate. + * + * **Details** + * + * This function checks whether every element in a given collection (an + * iterable) satisfies a condition defined by an effectful predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function will process each element and return `true` if all elements + * satisfy the predicate; otherwise, it returns `false`. + * + * **When to Use** + * + * This function is useful when you need to verify that all items in a + * collection meet certain criteria, even when the evaluation of each item + * involves effects, such as asynchronous checks or complex computations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [2, 4, 6, 8] + * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0) + * + * const program = Effect.gen(function*() { + * const allEven = yield* Effect.every(numbers, predicate) + * console.log(allEven) + * }) + * + * Effect.runFork(program) + * // Output: true + * ``` + * + * @see {@link exists} for a similar function that returns a boolean indicating + * whether **any** element satisfies the predicate. + * + * @since 2.0.0 + * @category Condition Checking + */ + (predicate: (a: A, i: number) => Effect): (elements: Iterable) => Effect; + /** + * Determines whether all elements of the iterable satisfy the effectful + * predicate. + * + * **Details** + * + * This function checks whether every element in a given collection (an + * iterable) satisfies a condition defined by an effectful predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function will process each element and return `true` if all elements + * satisfy the predicate; otherwise, it returns `false`. + * + * **When to Use** + * + * This function is useful when you need to verify that all items in a + * collection meet certain criteria, even when the evaluation of each item + * involves effects, such as asynchronous checks or complex computations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [2, 4, 6, 8] + * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0) + * + * const program = Effect.gen(function*() { + * const allEven = yield* Effect.every(numbers, predicate) + * console.log(allEven) + * }) + * + * Effect.runFork(program) + * // Output: true + * ``` + * + * @see {@link exists} for a similar function that returns a boolean indicating + * whether **any** element satisfies the predicate. + * + * @since 2.0.0 + * @category Condition Checking + */ + (elements: Iterable, predicate: (a: A, i: number) => Effect): Effect; +}; +/** + * Determines whether any element of the iterable satisfies the effectual + * predicate. + * + * **Details** + * + * This function checks whether any element in a given collection (an iterable) + * satisfies a condition defined by an effectful predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function will process each element, and if any element satisfies the + * predicate (returns `true`), the function will immediately return `true`. + * + * If none of the elements satisfy the condition, it will return `false`. + * + * **When to Use** + * + * This function allows you to quickly check for a condition in a collection + * without having to manually iterate over it. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4] + * const predicate = (n: number, i: number) => Effect.succeed(n > 2) + * + * const program = Effect.gen(function*() { + * const hasLargeNumber = yield* Effect.exists(numbers, predicate) + * console.log(hasLargeNumber) + * }) + * + * Effect.runFork(program) + * // Output: true + * ``` + * + * @see {@link every} for a similar function that checks if **all** elements + * satisfy the predicate. + * + * @since 2.0.0 + * @category Condition Checking + */ +export declare const exists: { + /** + * Determines whether any element of the iterable satisfies the effectual + * predicate. + * + * **Details** + * + * This function checks whether any element in a given collection (an iterable) + * satisfies a condition defined by an effectful predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function will process each element, and if any element satisfies the + * predicate (returns `true`), the function will immediately return `true`. + * + * If none of the elements satisfy the condition, it will return `false`. + * + * **When to Use** + * + * This function allows you to quickly check for a condition in a collection + * without having to manually iterate over it. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4] + * const predicate = (n: number, i: number) => Effect.succeed(n > 2) + * + * const program = Effect.gen(function*() { + * const hasLargeNumber = yield* Effect.exists(numbers, predicate) + * console.log(hasLargeNumber) + * }) + * + * Effect.runFork(program) + * // Output: true + * ``` + * + * @see {@link every} for a similar function that checks if **all** elements + * satisfy the predicate. + * + * @since 2.0.0 + * @category Condition Checking + */ + (predicate: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (elements: Iterable) => Effect; + /** + * Determines whether any element of the iterable satisfies the effectual + * predicate. + * + * **Details** + * + * This function checks whether any element in a given collection (an iterable) + * satisfies a condition defined by an effectful predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function will process each element, and if any element satisfies the + * predicate (returns `true`), the function will immediately return `true`. + * + * If none of the elements satisfy the condition, it will return `false`. + * + * **When to Use** + * + * This function allows you to quickly check for a condition in a collection + * without having to manually iterate over it. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4] + * const predicate = (n: number, i: number) => Effect.succeed(n > 2) + * + * const program = Effect.gen(function*() { + * const hasLargeNumber = yield* Effect.exists(numbers, predicate) + * console.log(hasLargeNumber) + * }) + * + * Effect.runFork(program) + * // Output: true + * ``` + * + * @see {@link every} for a similar function that checks if **all** elements + * satisfy the predicate. + * + * @since 2.0.0 + * @category Condition Checking + */ + (elements: Iterable, predicate: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect; +}; +/** + * Filters an iterable using the specified effectful predicate. + * + * **Details** + * + * This function filters a collection (an iterable) by applying an effectful + * predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function processes each element in the collection and keeps only those + * that satisfy the condition defined by the predicate. + * + * **Options** + * + * You can also adjust the behavior with options such as concurrency, batching, + * or whether to negate the condition. + * + * **When to Use** + * + * This function allows you to selectively keep or remove elements based on a + * condition that may involve asynchronous or side-effect-causing operations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.filter(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [2, 4] + * ``` + * + * @since 2.0.0 + * @category Filtering + */ +export declare const filter: { + /** + * Filters an iterable using the specified effectful predicate. + * + * **Details** + * + * This function filters a collection (an iterable) by applying an effectful + * predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function processes each element in the collection and keeps only those + * that satisfy the condition defined by the predicate. + * + * **Options** + * + * You can also adjust the behavior with options such as concurrency, batching, + * or whether to negate the condition. + * + * **When to Use** + * + * This function allows you to selectively keep or remove elements based on a + * condition that may involve asynchronous or side-effect-causing operations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.filter(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [2, 4] + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (predicate: (a: NoInfer, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly negate?: boolean | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (elements: Iterable) => Effect, E, R>; + /** + * Filters an iterable using the specified effectful predicate. + * + * **Details** + * + * This function filters a collection (an iterable) by applying an effectful + * predicate. + * + * The predicate is a function that takes an element and its index, and it + * returns an effect that evaluates to a boolean. + * + * The function processes each element in the collection and keeps only those + * that satisfy the condition defined by the predicate. + * + * **Options** + * + * You can also adjust the behavior with options such as concurrency, batching, + * or whether to negate the condition. + * + * **When to Use** + * + * This function allows you to selectively keep or remove elements based on a + * condition that may involve asynchronous or side-effect-causing operations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * const predicate = (n: number, i: number) => Effect.succeed(n % 2 === 0) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.filter(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: [2, 4] + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (elements: Iterable, predicate: (a: NoInfer, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly negate?: boolean | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect, E, R>; +}; +/** + * Filters and maps elements sequentially in one operation. + * + * This function processes each element one by one. It applies a function that + * returns an `Option` to each element. If the function returns `Some`, the + * element is kept; if it returns `None`, the element is removed. The operation + * is done sequentially for each element. + * + * **Example** + * + * ```ts + * import { Console, Effect, Option } from "effect" + * + * const task = (n: number) => + * Effect.succeed(n).pipe( + * Effect.delay(1000 - (n * 100)), + * Effect.tap(Console.log(`task${n} done`)) + * ) + * + * const program = Effect.filterMap( + * [task(1), task(2), task(3), task(4)], + * (n) => n % 2 === 0 ? Option.some(n) : Option.none() + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // task1 done + * // task2 done + * // task3 done + * // task4 done + * // [ 2, 4 ] + * ``` + * + * @since 2.0.0 + * @category Filtering + */ +export declare const filterMap: { + /** + * Filters and maps elements sequentially in one operation. + * + * This function processes each element one by one. It applies a function that + * returns an `Option` to each element. If the function returns `Some`, the + * element is kept; if it returns `None`, the element is removed. The operation + * is done sequentially for each element. + * + * **Example** + * + * ```ts + * import { Console, Effect, Option } from "effect" + * + * const task = (n: number) => + * Effect.succeed(n).pipe( + * Effect.delay(1000 - (n * 100)), + * Effect.tap(Console.log(`task${n} done`)) + * ) + * + * const program = Effect.filterMap( + * [task(1), task(2), task(3), task(4)], + * (n) => n % 2 === 0 ? Option.some(n) : Option.none() + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // task1 done + * // task2 done + * // task3 done + * // task4 done + * // [ 2, 4 ] + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + , B>(pf: (a: Effect.Success) => Option.Option): (elements: Iterable) => Effect, Effect.Error, Effect.Context>; + /** + * Filters and maps elements sequentially in one operation. + * + * This function processes each element one by one. It applies a function that + * returns an `Option` to each element. If the function returns `Some`, the + * element is kept; if it returns `None`, the element is removed. The operation + * is done sequentially for each element. + * + * **Example** + * + * ```ts + * import { Console, Effect, Option } from "effect" + * + * const task = (n: number) => + * Effect.succeed(n).pipe( + * Effect.delay(1000 - (n * 100)), + * Effect.tap(Console.log(`task${n} done`)) + * ) + * + * const program = Effect.filterMap( + * [task(1), task(2), task(3), task(4)], + * (n) => n % 2 === 0 ? Option.some(n) : Option.none() + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // task1 done + * // task2 done + * // task3 done + * // task4 done + * // [ 2, 4 ] + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + , B>(elements: Iterable, pf: (a: Effect.Success) => Option.Option): Effect, Effect.Error, Effect.Context>; +}; +/** + * Returns the first element that satisfies the effectful predicate. + * + * **Details** + * + * This function processes a collection of elements and applies an effectful + * predicate to each element. + * + * The predicate is a function that takes an element and its index in the + * collection, and it returns an effect that evaluates to a boolean. + * + * The function stops as soon as it finds the first element for which the + * predicate returns `true` and returns that element wrapped in an `Option`. + * + * If no element satisfies the predicate, the result will be `None`. + * + * **When to Use** + * + * This function allows you to efficiently find an element that meets a specific + * condition, even when the evaluation involves effects like asynchronous + * operations or side effects. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.findFirst(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: { _id: 'Option', _tag: 'Some', value: 4 } + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const findFirst: { + /** + * Returns the first element that satisfies the effectful predicate. + * + * **Details** + * + * This function processes a collection of elements and applies an effectful + * predicate to each element. + * + * The predicate is a function that takes an element and its index in the + * collection, and it returns an effect that evaluates to a boolean. + * + * The function stops as soon as it finds the first element for which the + * predicate returns `true` and returns that element wrapped in an `Option`. + * + * If no element satisfies the predicate, the result will be `None`. + * + * **When to Use** + * + * This function allows you to efficiently find an element that meets a specific + * condition, even when the evaluation involves effects like asynchronous + * operations or side effects. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.findFirst(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: { _id: 'Option', _tag: 'Some', value: 4 } + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (predicate: (a: NoInfer, i: number) => Effect): (elements: Iterable) => Effect, E, R>; + /** + * Returns the first element that satisfies the effectful predicate. + * + * **Details** + * + * This function processes a collection of elements and applies an effectful + * predicate to each element. + * + * The predicate is a function that takes an element and its index in the + * collection, and it returns an effect that evaluates to a boolean. + * + * The function stops as soon as it finds the first element for which the + * predicate returns `true` and returns that element wrapped in an `Option`. + * + * If no element satisfies the predicate, the result will be `None`. + * + * **When to Use** + * + * This function allows you to efficiently find an element that meets a specific + * condition, even when the evaluation involves effects like asynchronous + * operations or side effects. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [1, 2, 3, 4, 5] + * const predicate = (n: number, i: number) => Effect.succeed(n > 3) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.findFirst(numbers, predicate) + * console.log(result) + * }) + * + * Effect.runFork(program) + * // Output: { _id: 'Option', _tag: 'Some', value: 4 } + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, predicate: (a: NoInfer, i: number) => Effect): Effect, E, R>; +}; +/** + * Executes an effectful operation for each element in an `Iterable`. + * + * **Details** + * + * This function applies a provided operation to each element in the iterable, + * producing a new effect that returns an array of results. + * + * If any effect fails, the iteration stops immediately (short-circuiting), and + * the error is propagated. + * + * **Concurrency** + * + * The `concurrency` option controls how many operations are performed + * concurrently. By default, the operations are performed sequentially. + * + * **Discarding Results** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * **Example** (Applying Effects to Iterable Elements) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.forEach([1, 2, 3, 4, 5], (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)) + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // [ 2, 4, 6, 8, 10 ] + * ``` + * + * **Example** (Discarding Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Apply effects but discard the results + * const result = Effect.forEach( + * [1, 2, 3, 4, 5], + * (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)), + * { discard: true } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // undefined + * ``` + * + * @see {@link all} for combining multiple effects into one. + * + * @since 2.0.0 + * @category Looping + */ +export declare const forEach: { + /** + * Executes an effectful operation for each element in an `Iterable`. + * + * **Details** + * + * This function applies a provided operation to each element in the iterable, + * producing a new effect that returns an array of results. + * + * If any effect fails, the iteration stops immediately (short-circuiting), and + * the error is propagated. + * + * **Concurrency** + * + * The `concurrency` option controls how many operations are performed + * concurrently. By default, the operations are performed sequentially. + * + * **Discarding Results** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * **Example** (Applying Effects to Iterable Elements) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.forEach([1, 2, 3, 4, 5], (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)) + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // [ 2, 4, 6, 8, 10 ] + * ``` + * + * **Example** (Discarding Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Apply effects but discard the results + * const result = Effect.forEach( + * [1, 2, 3, 4, 5], + * (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)), + * { discard: true } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // undefined + * ``` + * + * @see {@link all} for combining multiple effects into one. + * + * @since 2.0.0 + * @category Looping + */ + >(f: (a: RA.ReadonlyArray.Infer, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: false | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (self: S) => Effect, E, R>; + /** + * Executes an effectful operation for each element in an `Iterable`. + * + * **Details** + * + * This function applies a provided operation to each element in the iterable, + * producing a new effect that returns an array of results. + * + * If any effect fails, the iteration stops immediately (short-circuiting), and + * the error is propagated. + * + * **Concurrency** + * + * The `concurrency` option controls how many operations are performed + * concurrently. By default, the operations are performed sequentially. + * + * **Discarding Results** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * **Example** (Applying Effects to Iterable Elements) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.forEach([1, 2, 3, 4, 5], (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)) + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // [ 2, 4, 6, 8, 10 ] + * ``` + * + * **Example** (Discarding Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Apply effects but discard the results + * const result = Effect.forEach( + * [1, 2, 3, 4, 5], + * (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)), + * { discard: true } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // undefined + * ``` + * + * @see {@link all} for combining multiple effects into one. + * + * @since 2.0.0 + * @category Looping + */ + (f: (a: A, i: number) => Effect, options: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard: true; + readonly concurrentFinalizers?: boolean | undefined; + }): (self: Iterable) => Effect; + /** + * Executes an effectful operation for each element in an `Iterable`. + * + * **Details** + * + * This function applies a provided operation to each element in the iterable, + * producing a new effect that returns an array of results. + * + * If any effect fails, the iteration stops immediately (short-circuiting), and + * the error is propagated. + * + * **Concurrency** + * + * The `concurrency` option controls how many operations are performed + * concurrently. By default, the operations are performed sequentially. + * + * **Discarding Results** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * **Example** (Applying Effects to Iterable Elements) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.forEach([1, 2, 3, 4, 5], (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)) + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // [ 2, 4, 6, 8, 10 ] + * ``` + * + * **Example** (Discarding Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Apply effects but discard the results + * const result = Effect.forEach( + * [1, 2, 3, 4, 5], + * (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)), + * { discard: true } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // undefined + * ``` + * + * @see {@link all} for combining multiple effects into one. + * + * @since 2.0.0 + * @category Looping + */ + >(self: S, f: (a: RA.ReadonlyArray.Infer, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: false | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect, E, R>; + /** + * Executes an effectful operation for each element in an `Iterable`. + * + * **Details** + * + * This function applies a provided operation to each element in the iterable, + * producing a new effect that returns an array of results. + * + * If any effect fails, the iteration stops immediately (short-circuiting), and + * the error is propagated. + * + * **Concurrency** + * + * The `concurrency` option controls how many operations are performed + * concurrently. By default, the operations are performed sequentially. + * + * **Discarding Results** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * **Example** (Applying Effects to Iterable Elements) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.forEach([1, 2, 3, 4, 5], (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)) + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // [ 2, 4, 6, 8, 10 ] + * ``` + * + * **Example** (Discarding Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Apply effects but discard the results + * const result = Effect.forEach( + * [1, 2, 3, 4, 5], + * (n, index) => + * Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)), + * { discard: true } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at index 0 + * // Currently at index 1 + * // Currently at index 2 + * // Currently at index 3 + * // Currently at index 4 + * // undefined + * ``` + * + * @see {@link all} for combining multiple effects into one. + * + * @since 2.0.0 + * @category Looping + */ + (self: Iterable, f: (a: A, i: number) => Effect, options: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard: true; + readonly concurrentFinalizers?: boolean | undefined; + }): Effect; +}; +/** + * Returns the first element of the iterable if the collection is non-empty, or + * fails with the error `NoSuchElementException` if the collection is empty. + * + * **When to Use** + * + * This function is useful when you need to retrieve the first item from a + * collection and want to handle the case where the collection might be empty + * without causing an unhandled exception. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // Simulate an async operation + * const fetchNumbers = Effect.succeed([1, 2, 3]).pipe(Effect.delay("100 millis")) + * + * const program = Effect.gen(function*() { + * const firstElement = yield* Effect.head(fetchNumbers) + * console.log(firstElement) + * }) + * + * Effect.runFork(program) + * // Output: 1 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const head: (self: Effect, E, R>) => Effect; +/** + * Merges an `Iterable>` to a single effect. + * + * **Details** + * + * This function takes an iterable of effects and combines them into a single + * effect. It does this by iterating over each effect in the collection and + * applying a function that accumulates results into a "zero" value, which + * starts with an initial value and is updated with each effect's success. + * + * The provided function `f` is called for each element in the iterable, + * allowing you to specify how to combine the results. + * + * **Options** + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [Effect.succeed(1), Effect.succeed(2), Effect.succeed(3)] + * const add = (sum: number, value: number, i: number) => sum + value + * const zero = 0 + * + * const program = Effect.gen(function*() { + * const total = yield* Effect.mergeAll(numbers, zero, add) + * console.log(total) + * }) + * + * Effect.runFork(program) + * // Output: 6 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const mergeAll: { + /** + * Merges an `Iterable>` to a single effect. + * + * **Details** + * + * This function takes an iterable of effects and combines them into a single + * effect. It does this by iterating over each effect in the collection and + * applying a function that accumulates results into a "zero" value, which + * starts with an initial value and is updated with each effect's success. + * + * The provided function `f` is called for each element in the iterable, + * allowing you to specify how to combine the results. + * + * **Options** + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [Effect.succeed(1), Effect.succeed(2), Effect.succeed(3)] + * const add = (sum: number, value: number, i: number) => sum + value + * const zero = 0 + * + * const program = Effect.gen(function*() { + * const total = yield* Effect.mergeAll(numbers, zero, add) + * console.log(total) + * }) + * + * Effect.runFork(program) + * // Output: 6 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + >(zero: Z, f: (z: Z, a: Effect.Success, i: number) => Z, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (elements: Iterable) => Effect, Effect.Context>; + /** + * Merges an `Iterable>` to a single effect. + * + * **Details** + * + * This function takes an iterable of effects and combines them into a single + * effect. It does this by iterating over each effect in the collection and + * applying a function that accumulates results into a "zero" value, which + * starts with an initial value and is updated with each effect's success. + * + * The provided function `f` is called for each element in the iterable, + * allowing you to specify how to combine the results. + * + * **Options** + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const numbers = [Effect.succeed(1), Effect.succeed(2), Effect.succeed(3)] + * const add = (sum: number, value: number, i: number) => sum + value + * const zero = 0 + * + * const program = Effect.gen(function*() { + * const total = yield* Effect.mergeAll(numbers, zero, add) + * console.log(total) + * }) + * + * Effect.runFork(program) + * // Output: 6 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + , Z>(elements: Iterable, zero: Z, f: (z: Z, a: Effect.Success, i: number) => Z, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect, Effect.Context>; +}; +/** + * Processes an iterable and applies an effectful function to each element, + * categorizing the results into successes and failures. + * + * **Details** + * + * This function processes each element in the provided iterable by applying an + * effectful function to it. The results are then categorized into two separate + * lists: one for failures and another for successes. This separation allows you + * to handle the two categories differently. Failures are collected in a list + * without interrupting the processing of the remaining elements, so the + * operation continues even if some elements fail. This is particularly useful + * when you need to handle both successful and failed results separately, + * without stopping the entire process on encountering a failure. + * + * **When to Use** + * + * Use this function when you want to process a collection of items and handle + * errors or failures without interrupting the processing of other items. It's + * useful when you need to distinguish between successful and failed results and + * process them separately, for example, when logging errors while continuing to + * work with valid data. The function ensures that failures are captured, while + * successes are processed normally. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect<[string[], number[]], never, never> + * // ▼ + * const program = Effect.partition([0, 1, 2, 3, 4], (n) => { + * if (n % 2 === 0) { + * return Effect.succeed(n) + * } else { + * return Effect.fail(`${n} is not even`) + * } + * }) + * + * Effect.runPromise(program).then(console.log, console.error) + * // Output: + * // [ [ '1 is not even', '3 is not even' ], [ 0, 2, 4 ] ] + * ``` + * + * @see {@link validateAll} for a function that either collects all failures or all successes. + * @see {@link validateFirst} for a function that stops at the first success. + * + * @since 2.0.0 + * @category Error Accumulation + */ +export declare const partition: { + /** + * Processes an iterable and applies an effectful function to each element, + * categorizing the results into successes and failures. + * + * **Details** + * + * This function processes each element in the provided iterable by applying an + * effectful function to it. The results are then categorized into two separate + * lists: one for failures and another for successes. This separation allows you + * to handle the two categories differently. Failures are collected in a list + * without interrupting the processing of the remaining elements, so the + * operation continues even if some elements fail. This is particularly useful + * when you need to handle both successful and failed results separately, + * without stopping the entire process on encountering a failure. + * + * **When to Use** + * + * Use this function when you want to process a collection of items and handle + * errors or failures without interrupting the processing of other items. It's + * useful when you need to distinguish between successful and failed results and + * process them separately, for example, when logging errors while continuing to + * work with valid data. The function ensures that failures are captured, while + * successes are processed normally. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect<[string[], number[]], never, never> + * // ▼ + * const program = Effect.partition([0, 1, 2, 3, 4], (n) => { + * if (n % 2 === 0) { + * return Effect.succeed(n) + * } else { + * return Effect.fail(`${n} is not even`) + * } + * }) + * + * Effect.runPromise(program).then(console.log, console.error) + * // Output: + * // [ [ '1 is not even', '3 is not even' ], [ 0, 2, 4 ] ] + * ``` + * + * @see {@link validateAll} for a function that either collects all failures or all successes. + * @see {@link validateFirst} for a function that stops at the first success. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (f: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (elements: Iterable) => Effect<[excluded: Array, satisfying: Array], never, R>; + /** + * Processes an iterable and applies an effectful function to each element, + * categorizing the results into successes and failures. + * + * **Details** + * + * This function processes each element in the provided iterable by applying an + * effectful function to it. The results are then categorized into two separate + * lists: one for failures and another for successes. This separation allows you + * to handle the two categories differently. Failures are collected in a list + * without interrupting the processing of the remaining elements, so the + * operation continues even if some elements fail. This is particularly useful + * when you need to handle both successful and failed results separately, + * without stopping the entire process on encountering a failure. + * + * **When to Use** + * + * Use this function when you want to process a collection of items and handle + * errors or failures without interrupting the processing of other items. It's + * useful when you need to distinguish between successful and failed results and + * process them separately, for example, when logging errors while continuing to + * work with valid data. The function ensures that failures are captured, while + * successes are processed normally. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect<[string[], number[]], never, never> + * // ▼ + * const program = Effect.partition([0, 1, 2, 3, 4], (n) => { + * if (n % 2 === 0) { + * return Effect.succeed(n) + * } else { + * return Effect.fail(`${n} is not even`) + * } + * }) + * + * Effect.runPromise(program).then(console.log, console.error) + * // Output: + * // [ [ '1 is not even', '3 is not even' ], [ 0, 2, 4 ] ] + * ``` + * + * @see {@link validateAll} for a function that either collects all failures or all successes. + * @see {@link validateFirst} for a function that stops at the first success. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (elements: Iterable, f: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect<[excluded: Array, satisfying: Array], never, R>; +}; +/** + * Reduces an `Iterable` using an effectual function `f`, working + * sequentially from left to right. + * + * **Details** + * + * This function takes an iterable and applies a function `f` to each element in + * the iterable. The function works sequentially, starting with an initial value + * `zero` and then combining it with each element in the collection. The + * provided function `f` is called for each element in the iterable, allowing + * you to accumulate a result based on the current value and the element being + * processed. + * + * **When to Use** + * + * The function is often used for operations like summing a collection of + * numbers or combining results from multiple tasks. It ensures that operations + * are performed one after the other, maintaining the order of the elements. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduce( + * [1, 2, 3, 4], + * 0, + * (acc, id, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // Order 4 processed + * // 1000 + * ``` + * + * @see {@link reduceWhile} for a similar function that stops the process based on a predicate. + * @see {@link reduceRight} for a similar function that works from right to left. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const reduce: { + /** + * Reduces an `Iterable` using an effectual function `f`, working + * sequentially from left to right. + * + * **Details** + * + * This function takes an iterable and applies a function `f` to each element in + * the iterable. The function works sequentially, starting with an initial value + * `zero` and then combining it with each element in the collection. The + * provided function `f` is called for each element in the iterable, allowing + * you to accumulate a result based on the current value and the element being + * processed. + * + * **When to Use** + * + * The function is often used for operations like summing a collection of + * numbers or combining results from multiple tasks. It ensures that operations + * are performed one after the other, maintaining the order of the elements. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduce( + * [1, 2, 3, 4], + * 0, + * (acc, id, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // Order 4 processed + * // 1000 + * ``` + * + * @see {@link reduceWhile} for a similar function that stops the process based on a predicate. + * @see {@link reduceRight} for a similar function that works from right to left. + * + * @since 2.0.0 + * @category Collecting + */ + (zero: Z, f: (z: Z, a: A, i: number) => Effect): (elements: Iterable) => Effect; + /** + * Reduces an `Iterable` using an effectual function `f`, working + * sequentially from left to right. + * + * **Details** + * + * This function takes an iterable and applies a function `f` to each element in + * the iterable. The function works sequentially, starting with an initial value + * `zero` and then combining it with each element in the collection. The + * provided function `f` is called for each element in the iterable, allowing + * you to accumulate a result based on the current value and the element being + * processed. + * + * **When to Use** + * + * The function is often used for operations like summing a collection of + * numbers or combining results from multiple tasks. It ensures that operations + * are performed one after the other, maintaining the order of the elements. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduce( + * [1, 2, 3, 4], + * 0, + * (acc, id, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // Order 4 processed + * // 1000 + * ``` + * + * @see {@link reduceWhile} for a similar function that stops the process based on a predicate. + * @see {@link reduceRight} for a similar function that works from right to left. + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, zero: Z, f: (z: Z, a: A, i: number) => Effect): Effect; +}; +/** + * Reduces an `Iterable` using an effectual function `body`, working + * sequentially from left to right, stopping the process early when the + * predicate `while` is not satisfied. + * + * **Details** + * + * This function processes a collection of elements, applying a function `body` + * to reduce them to a single value, starting from the first element. It checks + * the value of the accumulator against a predicate (`while`). If at any point + * the predicate returns `false`, the reduction stops, and the accumulated + * result is returned. + * + * **When to Use** + * + * Use this function when you need to reduce a collection of elements, but only + * continue the process as long as a certain condition holds true. For example, + * if you want to sum values in a list but stop as soon as the sum exceeds a + * certain threshold, you can use this function. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceWhile( + * [1, 2, 3, 4], + * 0, + * { + * body: (acc, id, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)), + * while: (acc) => acc < 500 + * } + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // 600 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const reduceWhile: { + /** + * Reduces an `Iterable` using an effectual function `body`, working + * sequentially from left to right, stopping the process early when the + * predicate `while` is not satisfied. + * + * **Details** + * + * This function processes a collection of elements, applying a function `body` + * to reduce them to a single value, starting from the first element. It checks + * the value of the accumulator against a predicate (`while`). If at any point + * the predicate returns `false`, the reduction stops, and the accumulated + * result is returned. + * + * **When to Use** + * + * Use this function when you need to reduce a collection of elements, but only + * continue the process as long as a certain condition holds true. For example, + * if you want to sum values in a list but stop as soon as the sum exceeds a + * certain threshold, you can use this function. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceWhile( + * [1, 2, 3, 4], + * 0, + * { + * body: (acc, id, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)), + * while: (acc) => acc < 500 + * } + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // 600 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (zero: Z, options: { + readonly while: Predicate; + readonly body: (s: Z, a: A, i: number) => Effect; + }): (elements: Iterable) => Effect; + /** + * Reduces an `Iterable` using an effectual function `body`, working + * sequentially from left to right, stopping the process early when the + * predicate `while` is not satisfied. + * + * **Details** + * + * This function processes a collection of elements, applying a function `body` + * to reduce them to a single value, starting from the first element. It checks + * the value of the accumulator against a predicate (`while`). If at any point + * the predicate returns `false`, the reduction stops, and the accumulated + * result is returned. + * + * **When to Use** + * + * Use this function when you need to reduce a collection of elements, but only + * continue the process as long as a certain condition holds true. For example, + * if you want to sum values in a list but stop as soon as the sum exceeds a + * certain threshold, you can use this function. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceWhile( + * [1, 2, 3, 4], + * 0, + * { + * body: (acc, id, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)), + * while: (acc) => acc < 500 + * } + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // 600 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, zero: Z, options: { + readonly while: Predicate; + readonly body: (s: Z, a: A, i: number) => Effect; + }): Effect; +}; +/** + * Reduces an `Iterable` using an effectual function `f`, working + * sequentially from right to left. + * + * **Details** + * + * This function takes an iterable and applies a function `f` to each element in + * the iterable. The function works sequentially, starting with an initial value + * `zero` and then combining it with each element in the collection. The + * provided function `f` is called for each element in the iterable, allowing + * you to accumulate a result based on the current value and the element being + * processed. + * + * **When to Use** + * + * The function is often used for operations like summing a collection of + * numbers or combining results from multiple tasks. It ensures that operations + * are performed one after the other, maintaining the order of the elements. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceRight( + * [1, 2, 3, 4], + * 0, + * (id, acc, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 4 processed + * // Order 3 processed + * // Order 2 processed + * // Order 1 processed + * // 1000 + * ``` + * + * @see {@link reduce} for a similar function that works from left to right. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const reduceRight: { + /** + * Reduces an `Iterable` using an effectual function `f`, working + * sequentially from right to left. + * + * **Details** + * + * This function takes an iterable and applies a function `f` to each element in + * the iterable. The function works sequentially, starting with an initial value + * `zero` and then combining it with each element in the collection. The + * provided function `f` is called for each element in the iterable, allowing + * you to accumulate a result based on the current value and the element being + * processed. + * + * **When to Use** + * + * The function is often used for operations like summing a collection of + * numbers or combining results from multiple tasks. It ensures that operations + * are performed one after the other, maintaining the order of the elements. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceRight( + * [1, 2, 3, 4], + * 0, + * (id, acc, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 4 processed + * // Order 3 processed + * // Order 2 processed + * // Order 1 processed + * // 1000 + * ``` + * + * @see {@link reduce} for a similar function that works from left to right. + * + * @since 2.0.0 + * @category Collecting + */ + (zero: Z, f: (a: A, z: Z, i: number) => Effect): (elements: Iterable) => Effect; + /** + * Reduces an `Iterable` using an effectual function `f`, working + * sequentially from right to left. + * + * **Details** + * + * This function takes an iterable and applies a function `f` to each element in + * the iterable. The function works sequentially, starting with an initial value + * `zero` and then combining it with each element in the collection. The + * provided function `f` is called for each element in the iterable, allowing + * you to accumulate a result based on the current value and the element being + * processed. + * + * **When to Use** + * + * The function is often used for operations like summing a collection of + * numbers or combining results from multiple tasks. It ensures that operations + * are performed one after the other, maintaining the order of the elements. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceRight( + * [1, 2, 3, 4], + * 0, + * (id, acc, i) => + * processOrder(id) + * .pipe(Effect.map((order) => acc + order.price)) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 4 processed + * // Order 3 processed + * // Order 2 processed + * // Order 1 processed + * // 1000 + * ``` + * + * @see {@link reduce} for a similar function that works from left to right. + * + * @since 2.0.0 + * @category Collecting + */ + (elements: Iterable, zero: Z, f: (a: A, z: Z, i: number) => Effect): Effect; +}; +/** + * Reduces an `Iterable>` to a single effect. + * + * **Details** + * + * This function processes a collection of effects and combines them into one + * single effect. It starts with an initial effect (`zero`) and applies a + * function `f` to each element in the collection. + * + * **Options** + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceEffect( + * [processOrder(1), processOrder(2), processOrder(3), processOrder(4)], + * Effect.succeed(0), + * (acc, order, i) => acc + order.price + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // Order 4 processed + * // 1000 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const reduceEffect: { + /** + * Reduces an `Iterable>` to a single effect. + * + * **Details** + * + * This function processes a collection of effects and combines them into one + * single effect. It starts with an initial effect (`zero`) and applies a + * function `f` to each element in the collection. + * + * **Options** + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceEffect( + * [processOrder(1), processOrder(2), processOrder(3), processOrder(4)], + * Effect.succeed(0), + * (acc, order, i) => acc + order.price + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // Order 4 processed + * // 1000 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + >(zero: Effect, f: (z: NoInfer, a: Effect.Success, i: number) => Z, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (elements: Iterable) => Effect, R | Effect.Context>; + /** + * Reduces an `Iterable>` to a single effect. + * + * **Details** + * + * This function processes a collection of effects and combines them into one + * single effect. It starts with an initial effect (`zero`) and applies a + * function `f` to each element in the collection. + * + * **Options** + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const processOrder = (id: number) => + * Effect.succeed({ id, price: 100 * id }) + * .pipe(Effect.tap(() => Console.log(`Order ${id} processed`)), Effect.delay(500 - (id * 100))) + * + * const program = Effect.reduceEffect( + * [processOrder(1), processOrder(2), processOrder(3), processOrder(4)], + * Effect.succeed(0), + * (acc, order, i) => acc + order.price + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Order 1 processed + * // Order 2 processed + * // Order 3 processed + * // Order 4 processed + * // 1000 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + , Z, E, R>(elements: Iterable, zero: Effect, f: (z: NoInfer, a: Effect.Success, i: number) => Z, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect, R | Effect.Context>; +}; +/** + * Replicates the given effect `n` times. + * + * **Details** + * + * This function takes an effect and replicates it a specified number of times + * (`n`). The result is an array of `n` effects, each of which is identical to + * the original effect. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const task = Effect.succeed("Hello, World!").pipe( + * Effect.tap(Console.log) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times + * const tasks = Effect.replicate(task, 3) + * for (const t of tasks) { + * // Run each task + * yield* t + * } + * }) + * + * Effect.runFork(program) + * // Output: + * // Hello, World! + * // Hello, World! + * // Hello, World! + * ``` + * + * @since 2.0.0 + */ +export declare const replicate: { + /** + * Replicates the given effect `n` times. + * + * **Details** + * + * This function takes an effect and replicates it a specified number of times + * (`n`). The result is an array of `n` effects, each of which is identical to + * the original effect. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const task = Effect.succeed("Hello, World!").pipe( + * Effect.tap(Console.log) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times + * const tasks = Effect.replicate(task, 3) + * for (const t of tasks) { + * // Run each task + * yield* t + * } + * }) + * + * Effect.runFork(program) + * // Output: + * // Hello, World! + * // Hello, World! + * // Hello, World! + * ``` + * + * @since 2.0.0 + */ + (n: number): (self: Effect) => Array>; + /** + * Replicates the given effect `n` times. + * + * **Details** + * + * This function takes an effect and replicates it a specified number of times + * (`n`). The result is an array of `n` effects, each of which is identical to + * the original effect. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const task = Effect.succeed("Hello, World!").pipe( + * Effect.tap(Console.log) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times + * const tasks = Effect.replicate(task, 3) + * for (const t of tasks) { + * // Run each task + * yield* t + * } + * }) + * + * Effect.runFork(program) + * // Output: + * // Hello, World! + * // Hello, World! + * // Hello, World! + * ``` + * + * @since 2.0.0 + */ + (self: Effect, n: number): Array>; +}; +/** + * Performs this effect the specified number of times and collects the results. + * + * **Details** + * + * This function repeats an effect multiple times and collects the results into + * an array. You specify how many times to execute the effect, and it runs that + * many times, either in sequence or concurrently depending on the provided + * options. + * + * **Options** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * let counter = 0 + * + * const task = Effect.sync(() => ++counter).pipe( + * Effect.tap(() => Console.log(`Task completed`)) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times and collect the results + * const results = yield* Effect.replicateEffect(task, 3) + * yield* Console.log(`Results: ${results.join(", ")}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // Task completed + * // Task completed + * // Task completed + * // Results: 1, 2, 3 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ +export declare const replicateEffect: { + /** + * Performs this effect the specified number of times and collects the results. + * + * **Details** + * + * This function repeats an effect multiple times and collects the results into + * an array. You specify how many times to execute the effect, and it runs that + * many times, either in sequence or concurrently depending on the provided + * options. + * + * **Options** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * let counter = 0 + * + * const task = Effect.sync(() => ++counter).pipe( + * Effect.tap(() => Console.log(`Task completed`)) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times and collect the results + * const results = yield* Effect.replicateEffect(task, 3) + * yield* Console.log(`Results: ${results.join(", ")}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // Task completed + * // Task completed + * // Task completed + * // Results: 1, 2, 3 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (n: number, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: false | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }): (self: Effect) => Effect, E, R>; + /** + * Performs this effect the specified number of times and collects the results. + * + * **Details** + * + * This function repeats an effect multiple times and collects the results into + * an array. You specify how many times to execute the effect, and it runs that + * many times, either in sequence or concurrently depending on the provided + * options. + * + * **Options** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * let counter = 0 + * + * const task = Effect.sync(() => ++counter).pipe( + * Effect.tap(() => Console.log(`Task completed`)) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times and collect the results + * const results = yield* Effect.replicateEffect(task, 3) + * yield* Console.log(`Results: ${results.join(", ")}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // Task completed + * // Task completed + * // Task completed + * // Results: 1, 2, 3 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (n: number, options: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard: true; + readonly concurrentFinalizers?: boolean | undefined; + }): (self: Effect) => Effect; + /** + * Performs this effect the specified number of times and collects the results. + * + * **Details** + * + * This function repeats an effect multiple times and collects the results into + * an array. You specify how many times to execute the effect, and it runs that + * many times, either in sequence or concurrently depending on the provided + * options. + * + * **Options** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * let counter = 0 + * + * const task = Effect.sync(() => ++counter).pipe( + * Effect.tap(() => Console.log(`Task completed`)) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times and collect the results + * const results = yield* Effect.replicateEffect(task, 3) + * yield* Console.log(`Results: ${results.join(", ")}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // Task completed + * // Task completed + * // Task completed + * // Results: 1, 2, 3 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (self: Effect, n: number, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: false | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }): Effect, E, R>; + /** + * Performs this effect the specified number of times and collects the results. + * + * **Details** + * + * This function repeats an effect multiple times and collects the results into + * an array. You specify how many times to execute the effect, and it runs that + * many times, either in sequence or concurrently depending on the provided + * options. + * + * **Options** + * + * If the `discard` option is set to `true`, the intermediate results are not + * collected, and the final result of the operation is `void`. + * + * The function also allows you to customize how the effects are handled by + * specifying options such as concurrency, batching, and how finalizers behave. + * These options provide flexibility in running the effects concurrently or + * adjusting other execution details. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * let counter = 0 + * + * const task = Effect.sync(() => ++counter).pipe( + * Effect.tap(() => Console.log(`Task completed`)) + * ) + * + * const program = Effect.gen(function*() { + * // Replicate the task 3 times and collect the results + * const results = yield* Effect.replicateEffect(task, 3) + * yield* Console.log(`Results: ${results.join(", ")}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // Task completed + * // Task completed + * // Task completed + * // Results: 1, 2, 3 + * ``` + * + * @since 2.0.0 + * @category Collecting + */ + (self: Effect, n: number, options: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard: true; + readonly concurrentFinalizers?: boolean | undefined; + }): Effect; +}; +/** + * Applies an effectful operation to each element in a collection while + * collecting both successes and failures. + * + * **Details** + * + * This function allows you to apply an effectful operation to every item in a + * collection. + * + * Unlike {@link forEach}, which would stop at the first error, this function + * continues processing all elements, accumulating both successes and failures. + * + * **When to Use** + * + * Use this function when you want to process every item in a collection, even + * if some items fail. This is particularly useful when you need to perform + * operations on all elements without halting due to an error. + * + * Keep in mind that if there are any failures, **all successes will be lost**, + * so this function is not suitable when you need to keep the successful results + * in case of errors. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateAll([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } else { + * return Effect.fail(`${n} is not less that 4`) + * } + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // item 1 + * // item 2 + * // item 3 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: [ '4 is not less that 4', '5 is not less that 4' ] + * // } + * // } + * ``` + * + * @see {@link forEach} for a similar function that stops at the first error. + * @see {@link partition} when you need to separate successes and failures + * instead of losing successes with errors. + * + * @since 2.0.0 + * @category Error Accumulation + */ +export declare const validateAll: { + /** + * Applies an effectful operation to each element in a collection while + * collecting both successes and failures. + * + * **Details** + * + * This function allows you to apply an effectful operation to every item in a + * collection. + * + * Unlike {@link forEach}, which would stop at the first error, this function + * continues processing all elements, accumulating both successes and failures. + * + * **When to Use** + * + * Use this function when you want to process every item in a collection, even + * if some items fail. This is particularly useful when you need to perform + * operations on all elements without halting due to an error. + * + * Keep in mind that if there are any failures, **all successes will be lost**, + * so this function is not suitable when you need to keep the successful results + * in case of errors. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateAll([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } else { + * return Effect.fail(`${n} is not less that 4`) + * } + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // item 1 + * // item 2 + * // item 3 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: [ '4 is not less that 4', '5 is not less that 4' ] + * // } + * // } + * ``` + * + * @see {@link forEach} for a similar function that stops at the first error. + * @see {@link partition} when you need to separate successes and failures + * instead of losing successes with errors. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (f: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: false | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (elements: Iterable) => Effect, RA.NonEmptyArray, R>; + /** + * Applies an effectful operation to each element in a collection while + * collecting both successes and failures. + * + * **Details** + * + * This function allows you to apply an effectful operation to every item in a + * collection. + * + * Unlike {@link forEach}, which would stop at the first error, this function + * continues processing all elements, accumulating both successes and failures. + * + * **When to Use** + * + * Use this function when you want to process every item in a collection, even + * if some items fail. This is particularly useful when you need to perform + * operations on all elements without halting due to an error. + * + * Keep in mind that if there are any failures, **all successes will be lost**, + * so this function is not suitable when you need to keep the successful results + * in case of errors. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateAll([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } else { + * return Effect.fail(`${n} is not less that 4`) + * } + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // item 1 + * // item 2 + * // item 3 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: [ '4 is not less that 4', '5 is not less that 4' ] + * // } + * // } + * ``` + * + * @see {@link forEach} for a similar function that stops at the first error. + * @see {@link partition} when you need to separate successes and failures + * instead of losing successes with errors. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (f: (a: A, i: number) => Effect, options: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard: true; + readonly concurrentFinalizers?: boolean | undefined; + }): (elements: Iterable) => Effect, R>; + /** + * Applies an effectful operation to each element in a collection while + * collecting both successes and failures. + * + * **Details** + * + * This function allows you to apply an effectful operation to every item in a + * collection. + * + * Unlike {@link forEach}, which would stop at the first error, this function + * continues processing all elements, accumulating both successes and failures. + * + * **When to Use** + * + * Use this function when you want to process every item in a collection, even + * if some items fail. This is particularly useful when you need to perform + * operations on all elements without halting due to an error. + * + * Keep in mind that if there are any failures, **all successes will be lost**, + * so this function is not suitable when you need to keep the successful results + * in case of errors. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateAll([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } else { + * return Effect.fail(`${n} is not less that 4`) + * } + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // item 1 + * // item 2 + * // item 3 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: [ '4 is not less that 4', '5 is not less that 4' ] + * // } + * // } + * ``` + * + * @see {@link forEach} for a similar function that stops at the first error. + * @see {@link partition} when you need to separate successes and failures + * instead of losing successes with errors. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (elements: Iterable, f: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard?: false | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect, RA.NonEmptyArray, R>; + /** + * Applies an effectful operation to each element in a collection while + * collecting both successes and failures. + * + * **Details** + * + * This function allows you to apply an effectful operation to every item in a + * collection. + * + * Unlike {@link forEach}, which would stop at the first error, this function + * continues processing all elements, accumulating both successes and failures. + * + * **When to Use** + * + * Use this function when you want to process every item in a collection, even + * if some items fail. This is particularly useful when you need to perform + * operations on all elements without halting due to an error. + * + * Keep in mind that if there are any failures, **all successes will be lost**, + * so this function is not suitable when you need to keep the successful results + * in case of errors. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateAll([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } else { + * return Effect.fail(`${n} is not less that 4`) + * } + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // item 1 + * // item 2 + * // item 3 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: [ '4 is not less that 4', '5 is not less that 4' ] + * // } + * // } + * ``` + * + * @see {@link forEach} for a similar function that stops at the first error. + * @see {@link partition} when you need to separate successes and failures + * instead of losing successes with errors. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (elements: Iterable, f: (a: A, i: number) => Effect, options: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly discard: true; + readonly concurrentFinalizers?: boolean | undefined; + }): Effect, R>; +}; +/** + * This function is similar to {@link validateAll} but with a key difference: it + * returns the first successful result or all errors if none of the operations + * succeed. + * + * **Details** + * + * This function processes a collection of elements and applies an effectful + * operation to each. Unlike {@link validateAll}, which accumulates both + * successes and failures, `Effect.validateFirst` stops and returns the first + * success it encounters. If no success occurs, it returns all accumulated + * errors. This can be useful when you are interested in the first successful + * result and want to avoid processing further once a valid result is found. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateFirst([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Effect.fail(`${n} is not less that 4`) + * } else { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } + * }) + * + * Effect.runPromise(program).then(console.log, console.error) + * // Output: + * // item 4 + * // 4 + * ``` + * + * @see {@link validateAll} for a similar function that accumulates all results. + * @see {@link firstSuccessOf} for a similar function that processes multiple + * effects and returns the first successful one or the last error. + * + * @since 2.0.0 + * @category Error Accumulation + */ +export declare const validateFirst: { + /** + * This function is similar to {@link validateAll} but with a key difference: it + * returns the first successful result or all errors if none of the operations + * succeed. + * + * **Details** + * + * This function processes a collection of elements and applies an effectful + * operation to each. Unlike {@link validateAll}, which accumulates both + * successes and failures, `Effect.validateFirst` stops and returns the first + * success it encounters. If no success occurs, it returns all accumulated + * errors. This can be useful when you are interested in the first successful + * result and want to avoid processing further once a valid result is found. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateFirst([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Effect.fail(`${n} is not less that 4`) + * } else { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } + * }) + * + * Effect.runPromise(program).then(console.log, console.error) + * // Output: + * // item 4 + * // 4 + * ``` + * + * @see {@link validateAll} for a similar function that accumulates all results. + * @see {@link firstSuccessOf} for a similar function that processes multiple + * effects and returns the first successful one or the last error. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (f: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (elements: Iterable) => Effect, R>; + /** + * This function is similar to {@link validateAll} but with a key difference: it + * returns the first successful result or all errors if none of the operations + * succeed. + * + * **Details** + * + * This function processes a collection of elements and applies an effectful + * operation to each. Unlike {@link validateAll}, which accumulates both + * successes and failures, `Effect.validateFirst` stops and returns the first + * success it encounters. If no success occurs, it returns all accumulated + * errors. This can be useful when you are interested in the first successful + * result and want to avoid processing further once a valid result is found. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.validateFirst([1, 2, 3, 4, 5], (n) => { + * if (n < 4) { + * return Effect.fail(`${n} is not less that 4`) + * } else { + * return Console.log(`item ${n}`).pipe(Effect.as(n)) + * } + * }) + * + * Effect.runPromise(program).then(console.log, console.error) + * // Output: + * // item 4 + * // 4 + * ``` + * + * @see {@link validateAll} for a similar function that accumulates all results. + * @see {@link firstSuccessOf} for a similar function that processes multiple + * effects and returns the first successful one or the last error. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (elements: Iterable, f: (a: A, i: number) => Effect, options?: { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect, R>; +}; +/** + * Creates an `Effect` from a callback-based asynchronous function. + * + * **Details** + * + * The `resume` function: + * - Must be called exactly once. Any additional calls will be ignored. + * - Can return an optional `Effect` that will be run if the `Fiber` executing + * this `Effect` is interrupted. This can be useful in scenarios where you + * need to handle resource cleanup if the operation is interrupted. + * - Can receive an `AbortSignal` to handle interruption if needed. + * + * The `FiberId` of the fiber that may complete the async callback may also be + * specified using the `blockingOn` argument. This is called the "blocking + * fiber" because it suspends the fiber executing the `async` effect (i.e. + * semantically blocks the fiber from making progress). Specifying this fiber id + * in cases where it is known will improve diagnostics, but not affect the + * behavior of the returned effect. + * + * **When to Use** + * + * Use `Effect.async` when dealing with APIs that use callback-style instead of + * `async/await` or `Promise`. + * + * **Example** (Wrapping a Callback API) + * + * ```ts + * import { Effect } from "effect" + * import * as NodeFS from "node:fs" + * + * const readFile = (filename: string) => + * Effect.async((resume) => { + * NodeFS.readFile(filename, (error, data) => { + * if (error) { + * // Resume with a failed Effect if an error occurs + * resume(Effect.fail(error)) + * } else { + * // Resume with a succeeded Effect if successful + * resume(Effect.succeed(data)) + * } + * }) + * }) + * + * // ┌─── Effect + * // ▼ + * const program = readFile("example.txt") + * ``` + * + * **Example** (Handling Interruption with Cleanup) + * + * ```ts + * import { Effect, Fiber } from "effect" + * import * as NodeFS from "node:fs" + * + * // Simulates a long-running operation to write to a file + * const writeFileWithCleanup = (filename: string, data: string) => + * Effect.async((resume) => { + * const writeStream = NodeFS.createWriteStream(filename) + * + * // Start writing data to the file + * writeStream.write(data) + * + * // When the stream is finished, resume with success + * writeStream.on("finish", () => resume(Effect.void)) + * + * // In case of an error during writing, resume with failure + * writeStream.on("error", (err) => resume(Effect.fail(err))) + * + * // Handle interruption by returning a cleanup effect + * return Effect.sync(() => { + * console.log(`Cleaning up ${filename}`) + * NodeFS.unlinkSync(filename) + * }) + * }) + * + * const program = Effect.gen(function* () { + * const fiber = yield* Effect.fork( + * writeFileWithCleanup("example.txt", "Some long data...") + * ) + * // Simulate interrupting the fiber after 1 second + * yield* Effect.sleep("1 second") + * yield* Fiber.interrupt(fiber) // This will trigger the cleanup + * }) + * + * // Run the program + * Effect.runPromise(program) + * // Output: + * // Cleaning up example.txt + * ``` + * + * **Example** (Handling Interruption with AbortSignal) + * + * ```ts + * import { Effect, Fiber } from "effect" + * + * // A task that supports interruption using AbortSignal + * const interruptibleTask = Effect.async((resume, signal) => { + * // Handle interruption + * signal.addEventListener("abort", () => { + * console.log("Abort signal received") + * clearTimeout(timeoutId) + * }) + * + * // Simulate a long-running task + * const timeoutId = setTimeout(() => { + * console.log("Operation completed") + * resume(Effect.void) + * }, 2000) + * }) + * + * const program = Effect.gen(function* () { + * const fiber = yield* Effect.fork(interruptibleTask) + * // Simulate interrupting the fiber after 1 second + * yield* Effect.sleep("1 second") + * yield* Fiber.interrupt(fiber) + * }) + * + * // Run the program + * Effect.runPromise(program) + * // Output: + * // Abort signal received + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const async: (resume: (callback: (_: Effect) => void, signal: AbortSignal) => void | Effect, blockingOn?: FiberId.FiberId) => Effect; +/** + * A variant of {@link async} where the registration function may return an `Effect`. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const asyncEffect: (register: (callback: (_: Effect) => void) => Effect | void, E2, R2>) => Effect; +/** + * Low level constructor that enables for custom stack tracing cutpoints. + * + * It is meant to be called with a bag of instructions that become available in + * the "this" of the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const throwingFunction = () => { throw new Error() } + * const blowUp = Effect.custom(throwingFunction, function() { + * return Effect.succeed(this.effect_instruction_i0()) + * }) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const custom: { + /** + * Low level constructor that enables for custom stack tracing cutpoints. + * + * It is meant to be called with a bag of instructions that become available in + * the "this" of the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const throwingFunction = () => { throw new Error() } + * const blowUp = Effect.custom(throwingFunction, function() { + * return Effect.succeed(this.effect_instruction_i0()) + * }) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ + (i0: X, body: (this: { + effect_instruction_i0: X; + }) => Effect): Effect; + /** + * Low level constructor that enables for custom stack tracing cutpoints. + * + * It is meant to be called with a bag of instructions that become available in + * the "this" of the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const throwingFunction = () => { throw new Error() } + * const blowUp = Effect.custom(throwingFunction, function() { + * return Effect.succeed(this.effect_instruction_i0()) + * }) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ + (i0: X, i1: Y, body: (this: { + effect_instruction_i0: X; + effect_instruction_i1: Y; + }) => Effect): Effect; + /** + * Low level constructor that enables for custom stack tracing cutpoints. + * + * It is meant to be called with a bag of instructions that become available in + * the "this" of the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const throwingFunction = () => { throw new Error() } + * const blowUp = Effect.custom(throwingFunction, function() { + * return Effect.succeed(this.effect_instruction_i0()) + * }) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ + (i0: X, i1: Y, i2: Z, body: (this: { + effect_instruction_i0: X; + effect_instruction_i1: Y; + effect_instruction_i2: Z; + }) => Effect): Effect; +}; +/** + * @since 2.0.0 + * @category Creating Effects + */ +export declare const withFiberRuntime: (withRuntime: (fiber: Fiber.RuntimeFiber, status: FiberStatus.Running) => Effect) => Effect; +/** + * Creates an `Effect` that represents a recoverable error. + * + * **When to Use** + * + * Use this function to explicitly signal an error in an `Effect`. The error + * will keep propagating unless it is handled. You can handle the error with + * functions like {@link catchAll} or {@link catchTag}. + * + * **Example** (Creating a Failed Effect) + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const failure = Effect.fail( + * new Error("Operation failed due to network error") + * ) + * ``` + * + * @see {@link succeed} to create an effect that represents a successful value. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const fail: (error: E) => Effect; +/** + * Creates an `Effect` that fails with the specified error, evaluated lazily. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const failSync: (evaluate: LazyArg) => Effect; +/** + * Creates an `Effect` that fails with the specified `Cause`. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const failCause: (cause: Cause.Cause) => Effect; +/** + * Creates an `Effect` that fails with the specified `Cause`, evaluated lazily. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const failCauseSync: (evaluate: LazyArg>) => Effect; +/** + * Creates an effect that terminates a fiber with a specified error. + * + * **Details** + * + * This function is used to signal a defect, which represents a critical and + * unexpected error in the code. When invoked, it produces an effect that does + * not handle the error and instead terminates the fiber. + * + * The error channel of the resulting effect is of type `never`, indicating that + * it cannot recover from this failure. + * + * **When to Use** + * + * Use this function when encountering unexpected conditions in your code that + * should not be handled as regular errors but instead represent unrecoverable + * defects. + * + * **Example** (Terminating on Division by Zero with a Specified Error) + * + * ```ts + * import { Effect } from "effect" + * + * const divide = (a: number, b: number) => + * b === 0 + * ? Effect.die(new Error("Cannot divide by zero")) + * : Effect.succeed(a / b) + * + * // ┌─── Effect + * // ▼ + * const program = divide(1, 0) + * + * Effect.runPromise(program).catch(console.error) + * // Output: + * // (FiberFailure) Error: Cannot divide by zero + * // ...stack trace... + * ``` + * + * @see {@link dieSync} for a variant that throws a specified error, evaluated + * lazily. + * @see {@link dieMessage} for a variant that throws a `RuntimeException` with a + * message. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const die: (defect: unknown) => Effect; +/** + * Creates an effect that terminates a fiber with a `RuntimeException` + * containing the specified message. + * + * **Details** + * + * This function is used to signal a defect, representing a critical and + * unexpected error in the code. When invoked, it produces an effect that + * terminates the fiber with a `RuntimeException` carrying the given message. + * + * The resulting effect has an error channel of type `never`, indicating it does + * not handle or recover from the error. + * + * **When to Use** + * + * Use this function when you want to terminate a fiber due to an unrecoverable + * defect and include a clear explanation in the message. + * + * **Example** (Terminating on Division by Zero with a Specified Message) + * + * ```ts + * import { Effect } from "effect" + * + * const divide = (a: number, b: number) => + * b === 0 + * ? Effect.dieMessage("Cannot divide by zero") + * : Effect.succeed(a / b) + * + * // ┌─── Effect + * // ▼ + * const program = divide(1, 0) + * + * Effect.runPromise(program).catch(console.error) + * // Output: + * // (FiberFailure) RuntimeException: Cannot divide by zero + * // ...stack trace... + * ``` + * + * @see {@link die} for a variant that throws a specified error. + * @see {@link dieSync} for a variant that throws a specified error, evaluated + * lazily. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const dieMessage: (message: string) => Effect; +/** + * Creates an effect that dies with the specified error, evaluated lazily. + * + * **Details** + * + * This function allows you to create an effect that will terminate with a fatal error. + * The error is provided as a lazy argument, meaning it will only be evaluated when the effect runs. + * + * @see {@link die} if you don't need to evaluate the error lazily. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const dieSync: (evaluate: LazyArg) => Effect; +/** + * Provides a way to write effectful code using generator functions, simplifying + * control flow and error handling. + * + * **When to Use** + * + * `Effect.gen` allows you to write code that looks and behaves like synchronous + * code, but it can handle asynchronous tasks, errors, and complex control flow + * (like loops and conditions). It helps make asynchronous code more readable + * and easier to manage. + * + * The generator functions work similarly to `async/await` but with more + * explicit control over the execution of effects. You can `yield*` values from + * effects and return the final result at the end. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const addServiceCharge = (amount: number) => amount + 1 + * + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const fetchDiscountRate = Effect.promise(() => Promise.resolve(5)) + * + * export const program = Effect.gen(function* () { + * const transactionAmount = yield* fetchTransactionAmount + * const discountRate = yield* fetchDiscountRate + * const discountedAmount = yield* applyDiscount( + * transactionAmount, + * discountRate + * ) + * const finalAmount = addServiceCharge(discountedAmount) + * return `Final amount to charge: ${finalAmount}` + * }) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const gen: { + /** + * Provides a way to write effectful code using generator functions, simplifying + * control flow and error handling. + * + * **When to Use** + * + * `Effect.gen` allows you to write code that looks and behaves like synchronous + * code, but it can handle asynchronous tasks, errors, and complex control flow + * (like loops and conditions). It helps make asynchronous code more readable + * and easier to manage. + * + * The generator functions work similarly to `async/await` but with more + * explicit control over the execution of effects. You can `yield*` values from + * effects and return the final result at the end. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const addServiceCharge = (amount: number) => amount + 1 + * + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const fetchDiscountRate = Effect.promise(() => Promise.resolve(5)) + * + * export const program = Effect.gen(function* () { + * const transactionAmount = yield* fetchTransactionAmount + * const discountRate = yield* fetchDiscountRate + * const discountedAmount = yield* applyDiscount( + * transactionAmount, + * discountRate + * ) + * const finalAmount = addServiceCharge(discountedAmount) + * return `Final amount to charge: ${finalAmount}` + * }) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ + >, AEff>(f: (resume: Adapter) => Generator): Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>; + /** + * Provides a way to write effectful code using generator functions, simplifying + * control flow and error handling. + * + * **When to Use** + * + * `Effect.gen` allows you to write code that looks and behaves like synchronous + * code, but it can handle asynchronous tasks, errors, and complex control flow + * (like loops and conditions). It helps make asynchronous code more readable + * and easier to manage. + * + * The generator functions work similarly to `async/await` but with more + * explicit control over the execution of effects. You can `yield*` values from + * effects and return the final result at the end. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const addServiceCharge = (amount: number) => amount + 1 + * + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const fetchDiscountRate = Effect.promise(() => Promise.resolve(5)) + * + * export const program = Effect.gen(function* () { + * const transactionAmount = yield* fetchTransactionAmount + * const discountRate = yield* fetchDiscountRate + * const discountedAmount = yield* applyDiscount( + * transactionAmount, + * discountRate + * ) + * const finalAmount = addServiceCharge(discountedAmount) + * return `Final amount to charge: ${finalAmount}` + * }) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ + >, AEff>(self: Self, f: (this: Self, resume: Adapter) => Generator): Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>; +}; +/** + * @since 2.0.0 + * @category Models + */ +export interface Adapter { + (self: Effect): Effect; + (a: A, ab: (a: A) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (g: H) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (s: T) => Effect<_A, _E, _R>): Effect<_A, _E, _R>; +} +/** + * An effect that that runs indefinitely and never produces any result. The + * moral equivalent of `while(true) {}`, only without the wasted CPU cycles. + * + * **When to Use** + * + * It could be useful for long-running background tasks or to simulate waiting + * behavior without actually consuming resources. This effect is ideal for cases + * where you want to keep the program alive or in a certain state without + * performing any active work. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const never: Effect; +/** + * Ensures the `Option` is `None`, returning `void`. Otherwise, raises a + * `NoSuchElementException`. + * + * **Details** + * + * This function checks if the provided `Option` is `None`. If it is, it returns + * an effect that produces no result (i.e., `void`). If the `Option` is not + * `None` (i.e., it contains a value), the function will raise a + * `NoSuchElementException` error. + * + * **When to Use** + * + * This is useful when you want to ensure that a certain value is absent (i.e., + * `None`) before continuing execution, and to handle cases where the value is + * unexpectedly present. + * + * @since 2.0.0 + */ +export declare const none: (self: Effect, E, R>) => Effect; +/** + * Creates an `Effect` that represents an asynchronous computation guaranteed to + * succeed. + * + * **Details** + * + * The provided function (`thunk`) returns a `Promise` that should never reject; if it does, the error + * will be treated as a "defect". + * + * This defect is not a standard error but indicates a flaw in the logic that + * was expected to be error-free. You can think of it similar to an unexpected + * crash in the program, which can be further managed or logged using tools like + * {@link catchAllDefect}. + * + * **Interruptions** + * + * An optional `AbortSignal` can be provided to allow for interruption of the + * wrapped `Promise` API. + * + * **When to Use** + * + * Use this function when you are sure the operation will not reject. + * + * **Example** (Delayed Message) + * + * ```ts + * import { Effect } from "effect" + * + * const delay = (message: string) => + * Effect.promise( + * () => + * new Promise((resolve) => { + * setTimeout(() => { + * resolve(message) + * }, 2000) + * }) + * ) + * + * // ┌─── Effect + * // ▼ + * const program = delay("Async operation completed successfully!") + * ``` + * + * @see {@link tryPromise} for a version that can handle failures. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const promise: (evaluate: (signal: AbortSignal) => PromiseLike) => Effect; +/** + * Creates an `Effect` that always succeeds with a given value. + * + * **When to Use** + * + * Use this function when you need an effect that completes successfully with a + * specific value without any errors or external dependencies. + * + * **Example** (Creating a Successful Effect) + * + * ```ts + * import { Effect } from "effect" + * + * // Creating an effect that represents a successful scenario + * // + * // ┌─── Effect + * // ▼ + * const success = Effect.succeed(42) + * ``` + * + * @see {@link fail} to create an effect that represents a failure. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const succeed: (value: A) => Effect; +/** + * Returns an effect which succeeds with `None`. + * + * **When to Use** + * + * Use this function when you need to represent the absence of a value in your + * code, especially when working with optional data. This can be helpful when + * you want to indicate that no result is available without throwing an error or + * performing additional logic. + * + * @see {@link succeedSome} to create an effect that succeeds with a `Some` value. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const succeedNone: Effect>; +/** + * Returns an effect which succeeds with the value wrapped in a `Some`. + * + * @see {@link succeedNone} for a similar function that returns `None` when the value is absent. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const succeedSome: (value: A) => Effect>; +/** + * Delays the creation of an `Effect` until it is actually needed. + * + * **Details** + * + * The `Effect.suspend` function takes a thunk that represents the effect and + * wraps it in a suspended effect. This means the effect will not be created + * until it is explicitly needed, which is helpful in various scenarios: + * - **Lazy Evaluation**: Helps optimize performance by deferring computations, + * especially when the effect might not be needed, or when its computation is + * expensive. This also ensures that any side effects or scoped captures are + * re-executed on each invocation. + * - **Handling Circular Dependencies**: Useful in managing circular + * dependencies, such as recursive functions that need to avoid eager + * evaluation to prevent stack overflow. + * - **Unifying Return Types**: Can help TypeScript unify return types in + * situations where multiple branches of logic return different effects, + * simplifying type inference. + * + * **When to Use** + * + * Use this function when you need to defer the evaluation of an effect until it + * is required. This is particularly useful for optimizing expensive + * computations, managing circular dependencies, or resolving type inference + * issues. + * + * **Example** (Lazy Evaluation with Side Effects) + * + * ```ts + * import { Effect } from "effect" + * + * let i = 0 + * + * const bad = Effect.succeed(i++) + * + * const good = Effect.suspend(() => Effect.succeed(i++)) + * + * console.log(Effect.runSync(bad)) // Output: 0 + * console.log(Effect.runSync(bad)) // Output: 0 + * + * console.log(Effect.runSync(good)) // Output: 1 + * console.log(Effect.runSync(good)) // Output: 2 + * ``` + * + * **Example** (Recursive Fibonacci) + * + * ```ts + * import { Effect } from "effect" + * + * const blowsUp = (n: number): Effect.Effect => + * n < 2 + * ? Effect.succeed(1) + * : Effect.zipWith(blowsUp(n - 1), blowsUp(n - 2), (a, b) => a + b) + * + * console.log(Effect.runSync(blowsUp(32))) + * // crash: JavaScript heap out of memory + * + * const allGood = (n: number): Effect.Effect => + * n < 2 + * ? Effect.succeed(1) + * : Effect.zipWith( + * Effect.suspend(() => allGood(n - 1)), + * Effect.suspend(() => allGood(n - 2)), + * (a, b) => a + b + * ) + * + * console.log(Effect.runSync(allGood(32))) + * // Output: 3524578 + * ``` + * + * **Example** (Using Effect.suspend to Help TypeScript Infer Types) + * + * ```ts + * import { Effect } from "effect" + * + * // Without suspend, TypeScript may struggle with type inference. + * // Inferred type: + * // (a: number, b: number) => + * // Effect | Effect + * const withoutSuspend = (a: number, b: number) => + * b === 0 + * ? Effect.fail(new Error("Cannot divide by zero")) + * : Effect.succeed(a / b) + * + * // Using suspend to unify return types. + * // Inferred type: + * // (a: number, b: number) => Effect + * const withSuspend = (a: number, b: number) => + * Effect.suspend(() => + * b === 0 + * ? Effect.fail(new Error("Cannot divide by zero")) + * : Effect.succeed(a / b) + * ) + * ``` + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const suspend: (effect: LazyArg>) => Effect; +/** + * Creates an `Effect` that represents a synchronous side-effectful computation. + * + * **Details** + * + * The provided function (`thunk`) must not throw errors; if it does, the error + * will be treated as a "defect". + * + * This defect is not a standard error but indicates a flaw in the logic that + * was expected to be error-free. You can think of it similar to an unexpected + * crash in the program, which can be further managed or logged using tools like + * {@link catchAllDefect}. + * + * **When to Use** + * + * Use this function when you are sure the operation will not fail. + * + * **Example** (Logging a Message) + * + * ```ts + * import { Effect } from "effect" + * + * const log = (message: string) => + * Effect.sync(() => { + * console.log(message) // side effect + * }) + * + * // ┌─── Effect + * // ▼ + * const program = log("Hello, World!") + * ``` + * + * @see {@link try_ | try} for a version that can handle failures. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const sync: (thunk: LazyArg) => Effect; +declare const _void: Effect; +export { +/** + * Represents an effect that does nothing and produces no value. + * + * **When to Use** + * + * Use this effect when you need to represent an effect that does nothing. + * This is useful in scenarios where you need to satisfy an effect-based + * interface or control program flow without performing any operations. For + * example, it can be used in situations where you want to return an effect + * from a function but do not need to compute or return any result. + * + * @since 2.0.0 + * @category Creating Effects + */ +_void as void }; +/** + * @since 2.0.0 + * @category Creating Effects + */ +export declare const yieldNow: (options?: { + readonly priority?: number | undefined; +}) => Effect; +declare const _catch: { + (discriminator: N, options: { + readonly failure: K; + readonly onFailure: (error: Extract) => Effect; + }): (self: Effect) => Effect, R1 | R>; + (self: Effect, discriminator: N, options: { + readonly failure: K; + readonly onFailure: (error: Extract) => Effect; + }): Effect, R | R1>; +}; +export { +/** + * Recovers from a specified error by catching it and handling it with a provided function. + * + * **Details** + * + * This function allows you to recover from specific errors that occur during + * the execution of an effect. It works by catching a specific type of error + * (identified by a discriminator) and then handling it using a provided + * handler function. The handler can return a new effect that helps recover + * from the error, allowing the program to continue. If the error doesn't + * match the specified type, the function allows the original effect to + * continue as it was. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * class NetworkError { + * readonly _tag = "NetworkError" + * } + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // Simulate an effect that may fail + * const task: Effect.Effect = Effect.fail(new NetworkError()) + * + * const program = Effect.gen(function*() { + * const result = yield* Effect.catch(task, "_tag", { + * failure: "NetworkError", + * onFailure: (error) => Effect.succeed(`recovered from error: ${error._tag}`) + * }) + * console.log(`Result: ${result}`) + * }) + * + * Effect.runFork(program) + * // Output: Result: recovered from error: NetworkError + * ``` + * + * @see {@link catchTag} for a version that can recover from errors based on a `_tag` discriminator. + * + * @since 2.0.0 + * @category Error handling + */ +_catch as catch }; +/** + * Handles all errors in an effect by providing a fallback effect. + * + * **Details** + * + * This function catches any errors that may occur during the execution of an + * effect and allows you to handle them by specifying a fallback effect. This + * ensures that the program continues without failing by recovering from errors + * using the provided fallback logic. + * + * **Note**: This function only handles recoverable errors. It will not recover + * from unrecoverable defects. + * + * **Example** (Providing Recovery Logic for Recoverable Errors) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchAll((error) => + * Effect.succeed(`Recovering from ${error._tag}`) + * ) + * ) + * ``` + * + * @see {@link catchAllCause} for a version that can recover from both + * recoverable and unrecoverable errors. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchAll: { + /** + * Handles all errors in an effect by providing a fallback effect. + * + * **Details** + * + * This function catches any errors that may occur during the execution of an + * effect and allows you to handle them by specifying a fallback effect. This + * ensures that the program continues without failing by recovering from errors + * using the provided fallback logic. + * + * **Note**: This function only handles recoverable errors. It will not recover + * from unrecoverable defects. + * + * **Example** (Providing Recovery Logic for Recoverable Errors) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchAll((error) => + * Effect.succeed(`Recovering from ${error._tag}`) + * ) + * ) + * ``` + * + * @see {@link catchAllCause} for a version that can recover from both + * recoverable and unrecoverable errors. + * + * @since 2.0.0 + * @category Error handling + */ + (f: (e: E) => Effect): (self: Effect) => Effect; + /** + * Handles all errors in an effect by providing a fallback effect. + * + * **Details** + * + * This function catches any errors that may occur during the execution of an + * effect and allows you to handle them by specifying a fallback effect. This + * ensures that the program continues without failing by recovering from errors + * using the provided fallback logic. + * + * **Note**: This function only handles recoverable errors. It will not recover + * from unrecoverable defects. + * + * **Example** (Providing Recovery Logic for Recoverable Errors) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchAll((error) => + * Effect.succeed(`Recovering from ${error._tag}`) + * ) + * ) + * ``` + * + * @see {@link catchAllCause} for a version that can recover from both + * recoverable and unrecoverable errors. + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, f: (e: E) => Effect): Effect; +}; +/** + * Handles both recoverable and unrecoverable errors by providing a recovery + * effect. + * + * **When to Use** + * + * The `catchAllCause` function allows you to handle all errors, including + * unrecoverable defects, by providing a recovery effect. The recovery logic is + * based on the `Cause` of the error, which provides detailed information about + * the failure. + * + * **When to Recover from Defects** + * + * Defects are unexpected errors that typically shouldn't be recovered from, as + * they often indicate serious issues. However, in some cases, such as + * dynamically loaded plugins, controlled recovery might be needed. + * + * **Example** (Recovering from All Errors) + * + * ```ts + * import { Cause, Effect } from "effect" + * + * // Define an effect that may fail with a recoverable or unrecoverable error + * const program = Effect.fail("Something went wrong!") + * + * // Recover from all errors by examining the cause + * const recovered = program.pipe( + * Effect.catchAllCause((cause) => + * Cause.isFailure(cause) + * ? Effect.succeed("Recovered from a regular error") + * : Effect.succeed("Recovered from a defect") + * ) + * ) + * + * Effect.runPromise(recovered).then(console.log) + * // Output: "Recovered from a regular error" + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchAllCause: { + /** + * Handles both recoverable and unrecoverable errors by providing a recovery + * effect. + * + * **When to Use** + * + * The `catchAllCause` function allows you to handle all errors, including + * unrecoverable defects, by providing a recovery effect. The recovery logic is + * based on the `Cause` of the error, which provides detailed information about + * the failure. + * + * **When to Recover from Defects** + * + * Defects are unexpected errors that typically shouldn't be recovered from, as + * they often indicate serious issues. However, in some cases, such as + * dynamically loaded plugins, controlled recovery might be needed. + * + * **Example** (Recovering from All Errors) + * + * ```ts + * import { Cause, Effect } from "effect" + * + * // Define an effect that may fail with a recoverable or unrecoverable error + * const program = Effect.fail("Something went wrong!") + * + * // Recover from all errors by examining the cause + * const recovered = program.pipe( + * Effect.catchAllCause((cause) => + * Cause.isFailure(cause) + * ? Effect.succeed("Recovered from a regular error") + * : Effect.succeed("Recovered from a defect") + * ) + * ) + * + * Effect.runPromise(recovered).then(console.log) + * // Output: "Recovered from a regular error" + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (f: (cause: Cause.Cause) => Effect): (self: Effect) => Effect; + /** + * Handles both recoverable and unrecoverable errors by providing a recovery + * effect. + * + * **When to Use** + * + * The `catchAllCause` function allows you to handle all errors, including + * unrecoverable defects, by providing a recovery effect. The recovery logic is + * based on the `Cause` of the error, which provides detailed information about + * the failure. + * + * **When to Recover from Defects** + * + * Defects are unexpected errors that typically shouldn't be recovered from, as + * they often indicate serious issues. However, in some cases, such as + * dynamically loaded plugins, controlled recovery might be needed. + * + * **Example** (Recovering from All Errors) + * + * ```ts + * import { Cause, Effect } from "effect" + * + * // Define an effect that may fail with a recoverable or unrecoverable error + * const program = Effect.fail("Something went wrong!") + * + * // Recover from all errors by examining the cause + * const recovered = program.pipe( + * Effect.catchAllCause((cause) => + * Cause.isFailure(cause) + * ? Effect.succeed("Recovered from a regular error") + * : Effect.succeed("Recovered from a defect") + * ) + * ) + * + * Effect.runPromise(recovered).then(console.log) + * // Output: "Recovered from a regular error" + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, f: (cause: Cause.Cause) => Effect): Effect; +}; +/** + * Recovers from all defects using a provided recovery function. + * + * **When to Use** + * + * There is no sensible way to recover from defects. This method should be used + * only at the boundary between Effect and an external system, to transmit + * information on a defect for diagnostic or explanatory purposes. + * + * **Details** + * + * `catchAllDefect` allows you to handle defects, which are unexpected errors + * that usually cause the program to terminate. This function lets you recover + * from these defects by providing a function that handles the error. However, + * it does not handle expected errors (like those from {@link fail}) or + * execution interruptions (like those from {@link interrupt}). + * + * **When to Recover from Defects** + * + * Defects are unexpected errors that typically shouldn't be recovered from, as + * they often indicate serious issues. However, in some cases, such as + * dynamically loaded plugins, controlled recovery might be needed. + * + * **Example** (Handling All Defects) + * + * ```ts + * import { Effect, Cause, Console } from "effect" + * + * // Simulating a runtime error + * const task = Effect.dieMessage("Boom!") + * + * const program = Effect.catchAllDefect(task, (defect) => { + * if (Cause.isRuntimeException(defect)) { + * return Console.log( + * `RuntimeException defect caught: ${defect.message}` + * ) + * } + * return Console.log("Unknown defect caught.") + * }) + * + * // We get an Exit.Success because we caught all defects + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // RuntimeException defect caught: Boom! + * // { + * // _id: "Exit", + * // _tag: "Success", + * // value: undefined + * // } + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchAllDefect: { + /** + * Recovers from all defects using a provided recovery function. + * + * **When to Use** + * + * There is no sensible way to recover from defects. This method should be used + * only at the boundary between Effect and an external system, to transmit + * information on a defect for diagnostic or explanatory purposes. + * + * **Details** + * + * `catchAllDefect` allows you to handle defects, which are unexpected errors + * that usually cause the program to terminate. This function lets you recover + * from these defects by providing a function that handles the error. However, + * it does not handle expected errors (like those from {@link fail}) or + * execution interruptions (like those from {@link interrupt}). + * + * **When to Recover from Defects** + * + * Defects are unexpected errors that typically shouldn't be recovered from, as + * they often indicate serious issues. However, in some cases, such as + * dynamically loaded plugins, controlled recovery might be needed. + * + * **Example** (Handling All Defects) + * + * ```ts + * import { Effect, Cause, Console } from "effect" + * + * // Simulating a runtime error + * const task = Effect.dieMessage("Boom!") + * + * const program = Effect.catchAllDefect(task, (defect) => { + * if (Cause.isRuntimeException(defect)) { + * return Console.log( + * `RuntimeException defect caught: ${defect.message}` + * ) + * } + * return Console.log("Unknown defect caught.") + * }) + * + * // We get an Exit.Success because we caught all defects + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // RuntimeException defect caught: Boom! + * // { + * // _id: "Exit", + * // _tag: "Success", + * // value: undefined + * // } + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (f: (defect: unknown) => Effect): (self: Effect) => Effect; + /** + * Recovers from all defects using a provided recovery function. + * + * **When to Use** + * + * There is no sensible way to recover from defects. This method should be used + * only at the boundary between Effect and an external system, to transmit + * information on a defect for diagnostic or explanatory purposes. + * + * **Details** + * + * `catchAllDefect` allows you to handle defects, which are unexpected errors + * that usually cause the program to terminate. This function lets you recover + * from these defects by providing a function that handles the error. However, + * it does not handle expected errors (like those from {@link fail}) or + * execution interruptions (like those from {@link interrupt}). + * + * **When to Recover from Defects** + * + * Defects are unexpected errors that typically shouldn't be recovered from, as + * they often indicate serious issues. However, in some cases, such as + * dynamically loaded plugins, controlled recovery might be needed. + * + * **Example** (Handling All Defects) + * + * ```ts + * import { Effect, Cause, Console } from "effect" + * + * // Simulating a runtime error + * const task = Effect.dieMessage("Boom!") + * + * const program = Effect.catchAllDefect(task, (defect) => { + * if (Cause.isRuntimeException(defect)) { + * return Console.log( + * `RuntimeException defect caught: ${defect.message}` + * ) + * } + * return Console.log("Unknown defect caught.") + * }) + * + * // We get an Exit.Success because we caught all defects + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // RuntimeException defect caught: Boom! + * // { + * // _id: "Exit", + * // _tag: "Success", + * // value: undefined + * // } + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, f: (defect: unknown) => Effect): Effect; +}; +/** + * Recovers from specific errors based on a predicate. + * + * **When to Use** + * + * `catchIf` works similarly to {@link catchSome}, but it allows you to + * recover from errors by providing a predicate function. If the predicate + * matches the error, the recovery effect is applied. This function doesn't + * alter the error type, so the resulting effect still carries the original + * error type unless a user-defined type guard is used to narrow the type. + * + * **Example** (Catching Specific Errors with a Predicate) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchIf( + * // Only handle HttpError errors + * (error) => error._tag === "HttpError", + * () => Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchIf: { + /** + * Recovers from specific errors based on a predicate. + * + * **When to Use** + * + * `catchIf` works similarly to {@link catchSome}, but it allows you to + * recover from errors by providing a predicate function. If the predicate + * matches the error, the recovery effect is applied. This function doesn't + * alter the error type, so the resulting effect still carries the original + * error type unless a user-defined type guard is used to narrow the type. + * + * **Example** (Catching Specific Errors with a Predicate) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchIf( + * // Only handle HttpError errors + * (error) => error._tag === "HttpError", + * () => Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (refinement: Refinement, EB>, f: (e: EB) => Effect): (self: Effect) => Effect, R2 | R>; + /** + * Recovers from specific errors based on a predicate. + * + * **When to Use** + * + * `catchIf` works similarly to {@link catchSome}, but it allows you to + * recover from errors by providing a predicate function. If the predicate + * matches the error, the recovery effect is applied. This function doesn't + * alter the error type, so the resulting effect still carries the original + * error type unless a user-defined type guard is used to narrow the type. + * + * **Example** (Catching Specific Errors with a Predicate) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchIf( + * // Only handle HttpError errors + * (error) => error._tag === "HttpError", + * () => Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (predicate: Predicate>, f: (e: NoInfer) => Effect): (self: Effect) => Effect; + /** + * Recovers from specific errors based on a predicate. + * + * **When to Use** + * + * `catchIf` works similarly to {@link catchSome}, but it allows you to + * recover from errors by providing a predicate function. If the predicate + * matches the error, the recovery effect is applied. This function doesn't + * alter the error type, so the resulting effect still carries the original + * error type unless a user-defined type guard is used to narrow the type. + * + * **Example** (Catching Specific Errors with a Predicate) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchIf( + * // Only handle HttpError errors + * (error) => error._tag === "HttpError", + * () => Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, refinement: Refinement, f: (e: EB) => Effect): Effect, R | R2>; + /** + * Recovers from specific errors based on a predicate. + * + * **When to Use** + * + * `catchIf` works similarly to {@link catchSome}, but it allows you to + * recover from errors by providing a predicate function. If the predicate + * matches the error, the recovery effect is applied. This function doesn't + * alter the error type, so the resulting effect still carries the original + * error type unless a user-defined type guard is used to narrow the type. + * + * **Example** (Catching Specific Errors with a Predicate) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchIf( + * // Only handle HttpError errors + * (error) => error._tag === "HttpError", + * () => Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, predicate: Predicate, f: (e: E) => Effect): Effect; +}; +/** + * Catches and recovers from specific types of errors, allowing you to attempt + * recovery only for certain errors. + * + * **Details** + * + * `catchSome` lets you selectively catch and handle errors of certain + * types by providing a recovery effect for specific errors. If the error + * matches a condition, recovery is attempted; if not, it doesn't affect the + * program. This function doesn't alter the error type, meaning the error type + * remains the same as in the original effect. + * + * **Example** (Handling Specific Errors with Effect.catchSome) + * + * ```ts + * import { Effect, Random, Option } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchSome((error) => { + * // Only handle HttpError errors + * if (error._tag === "HttpError") { + * return Option.some(Effect.succeed("Recovering from HttpError")) + * } else { + * return Option.none() + * } + * }) + * ) + * ``` + * + * @see {@link catchIf} for a version that allows you to recover from errors based on a predicate. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchSome: { + /** + * Catches and recovers from specific types of errors, allowing you to attempt + * recovery only for certain errors. + * + * **Details** + * + * `catchSome` lets you selectively catch and handle errors of certain + * types by providing a recovery effect for specific errors. If the error + * matches a condition, recovery is attempted; if not, it doesn't affect the + * program. This function doesn't alter the error type, meaning the error type + * remains the same as in the original effect. + * + * **Example** (Handling Specific Errors with Effect.catchSome) + * + * ```ts + * import { Effect, Random, Option } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchSome((error) => { + * // Only handle HttpError errors + * if (error._tag === "HttpError") { + * return Option.some(Effect.succeed("Recovering from HttpError")) + * } else { + * return Option.none() + * } + * }) + * ) + * ``` + * + * @see {@link catchIf} for a version that allows you to recover from errors based on a predicate. + * + * @since 2.0.0 + * @category Error handling + */ + (pf: (e: NoInfer) => Option.Option>): (self: Effect) => Effect; + /** + * Catches and recovers from specific types of errors, allowing you to attempt + * recovery only for certain errors. + * + * **Details** + * + * `catchSome` lets you selectively catch and handle errors of certain + * types by providing a recovery effect for specific errors. If the error + * matches a condition, recovery is attempted; if not, it doesn't affect the + * program. This function doesn't alter the error type, meaning the error type + * remains the same as in the original effect. + * + * **Example** (Handling Specific Errors with Effect.catchSome) + * + * ```ts + * import { Effect, Random, Option } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchSome((error) => { + * // Only handle HttpError errors + * if (error._tag === "HttpError") { + * return Option.some(Effect.succeed("Recovering from HttpError")) + * } else { + * return Option.none() + * } + * }) + * ) + * ``` + * + * @see {@link catchIf} for a version that allows you to recover from errors based on a predicate. + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, pf: (e: NoInfer) => Option.Option>): Effect; +}; +/** + * Recovers from specific causes using a provided partial function. + * + * @see {@link catchSome} for a version that allows you to recover from errors. + * @see {@link catchSomeDefect} for a version that allows you to recover from defects. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchSomeCause: { + /** + * Recovers from specific causes using a provided partial function. + * + * @see {@link catchSome} for a version that allows you to recover from errors. + * @see {@link catchSomeDefect} for a version that allows you to recover from defects. + * + * @since 2.0.0 + * @category Error handling + */ + (f: (cause: Cause.Cause>) => Option.Option>): (self: Effect) => Effect; + /** + * Recovers from specific causes using a provided partial function. + * + * @see {@link catchSome} for a version that allows you to recover from errors. + * @see {@link catchSomeDefect} for a version that allows you to recover from defects. + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, f: (cause: Cause.Cause>) => Option.Option>): Effect; +}; +/** + * Recovers from specific defects using a provided partial function. + * + * **Details** + * + * `catchSomeDefect` allows you to handle specific defects, which are + * unexpected errors that can cause the program to stop. It uses a partial + * function to catch only certain defects and ignores others. The function does + * not handle expected errors (such as those caused by {@link fail}) or + * interruptions in execution (like those caused by {@link interrupt}). + * + * This function provides a way to handle certain types of defects while + * allowing others to propagate and cause failure in the program. + * + * **Note**: There is no sensible way to recover from defects. This method + * should be used only at the boundary between Effect and an external system, to + * transmit information on a defect for diagnostic or explanatory purposes. + * + * **How the Partial Function Works** + * + * The function provided to `catchSomeDefect` acts as a filter and a handler for defects: + * - It receives the defect as an input. + * - If the defect matches a specific condition (e.g., a certain error type), the function returns + * an `Option.some` containing the recovery logic. + * - If the defect does not match, the function returns `Option.none`, allowing the defect to propagate. + * + * **Example** (Handling Specific Defects) + * + * ```ts + * import { Effect, Cause, Option, Console } from "effect" + * + * // Simulating a runtime error + * const task = Effect.dieMessage("Boom!") + * + * const program = Effect.catchSomeDefect(task, (defect) => { + * if (Cause.isIllegalArgumentException(defect)) { + * return Option.some( + * Console.log( + * `Caught an IllegalArgumentException defect: ${defect.message}` + * ) + * ) + * } + * return Option.none() + * }) + * + * // Since we are only catching IllegalArgumentException + * // we will get an Exit.Failure because we simulated a runtime error. + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Die', + * // defect: { _tag: 'RuntimeException' } + * // } + * // } + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchSomeDefect: { + /** + * Recovers from specific defects using a provided partial function. + * + * **Details** + * + * `catchSomeDefect` allows you to handle specific defects, which are + * unexpected errors that can cause the program to stop. It uses a partial + * function to catch only certain defects and ignores others. The function does + * not handle expected errors (such as those caused by {@link fail}) or + * interruptions in execution (like those caused by {@link interrupt}). + * + * This function provides a way to handle certain types of defects while + * allowing others to propagate and cause failure in the program. + * + * **Note**: There is no sensible way to recover from defects. This method + * should be used only at the boundary between Effect and an external system, to + * transmit information on a defect for diagnostic or explanatory purposes. + * + * **How the Partial Function Works** + * + * The function provided to `catchSomeDefect` acts as a filter and a handler for defects: + * - It receives the defect as an input. + * - If the defect matches a specific condition (e.g., a certain error type), the function returns + * an `Option.some` containing the recovery logic. + * - If the defect does not match, the function returns `Option.none`, allowing the defect to propagate. + * + * **Example** (Handling Specific Defects) + * + * ```ts + * import { Effect, Cause, Option, Console } from "effect" + * + * // Simulating a runtime error + * const task = Effect.dieMessage("Boom!") + * + * const program = Effect.catchSomeDefect(task, (defect) => { + * if (Cause.isIllegalArgumentException(defect)) { + * return Option.some( + * Console.log( + * `Caught an IllegalArgumentException defect: ${defect.message}` + * ) + * ) + * } + * return Option.none() + * }) + * + * // Since we are only catching IllegalArgumentException + * // we will get an Exit.Failure because we simulated a runtime error. + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Die', + * // defect: { _tag: 'RuntimeException' } + * // } + * // } + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (pf: (defect: unknown) => Option.Option>): (self: Effect) => Effect; + /** + * Recovers from specific defects using a provided partial function. + * + * **Details** + * + * `catchSomeDefect` allows you to handle specific defects, which are + * unexpected errors that can cause the program to stop. It uses a partial + * function to catch only certain defects and ignores others. The function does + * not handle expected errors (such as those caused by {@link fail}) or + * interruptions in execution (like those caused by {@link interrupt}). + * + * This function provides a way to handle certain types of defects while + * allowing others to propagate and cause failure in the program. + * + * **Note**: There is no sensible way to recover from defects. This method + * should be used only at the boundary between Effect and an external system, to + * transmit information on a defect for diagnostic or explanatory purposes. + * + * **How the Partial Function Works** + * + * The function provided to `catchSomeDefect` acts as a filter and a handler for defects: + * - It receives the defect as an input. + * - If the defect matches a specific condition (e.g., a certain error type), the function returns + * an `Option.some` containing the recovery logic. + * - If the defect does not match, the function returns `Option.none`, allowing the defect to propagate. + * + * **Example** (Handling Specific Defects) + * + * ```ts + * import { Effect, Cause, Option, Console } from "effect" + * + * // Simulating a runtime error + * const task = Effect.dieMessage("Boom!") + * + * const program = Effect.catchSomeDefect(task, (defect) => { + * if (Cause.isIllegalArgumentException(defect)) { + * return Option.some( + * Console.log( + * `Caught an IllegalArgumentException defect: ${defect.message}` + * ) + * ) + * } + * return Option.none() + * }) + * + * // Since we are only catching IllegalArgumentException + * // we will get an Exit.Failure because we simulated a runtime error. + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Die', + * // defect: { _tag: 'RuntimeException' } + * // } + * // } + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, pf: (defect: unknown) => Option.Option>): Effect; +}; +/** + * Catches and handles specific errors by their `_tag` field, which is used as a + * discriminator. + * + * **When to Use** + * + * `catchTag` is useful when your errors are tagged with a readonly `_tag` field + * that identifies the error type. You can use this function to handle specific + * error types by matching the `_tag` value. This allows for precise error + * handling, ensuring that only specific errors are caught and handled. + * + * The error type must have a readonly `_tag` field to use `catchTag`. This + * field is used to identify and match errors. + * + * **Example** (Handling Errors by Tag) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * // Only handle HttpError errors + * Effect.catchTag("HttpError", (_HttpError) => + * Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @see {@link catchTags} for a version that allows you to handle multiple error + * types at once. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchTag: { + /** + * Catches and handles specific errors by their `_tag` field, which is used as a + * discriminator. + * + * **When to Use** + * + * `catchTag` is useful when your errors are tagged with a readonly `_tag` field + * that identifies the error type. You can use this function to handle specific + * error types by matching the `_tag` value. This allows for precise error + * handling, ensuring that only specific errors are caught and handled. + * + * The error type must have a readonly `_tag` field to use `catchTag`. This + * field is used to identify and match errors. + * + * **Example** (Handling Errors by Tag) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * // Only handle HttpError errors + * Effect.catchTag("HttpError", (_HttpError) => + * Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @see {@link catchTags} for a version that allows you to handle multiple error + * types at once. + * + * @since 2.0.0 + * @category Error handling + */ + , A1, E1, R1>(...args: [...tags: K, f: (e: Extract, { + _tag: K[number]; + }>) => Effect]): (self: Effect) => Effect | E1, R | R1>; + /** + * Catches and handles specific errors by their `_tag` field, which is used as a + * discriminator. + * + * **When to Use** + * + * `catchTag` is useful when your errors are tagged with a readonly `_tag` field + * that identifies the error type. You can use this function to handle specific + * error types by matching the `_tag` value. This allows for precise error + * handling, ensuring that only specific errors are caught and handled. + * + * The error type must have a readonly `_tag` field to use `catchTag`. This + * field is used to identify and match errors. + * + * **Example** (Handling Errors by Tag) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * // Only handle HttpError errors + * Effect.catchTag("HttpError", (_HttpError) => + * Effect.succeed("Recovering from HttpError") + * ) + * ) + * ``` + * + * @see {@link catchTags} for a version that allows you to handle multiple error + * types at once. + * + * @since 2.0.0 + * @category Error handling + */ + , A1, E1, R1>(self: Effect, ...args: [...tags: K, f: (e: Extract, { + _tag: K[number]; + }>) => Effect]): Effect | E1, R | R1>; +}; +/** + * Handles multiple errors in a single block of code using their `_tag` field. + * + * **When to Use** + * + * `catchTags` is a convenient way to handle multiple error types at + * once. Instead of using {@link catchTag} multiple times, you can pass an + * object where each key is an error type's `_tag`, and the value is the handler + * for that specific error. This allows you to catch and recover from multiple + * error types in a single call. + * + * The error type must have a readonly `_tag` field to use `catchTag`. This + * field is used to identify and match errors. + * + * **Example** (Handling Multiple Tagged Error Types at Once) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchTags({ + * HttpError: (_HttpError) => + * Effect.succeed(`Recovering from HttpError`), + * ValidationError: (_ValidationError) => + * Effect.succeed(`Recovering from ValidationError`) + * }) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const catchTags: { + /** + * Handles multiple errors in a single block of code using their `_tag` field. + * + * **When to Use** + * + * `catchTags` is a convenient way to handle multiple error types at + * once. Instead of using {@link catchTag} multiple times, you can pass an + * object where each key is an error type's `_tag`, and the value is the handler + * for that specific error. This allows you to catch and recover from multiple + * error types in a single call. + * + * The error type must have a readonly `_tag` field to use `catchTag`. This + * field is used to identify and match errors. + * + * **Example** (Handling Multiple Tagged Error Types at Once) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchTags({ + * HttpError: (_HttpError) => + * Effect.succeed(`Recovering from HttpError`), + * ValidationError: (_ValidationError) => + * Effect.succeed(`Recovering from ValidationError`) + * }) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + ["_tag"]]+?: ((error: Extract) => Effect); + } & (unknown extends E ? {} : { + [K in Exclude["_tag"]>]: never; + })>(cases: Cases): (self: Effect) => Effect) => Effect ? A : never; + }[keyof Cases], Exclude | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => Effect ? E : never; + }[keyof Cases], R | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => Effect ? R : never; + }[keyof Cases]>; + /** + * Handles multiple errors in a single block of code using their `_tag` field. + * + * **When to Use** + * + * `catchTags` is a convenient way to handle multiple error types at + * once. Instead of using {@link catchTag} multiple times, you can pass an + * object where each key is an error type's `_tag`, and the value is the handler + * for that specific error. This allows you to catch and recover from multiple + * error types in a single call. + * + * The error type must have a readonly `_tag` field to use `catchTag`. This + * field is used to identify and match errors. + * + * **Example** (Handling Multiple Tagged Error Types at Once) + * + * ```ts + * import { Effect, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = program.pipe( + * Effect.catchTags({ + * HttpError: (_HttpError) => + * Effect.succeed(`Recovering from HttpError`), + * ValidationError: (_ValidationError) => + * Effect.succeed(`Recovering from ValidationError`) + * }) + * ) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ + ["_tag"]]+?: ((error: Extract) => Effect); + } & (unknown extends E ? {} : { + [K in Exclude["_tag"]>]: never; + })>(self: Effect, cases: Cases): Effect) => Effect ? A : never; + }[keyof Cases], Exclude | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => Effect ? E : never; + }[keyof Cases], R | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => Effect ? R : never; + }[keyof Cases]>; +}; +/** + * Retrieves the cause of a failure in an effect. + * + * **Details** + * + * This function allows you to expose the detailed cause of an effect, which + * includes a more precise representation of failures, such as error messages + * and defects. + * + * **When to Use** + * + * This function is helpful when you need to inspect the cause of a failure in + * an effect, giving you more information than just the error message. It can be + * used to log, handle, or analyze failures in more detail, including + * distinguishing between different types of defects (e.g., runtime exceptions, + * interruptions, etc.). + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.fail("Oh uh!").pipe(Effect.as(2)) + * + * // ┌─── Effect + * // ▼ + * const recovered = Effect.gen(function* () { + * const cause = yield* Effect.cause(program) + * yield* Console.log(cause) + * }) + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const cause: (self: Effect) => Effect, never, R>; +/** + * Runs an effect repeatedly until it succeeds, ignoring errors. + * + * **Details** + * + * This function takes an effect and runs it repeatedly until the effect + * successfully completes. If the effect fails, it will ignore the error and + * retry the operation. This is useful when you need to perform a task that may + * fail occasionally, but you want to keep trying until it eventually succeeds. + * It works by repeatedly executing the effect until it no longer throws an + * error. + * + * **When to Use** + * + * Use this function when you want to retry an operation multiple times until it + * succeeds. It is helpful in cases where the operation may fail temporarily + * (e.g., a network request), and you want to keep trying without handling or + * worrying about the errors. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * let counter = 0 + * + * const effect = Effect.try(() => { + * counter++ + * if (counter < 3) { + * console.log("running effect") + * throw new Error("error") + * } else { + * console.log("effect done") + * return "some result" + * } + * }) + * + * const program = Effect.eventually(effect) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // running effect + * // running effect + * // effect done + * // some result + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const eventually: (self: Effect) => Effect; +/** + * Discards both the success and failure values of an effect. + * + * **When to Use** + * + * `ignore` allows you to run an effect without caring about its result, whether + * it succeeds or fails. This is useful when you only care about the side + * effects of the effect and do not need to handle or process its outcome. + * + * **Example** (Using Effect.ignore to Discard Values) + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const task = Effect.fail("Uh oh!").pipe(Effect.as(5)) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.ignore(task) + * ``` + * + * @see {@link ignoreLogged} to log failures while ignoring them. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const ignore: (self: Effect) => Effect; +/** + * Ignores the result of an effect but logs any failures. + * + * **Details** + * + * This function takes an effect and returns a new effect that ignores whether + * the original effect succeeds or fails. However, if the effect fails, it will + * log the failure at the Debug level, so you can keep track of any issues that + * arise. + * + * **When to Use** + * + * This is useful in scenarios where you want to continue with your program + * regardless of the result of the effect, but you still want to be aware of + * potential failures that may need attention later. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const ignoreLogged: (self: Effect) => Effect; +/** + * Combines all errors from concurrent operations into a single error. + * + * **Details** + * + * This function is used when you have multiple operations running at the same + * time, and you want to capture all the errors that occur across those + * operations. Instead of handling each error separately, it combines all the + * errors into one unified error. + * + * **When to Use** + * + * When using this function, any errors that occur in the concurrently running + * operations will be grouped together into a single error. This helps simplify + * error handling in cases where you don't need to differentiate between each + * failure, but simply want to know that multiple failures occurred. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const fail1 = Effect.fail("Oh uh!") + * const fail2 = Effect.fail("Oh no!") + * const die = Effect.dieMessage("Boom!") + * + * // Run all effects concurrently and capture all errors + * const program = Effect.all([fail1, fail2, die], { + * concurrency: "unbounded" + * }).pipe(Effect.asVoid, Effect.parallelErrors) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: [ 'Oh uh!', 'Oh no!' ] } + * // } + * ``` + * + * @since 2.0.0 + * @category Error handling + */ +export declare const parallelErrors: (self: Effect) => Effect, R>; +/** + * Transforms an effect to expose detailed error causes. + * + * **Details** + * + * This function enhances an effect by providing detailed information about any + * error, defect, or interruption that may occur during its execution. It + * modifies the error channel of the effect so that it includes a full cause of + * the failure, wrapped in a `Cause` type. + * + * After applying this function, you can use operators like {@link catchAll} and + * {@link catchTags} to handle specific types of errors. + * + * If you no longer need the detailed cause information, you can revert the + * changes using {@link unsandbox} to return to the original error-handling + * behavior. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const task = Effect.fail(new Error("Oh uh!")).pipe( + * Effect.as("primary result") + * ) + * + * // ┌─── Effect, never> + * // ▼ + * const sandboxed = Effect.sandbox(task) + * + * const program = Effect.catchTags(sandboxed, { + * Die: (cause) => + * Console.log(`Caught a defect: ${cause.defect}`).pipe( + * Effect.as("fallback result on defect") + * ), + * Interrupt: (cause) => + * Console.log(`Caught a defect: ${cause.fiberId}`).pipe( + * Effect.as("fallback result on fiber interruption") + * ), + * Fail: (cause) => + * Console.log(`Caught a defect: ${cause.error}`).pipe( + * Effect.as("fallback result on failure") + * ) + * }) + * + * // Restore the original error handling with unsandbox + * const main = Effect.unsandbox(program) + * + * Effect.runPromise(main).then(console.log) + * // Output: + * // Caught a defect: Oh uh! + * // fallback result on failure + * ``` + * + * @see {@link unsandbox} to restore the original error handling. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const sandbox: (self: Effect) => Effect, R>; +/** + * @since 2.0.0 + * @category Error handling + */ +export declare namespace Retry { + /** + * @since 2.0.0 + * @category Error handling + */ + type Return, O>> = Effect; + } ? E : O extends { + until: Refinement; + } ? E2 : E) | (O extends { + while: (...args: Array) => Effect; + } ? E : never) | (O extends { + until: (...args: Array) => Effect; + } ? E : never), R | (O extends { + schedule: Schedule.Schedule; + } ? R : never) | (O extends { + while: (...args: Array) => Effect; + } ? R : never) | (O extends { + until: (...args: Array) => Effect; + } ? R : never)> extends infer Z ? Z : never; + /** + * @since 2.0.0 + * @category Error handling + */ + interface Options { + while?: ((error: E) => boolean | Effect) | undefined; + until?: ((error: E) => boolean | Effect) | undefined; + times?: number | undefined; + schedule?: Schedule.Schedule | undefined; + } +} +/** + * Retries a failing effect based on a defined retry policy. + * + * **Details** + * + * The `Effect.retry` function takes an effect and a {@link Schedule} policy, + * and will automatically retry the effect if it fails, following the rules of + * the policy. + * + * If the effect ultimately succeeds, the result will be returned. + * + * If the maximum retries are exhausted and the effect still fails, the failure + * is propagated. + * + * **When to Use** + * + * This can be useful when dealing with intermittent failures, such as network + * issues or temporary resource unavailability. By defining a retry policy, you + * can control the number of retries, the delay between them, and when to stop + * retrying. + * + * **Example** (Retrying with a Fixed Delay) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Define a repetition policy using a fixed delay between retries + * const policy = Schedule.fixed("100 millis") + * + * const repeated = Effect.retry(task, policy) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * // yay! + * ``` + * + * **Example** (Retrying a Task up to 5 times) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task up to 5 times + * Effect.runPromise(Effect.retry(task, { times: 5 })).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * ``` + * + * **Example** (Retrying Until a Specific Condition is Met) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Define an effect that simulates varying error on each invocation + * const action = Effect.failSync(() => { + * console.log(`Action called ${++count} time(s)`) + * return `Error ${count}` + * }) + * + * // Retry the action until a specific condition is met + * const program = Effect.retry(action, { + * until: (err) => err === "Error 3" + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Action called 1 time(s) + * // Action called 2 time(s) + * // Action called 3 time(s) + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Error 3' } + * // } + * ``` + * + * @see {@link retryOrElse} for a version that allows you to run a fallback. + * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const retry: { + /** + * Retries a failing effect based on a defined retry policy. + * + * **Details** + * + * The `Effect.retry` function takes an effect and a {@link Schedule} policy, + * and will automatically retry the effect if it fails, following the rules of + * the policy. + * + * If the effect ultimately succeeds, the result will be returned. + * + * If the maximum retries are exhausted and the effect still fails, the failure + * is propagated. + * + * **When to Use** + * + * This can be useful when dealing with intermittent failures, such as network + * issues or temporary resource unavailability. By defining a retry policy, you + * can control the number of retries, the delay between them, and when to stop + * retrying. + * + * **Example** (Retrying with a Fixed Delay) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Define a repetition policy using a fixed delay between retries + * const policy = Schedule.fixed("100 millis") + * + * const repeated = Effect.retry(task, policy) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * // yay! + * ``` + * + * **Example** (Retrying a Task up to 5 times) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task up to 5 times + * Effect.runPromise(Effect.retry(task, { times: 5 })).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * ``` + * + * **Example** (Retrying Until a Specific Condition is Met) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Define an effect that simulates varying error on each invocation + * const action = Effect.failSync(() => { + * console.log(`Action called ${++count} time(s)`) + * return `Error ${count}` + * }) + * + * // Retry the action until a specific condition is met + * const program = Effect.retry(action, { + * until: (err) => err === "Error 3" + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Action called 1 time(s) + * // Action called 2 time(s) + * // Action called 3 time(s) + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Error 3' } + * // } + * ``` + * + * @see {@link retryOrElse} for a version that allows you to run a fallback. + * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors. + * + * @since 2.0.0 + * @category Error handling + */ + , O>>(options: O): (self: Effect) => Retry.Return; + /** + * Retries a failing effect based on a defined retry policy. + * + * **Details** + * + * The `Effect.retry` function takes an effect and a {@link Schedule} policy, + * and will automatically retry the effect if it fails, following the rules of + * the policy. + * + * If the effect ultimately succeeds, the result will be returned. + * + * If the maximum retries are exhausted and the effect still fails, the failure + * is propagated. + * + * **When to Use** + * + * This can be useful when dealing with intermittent failures, such as network + * issues or temporary resource unavailability. By defining a retry policy, you + * can control the number of retries, the delay between them, and when to stop + * retrying. + * + * **Example** (Retrying with a Fixed Delay) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Define a repetition policy using a fixed delay between retries + * const policy = Schedule.fixed("100 millis") + * + * const repeated = Effect.retry(task, policy) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * // yay! + * ``` + * + * **Example** (Retrying a Task up to 5 times) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task up to 5 times + * Effect.runPromise(Effect.retry(task, { times: 5 })).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * ``` + * + * **Example** (Retrying Until a Specific Condition is Met) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Define an effect that simulates varying error on each invocation + * const action = Effect.failSync(() => { + * console.log(`Action called ${++count} time(s)`) + * return `Error ${count}` + * }) + * + * // Retry the action until a specific condition is met + * const program = Effect.retry(action, { + * until: (err) => err === "Error 3" + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Action called 1 time(s) + * // Action called 2 time(s) + * // Action called 3 time(s) + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Error 3' } + * // } + * ``` + * + * @see {@link retryOrElse} for a version that allows you to run a fallback. + * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors. + * + * @since 2.0.0 + * @category Error handling + */ + (policy: Schedule.Schedule, R1>): (self: Effect) => Effect; + /** + * Retries a failing effect based on a defined retry policy. + * + * **Details** + * + * The `Effect.retry` function takes an effect and a {@link Schedule} policy, + * and will automatically retry the effect if it fails, following the rules of + * the policy. + * + * If the effect ultimately succeeds, the result will be returned. + * + * If the maximum retries are exhausted and the effect still fails, the failure + * is propagated. + * + * **When to Use** + * + * This can be useful when dealing with intermittent failures, such as network + * issues or temporary resource unavailability. By defining a retry policy, you + * can control the number of retries, the delay between them, and when to stop + * retrying. + * + * **Example** (Retrying with a Fixed Delay) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Define a repetition policy using a fixed delay between retries + * const policy = Schedule.fixed("100 millis") + * + * const repeated = Effect.retry(task, policy) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * // yay! + * ``` + * + * **Example** (Retrying a Task up to 5 times) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task up to 5 times + * Effect.runPromise(Effect.retry(task, { times: 5 })).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * ``` + * + * **Example** (Retrying Until a Specific Condition is Met) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Define an effect that simulates varying error on each invocation + * const action = Effect.failSync(() => { + * console.log(`Action called ${++count} time(s)`) + * return `Error ${count}` + * }) + * + * // Retry the action until a specific condition is met + * const program = Effect.retry(action, { + * until: (err) => err === "Error 3" + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Action called 1 time(s) + * // Action called 2 time(s) + * // Action called 3 time(s) + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Error 3' } + * // } + * ``` + * + * @see {@link retryOrElse} for a version that allows you to run a fallback. + * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors. + * + * @since 2.0.0 + * @category Error handling + */ + , O>>(self: Effect, options: O): Retry.Return; + /** + * Retries a failing effect based on a defined retry policy. + * + * **Details** + * + * The `Effect.retry` function takes an effect and a {@link Schedule} policy, + * and will automatically retry the effect if it fails, following the rules of + * the policy. + * + * If the effect ultimately succeeds, the result will be returned. + * + * If the maximum retries are exhausted and the effect still fails, the failure + * is propagated. + * + * **When to Use** + * + * This can be useful when dealing with intermittent failures, such as network + * issues or temporary resource unavailability. By defining a retry policy, you + * can control the number of retries, the delay between them, and when to stop + * retrying. + * + * **Example** (Retrying with a Fixed Delay) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Define a repetition policy using a fixed delay between retries + * const policy = Schedule.fixed("100 millis") + * + * const repeated = Effect.retry(task, policy) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * // yay! + * ``` + * + * **Example** (Retrying a Task up to 5 times) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task up to 5 times + * Effect.runPromise(Effect.retry(task, { times: 5 })).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // success + * ``` + * + * **Example** (Retrying Until a Specific Condition is Met) + * + * ```ts + * import { Effect } from "effect" + * + * let count = 0 + * + * // Define an effect that simulates varying error on each invocation + * const action = Effect.failSync(() => { + * console.log(`Action called ${++count} time(s)`) + * return `Error ${count}` + * }) + * + * // Retry the action until a specific condition is met + * const program = Effect.retry(action, { + * until: (err) => err === "Error 3" + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Action called 1 time(s) + * // Action called 2 time(s) + * // Action called 3 time(s) + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Error 3' } + * // } + * ``` + * + * @see {@link retryOrElse} for a version that allows you to run a fallback. + * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors. + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, policy: Schedule.Schedule, R1>): Effect; +}; +/** + * Apply an `ExecutionPlan` to the effect, which allows you to fallback to + * different resources in case of failure. + * + * @since 3.16.0 + * @category Error handling + * @experimental + */ +export declare const withExecutionPlan: { + /** + * Apply an `ExecutionPlan` to the effect, which allows you to fallback to + * different resources in case of failure. + * + * @since 3.16.0 + * @category Error handling + * @experimental + */ + (plan: ExecutionPlan<{ + provides: Provides; + input: Input; + error: PlanE; + requirements: PlanR; + }>): (effect: Effect) => Effect | PlanR>; + /** + * Apply an `ExecutionPlan` to the effect, which allows you to fallback to + * different resources in case of failure. + * + * @since 3.16.0 + * @category Error handling + * @experimental + */ + (effect: Effect, plan: ExecutionPlan<{ + provides: Provides; + input: Input; + error: PlanE; + requirements: PlanR; + }>): Effect | PlanR>; +}; +/** + * Retries a failing effect and runs a fallback effect if retries are exhausted. + * + * **Details** + * + * The `Effect.retryOrElse` function attempts to retry a failing effect multiple + * times according to a defined {@link Schedule} policy. + * + * If the retries are exhausted and the effect still fails, it runs a fallback + * effect instead. + * + * **When to Use** + * + * This function is useful when you want to handle failures gracefully by + * specifying an alternative action after repeated failures. + * + * **Example** (Retrying with Fallback) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task with a delay between retries and a maximum of 2 retries + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * + * // If all retries fail, run the fallback effect + * const repeated = Effect.retryOrElse( + * task, + * policy, + * // fallback + * () => Console.log("orElse").pipe(Effect.as("default value")) + * ) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // orElse + * // default value + * ``` + * + * @see {@link retry} for a version that does not run a fallback effect. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const retryOrElse: { + /** + * Retries a failing effect and runs a fallback effect if retries are exhausted. + * + * **Details** + * + * The `Effect.retryOrElse` function attempts to retry a failing effect multiple + * times according to a defined {@link Schedule} policy. + * + * If the retries are exhausted and the effect still fails, it runs a fallback + * effect instead. + * + * **When to Use** + * + * This function is useful when you want to handle failures gracefully by + * specifying an alternative action after repeated failures. + * + * **Example** (Retrying with Fallback) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task with a delay between retries and a maximum of 2 retries + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * + * // If all retries fail, run the fallback effect + * const repeated = Effect.retryOrElse( + * task, + * policy, + * // fallback + * () => Console.log("orElse").pipe(Effect.as("default value")) + * ) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // orElse + * // default value + * ``` + * + * @see {@link retry} for a version that does not run a fallback effect. + * + * @since 2.0.0 + * @category Error handling + */ + (policy: Schedule.Schedule, R1>, orElse: (e: NoInfer, out: A1) => Effect): (self: Effect) => Effect; + /** + * Retries a failing effect and runs a fallback effect if retries are exhausted. + * + * **Details** + * + * The `Effect.retryOrElse` function attempts to retry a failing effect multiple + * times according to a defined {@link Schedule} policy. + * + * If the retries are exhausted and the effect still fails, it runs a fallback + * effect instead. + * + * **When to Use** + * + * This function is useful when you want to handle failures gracefully by + * specifying an alternative action after repeated failures. + * + * **Example** (Retrying with Fallback) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * let count = 0 + * + * // Simulates an effect with possible failures + * const task = Effect.async((resume) => { + * if (count <= 2) { + * count++ + * console.log("failure") + * resume(Effect.fail(new Error())) + * } else { + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * // Retry the task with a delay between retries and a maximum of 2 retries + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * + * // If all retries fail, run the fallback effect + * const repeated = Effect.retryOrElse( + * task, + * policy, + * // fallback + * () => Console.log("orElse").pipe(Effect.as("default value")) + * ) + * + * Effect.runPromise(repeated).then(console.log) + * // Output: + * // failure + * // failure + * // failure + * // orElse + * // default value + * ``` + * + * @see {@link retry} for a version that does not run a fallback effect. + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, policy: Schedule.Schedule, R1>, orElse: (e: NoInfer, out: A1) => Effect): Effect; +}; +declare const try_: { + (options: { + readonly try: LazyArg; + readonly catch: (error: unknown) => E; + }): Effect; + (thunk: LazyArg): Effect; +}; +export { +/** + * Creates an `Effect` that represents a synchronous computation that might + * fail. + * + * **When to Use** + * + * In situations where you need to perform synchronous operations that might + * fail, such as parsing JSON, you can use the `try` constructor. This + * constructor is designed to handle operations that could throw exceptions by + * capturing those exceptions and transforming them into manageable errors. + * + * **Error Handling** + * + * There are two ways to handle errors with `try`: + * + * 1. If you don't provide a `catch` function, the error is caught and the + * effect fails with an `UnknownException`. + * 2. If you provide a `catch` function, the error is caught and the `catch` + * function maps it to an error of type `E`. + * + * **Example** (Safe JSON Parsing) + * + * ```ts + * import { Effect } from "effect" + * + * const parse = (input: string) => + * // This might throw an error if input is not valid JSON + * Effect.try(() => JSON.parse(input)) + * + * // ┌─── Effect + * // ▼ + * const program = parse("") + * + * ``` + * + * **Example** (Custom Error Handling) + * + * ```ts + * import { Effect } from "effect" + * + * const parse = (input: string) => + * Effect.try({ + * // JSON.parse may throw for bad input + * try: () => JSON.parse(input), + * // remap the error + * catch: (unknown) => new Error(`something went wrong ${unknown}`) + * }) + * + * // ┌─── Effect + * // ▼ + * const program = parse("") + * ``` + * + * @see {@link sync} if the effectful computation is synchronous and does not + * throw errors. + * + * @since 2.0.0 + * @category Creating Effects + */ +try_ as try }; +/** + * Returns an effect that maps its success using the specified side-effecting + * `try` function, converting any errors into typed failed effects using the + * `catch` function. + * + * @see {@link tryPromise} for a version that works with asynchronous computations. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const tryMap: { + /** + * Returns an effect that maps its success using the specified side-effecting + * `try` function, converting any errors into typed failed effects using the + * `catch` function. + * + * @see {@link tryPromise} for a version that works with asynchronous computations. + * + * @since 2.0.0 + * @category Error handling + */ + (options: { + readonly try: (a: A) => B; + readonly catch: (error: unknown) => E1; + }): (self: Effect) => Effect; + /** + * Returns an effect that maps its success using the specified side-effecting + * `try` function, converting any errors into typed failed effects using the + * `catch` function. + * + * @see {@link tryPromise} for a version that works with asynchronous computations. + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, options: { + readonly try: (a: A) => B; + readonly catch: (error: unknown) => E1; + }): Effect; +}; +/** + * Returns an effect that maps its success using the specified side-effecting + * `try` function, converting any promise rejections into typed failed effects + * using the `catch` function. + * + * An optional `AbortSignal` can be provided to allow for interruption of the + * wrapped `Promise` API. + * + * @see {@link tryMap} for a version that works with synchronous computations. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const tryMapPromise: { + /** + * Returns an effect that maps its success using the specified side-effecting + * `try` function, converting any promise rejections into typed failed effects + * using the `catch` function. + * + * An optional `AbortSignal` can be provided to allow for interruption of the + * wrapped `Promise` API. + * + * @see {@link tryMap} for a version that works with synchronous computations. + * + * @since 2.0.0 + * @category Error handling + */ + (options: { + readonly try: (a: A, signal: AbortSignal) => PromiseLike; + readonly catch: (error: unknown) => E1; + }): (self: Effect) => Effect; + /** + * Returns an effect that maps its success using the specified side-effecting + * `try` function, converting any promise rejections into typed failed effects + * using the `catch` function. + * + * An optional `AbortSignal` can be provided to allow for interruption of the + * wrapped `Promise` API. + * + * @see {@link tryMap} for a version that works with synchronous computations. + * + * @since 2.0.0 + * @category Error handling + */ + (self: Effect, options: { + readonly try: (a: A, signal: AbortSignal) => PromiseLike; + readonly catch: (error: unknown) => E1; + }): Effect; +}; +/** + * Creates an `Effect` that represents an asynchronous computation that might + * fail. + * + * **When to Use** + * + * In situations where you need to perform asynchronous operations that might + * fail, such as fetching data from an API, you can use the `tryPromise` + * constructor. This constructor is designed to handle operations that could + * throw exceptions by capturing those exceptions and transforming them into + * manageable errors. + * + * **Error Handling** + * + * There are two ways to handle errors with `tryPromise`: + * + * 1. If you don't provide a `catch` function, the error is caught and the + * effect fails with an `UnknownException`. + * 2. If you provide a `catch` function, the error is caught and the `catch` + * function maps it to an error of type `E`. + * + * **Interruptions** + * + * An optional `AbortSignal` can be provided to allow for interruption of the + * wrapped `Promise` API. + * + * **Example** (Fetching a TODO Item) + * + * ```ts + * import { Effect } from "effect" + * + * const getTodo = (id: number) => + * // Will catch any errors and propagate them as UnknownException + * Effect.tryPromise(() => + * fetch(`https://jsonplaceholder.typicode.com/todos/${id}`) + * ) + * + * // ┌─── Effect + * // ▼ + * const program = getTodo(1) + * ``` + * + * **Example** (Custom Error Handling) + * + * ```ts + * import { Effect } from "effect" + * + * const getTodo = (id: number) => + * Effect.tryPromise({ + * try: () => fetch(`https://jsonplaceholder.typicode.com/todos/${id}`), + * // remap the error + * catch: (unknown) => new Error(`something went wrong ${unknown}`) + * }) + * + * // ┌─── Effect + * // ▼ + * const program = getTodo(1) + * ``` + * + * @see {@link promise} if the effectful computation is asynchronous and does not throw errors. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const tryPromise: { + /** + * Creates an `Effect` that represents an asynchronous computation that might + * fail. + * + * **When to Use** + * + * In situations where you need to perform asynchronous operations that might + * fail, such as fetching data from an API, you can use the `tryPromise` + * constructor. This constructor is designed to handle operations that could + * throw exceptions by capturing those exceptions and transforming them into + * manageable errors. + * + * **Error Handling** + * + * There are two ways to handle errors with `tryPromise`: + * + * 1. If you don't provide a `catch` function, the error is caught and the + * effect fails with an `UnknownException`. + * 2. If you provide a `catch` function, the error is caught and the `catch` + * function maps it to an error of type `E`. + * + * **Interruptions** + * + * An optional `AbortSignal` can be provided to allow for interruption of the + * wrapped `Promise` API. + * + * **Example** (Fetching a TODO Item) + * + * ```ts + * import { Effect } from "effect" + * + * const getTodo = (id: number) => + * // Will catch any errors and propagate them as UnknownException + * Effect.tryPromise(() => + * fetch(`https://jsonplaceholder.typicode.com/todos/${id}`) + * ) + * + * // ┌─── Effect + * // ▼ + * const program = getTodo(1) + * ``` + * + * **Example** (Custom Error Handling) + * + * ```ts + * import { Effect } from "effect" + * + * const getTodo = (id: number) => + * Effect.tryPromise({ + * try: () => fetch(`https://jsonplaceholder.typicode.com/todos/${id}`), + * // remap the error + * catch: (unknown) => new Error(`something went wrong ${unknown}`) + * }) + * + * // ┌─── Effect + * // ▼ + * const program = getTodo(1) + * ``` + * + * @see {@link promise} if the effectful computation is asynchronous and does not throw errors. + * + * @since 2.0.0 + * @category Creating Effects + */ + (options: { + readonly try: (signal: AbortSignal) => PromiseLike; + readonly catch: (error: unknown) => E; + }): Effect; + /** + * Creates an `Effect` that represents an asynchronous computation that might + * fail. + * + * **When to Use** + * + * In situations where you need to perform asynchronous operations that might + * fail, such as fetching data from an API, you can use the `tryPromise` + * constructor. This constructor is designed to handle operations that could + * throw exceptions by capturing those exceptions and transforming them into + * manageable errors. + * + * **Error Handling** + * + * There are two ways to handle errors with `tryPromise`: + * + * 1. If you don't provide a `catch` function, the error is caught and the + * effect fails with an `UnknownException`. + * 2. If you provide a `catch` function, the error is caught and the `catch` + * function maps it to an error of type `E`. + * + * **Interruptions** + * + * An optional `AbortSignal` can be provided to allow for interruption of the + * wrapped `Promise` API. + * + * **Example** (Fetching a TODO Item) + * + * ```ts + * import { Effect } from "effect" + * + * const getTodo = (id: number) => + * // Will catch any errors and propagate them as UnknownException + * Effect.tryPromise(() => + * fetch(`https://jsonplaceholder.typicode.com/todos/${id}`) + * ) + * + * // ┌─── Effect + * // ▼ + * const program = getTodo(1) + * ``` + * + * **Example** (Custom Error Handling) + * + * ```ts + * import { Effect } from "effect" + * + * const getTodo = (id: number) => + * Effect.tryPromise({ + * try: () => fetch(`https://jsonplaceholder.typicode.com/todos/${id}`), + * // remap the error + * catch: (unknown) => new Error(`something went wrong ${unknown}`) + * }) + * + * // ┌─── Effect + * // ▼ + * const program = getTodo(1) + * ``` + * + * @see {@link promise} if the effectful computation is asynchronous and does not throw errors. + * + * @since 2.0.0 + * @category Creating Effects + */ + (evaluate: (signal: AbortSignal) => PromiseLike): Effect; +}; +/** + * The `unsandbox` function is used to revert an effect that has been + * sandboxed by {@link sandbox}. When you apply `unsandbox`, the + * effect's error channel is restored to its original state, without the + * detailed `Cause` information. This means that any underlying causes of + * errors, defects, or fiber interruptions are no longer exposed in the error + * channel. + * + * This function is useful when you want to remove the detailed error tracking + * provided by `sandbox` and return to the standard error handling for + * your effect. Once unsandboxed, the effect behaves as if `sandbox` was + * never applied. + * + * @see {@link sandbox} to expose the full cause of failures, defects, or interruptions. + * + * @since 2.0.0 + * @category Error handling + */ +export declare const unsandbox: (self: Effect, R>) => Effect; +/** + * Allows interruption of the current fiber, even in uninterruptible regions. + * + * **Details** + * + * This effect checks whether any other fibers are attempting to interrupt the + * current fiber. If so, it allows the current fiber to perform a + * self-interruption. + * + * **When to Use** + * + * This is useful in situations where you want to allow interruption to happen + * even in regions of the code that are normally uninterruptible. + * + * @since 2.0.0 + * @category Interruption + */ +export declare const allowInterrupt: Effect; +/** + * Checks if interruption is allowed and executes a callback accordingly. + * + * **Details** + * + * This function checks the current interrupt status of the running fiber. It + * then calls the provided callback, passing a boolean indicating whether + * interruption is allowed. + * + * **When to Use** + * + * This is useful for handling specific logic based on whether the current + * operation can be interrupted, such as when performing asynchronous operations + * or handling cancellation. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.checkInterruptible((isInterruptible) => { + * if (isInterruptible) { + * return Console.log("You can interrupt this operation.") + * } else { + * return Console.log("This operation cannot be interrupted.") + * } + * }) + * }) + * + * Effect.runPromise(program) + * // Output: You can interrupt this operation. + * + * Effect.runPromise(program.pipe(Effect.uninterruptible)) + * // Output: This operation cannot be interrupted. + * + * ``` + * + * @since 2.0.0 + * @category Interruption + */ +export declare const checkInterruptible: (f: (isInterruptible: boolean) => Effect) => Effect; +/** + * Provides a way to handle timeouts in uninterruptible effects, allowing them + * to continue in the background while the main control flow proceeds with the + * timeout error. + * + * **Details** + * + * The `disconnect` function allows an uninterruptible effect to continue + * running in the background, while enabling the main control flow to + * immediately recognize a timeout condition. This is useful when you want to + * avoid blocking the program due to long-running tasks, especially when those + * tasks do not need to affect the flow of the rest of the program. + * + * Without `disconnect`, an uninterruptible effect will ignore the + * timeout and continue executing until it completes. The timeout error will + * only be assessed after the effect finishes, which can cause delays in + * recognizing a timeout. + * + * With `disconnect`, the uninterruptible effect proceeds in the + * background while the main program flow can immediately handle the timeout + * error or trigger alternative logic. This enables faster timeout handling + * without waiting for the completion of the long-running task. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const longRunningTask = Effect.gen(function* () { + * console.log("Start heavy processing...") + * yield* Effect.sleep("5 seconds") // Simulate a long process + * console.log("Heavy processing done.") + * return "Data processed" + * }) + * + * const timedEffect = longRunningTask.pipe( + * Effect.uninterruptible, + * // Allows the task to finish in the background if it times out + * Effect.disconnect, + * Effect.timeout("1 second") + * ) + * + * Effect.runPromiseExit(timedEffect).then(console.log) + * // Output: + * // Start heavy processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: { _tag: 'TimeoutException' } + * // } + * // } + * // Heavy processing done. + * ``` + * + * @see {@link timeout} for a version that interrupts the effect. + * @see {@link uninterruptible} for creating an uninterruptible effect. + * + * @since 2.0.0 + * @category Interruption + */ +export declare const disconnect: (self: Effect) => Effect; +/** + * Represents an effect that interrupts the current fiber. + * + * **Details** + * + * This effect models the explicit interruption of the fiber in which it runs. + * When executed, it causes the fiber to stop its operation immediately, + * capturing the interruption details such as the fiber's ID and its start time. + * The resulting interruption can be observed in the `Exit` type if the effect + * is run with functions like {@link runPromiseExit}. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function* () { + * console.log("start") + * yield* Effect.sleep("2 seconds") + * yield* Effect.interrupt + * console.log("done") + * return "some result" + * }) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // start + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Interrupt', + * // fiberId: { + * // _id: 'FiberId', + * // _tag: 'Runtime', + * // id: 0, + * // startTimeMillis: ... + * // } + * // } + * // } + * ``` + * + * @since 2.0.0 + * @category Interruption + */ +export declare const interrupt: Effect; +/** + * @since 2.0.0 + * @category Interruption + */ +export declare const interruptWith: (fiberId: FiberId.FiberId) => Effect; +/** + * Marks an effect as interruptible. + * + * @since 2.0.0 + * @category Interruption + */ +export declare const interruptible: (self: Effect) => Effect; +/** + * This function behaves like {@link interruptible}, but it also provides a + * `restore` function. This function can be used to restore the interruptibility + * of any specific region of code. + * + * @since 2.0.0 + * @category Interruption + */ +export declare const interruptibleMask: (f: (restore: (effect: Effect) => Effect) => Effect) => Effect; +/** + * Registers a cleanup effect to run when an effect is interrupted. + * + * **Details** + * + * This function allows you to specify an effect to run when the fiber is + * interrupted. This effect will be executed when the fiber is interrupted, + * allowing you to perform cleanup or other actions. + * + * **Example** (Running a Cleanup Action on Interruption) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // This handler is executed when the fiber is interrupted + * const handler = Effect.onInterrupt((_fibers) => Console.log("Cleanup completed")) + * + * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * + * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * + * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed + * ``` + * + * @since 2.0.0 + * @category Interruption + */ +export declare const onInterrupt: { + /** + * Registers a cleanup effect to run when an effect is interrupted. + * + * **Details** + * + * This function allows you to specify an effect to run when the fiber is + * interrupted. This effect will be executed when the fiber is interrupted, + * allowing you to perform cleanup or other actions. + * + * **Example** (Running a Cleanup Action on Interruption) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // This handler is executed when the fiber is interrupted + * const handler = Effect.onInterrupt((_fibers) => Console.log("Cleanup completed")) + * + * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * + * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * + * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed + * ``` + * + * @since 2.0.0 + * @category Interruption + */ + (cleanup: (interruptors: HashSet.HashSet) => Effect): (self: Effect) => Effect; + /** + * Registers a cleanup effect to run when an effect is interrupted. + * + * **Details** + * + * This function allows you to specify an effect to run when the fiber is + * interrupted. This effect will be executed when the fiber is interrupted, + * allowing you to perform cleanup or other actions. + * + * **Example** (Running a Cleanup Action on Interruption) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // This handler is executed when the fiber is interrupted + * const handler = Effect.onInterrupt((_fibers) => Console.log("Cleanup completed")) + * + * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * + * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * + * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed + * ``` + * + * @since 2.0.0 + * @category Interruption + */ + (self: Effect, cleanup: (interruptors: HashSet.HashSet) => Effect): Effect; +}; +/** + * Marks an effect as uninterruptible. + * + * @since 2.0.0 + * @category Interruption + */ +export declare const uninterruptible: (self: Effect) => Effect; +/** + * This function behaves like {@link uninterruptible}, but it also provides a + * `restore` function. This function can be used to restore the interruptibility + * of any specific region of code. + * + * @since 2.0.0 + * @category Interruption + */ +export declare const uninterruptibleMask: (f: (restore: (effect: Effect) => Effect) => Effect) => Effect; +/** + * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true` + * or failing with specified error if the predicate fails + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * // succeeds with `1` + * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`) + * + * // fails with `"0 is not positive"` + * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`) + * ``` + * + * @category Condition Checking + * @since 3.4.0 + */ +export declare const liftPredicate: { + /** + * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true` + * or failing with specified error if the predicate fails + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * // succeeds with `1` + * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`) + * + * // fails with `"0 is not positive"` + * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`) + * ``` + * + * @category Condition Checking + * @since 3.4.0 + */ + (predicate: Refinement | Predicate, orFailWith: (a: EqualsWith>) => E): (a: A) => Effect, E>; + /** + * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true` + * or failing with specified error if the predicate fails + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * // succeeds with `1` + * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`) + * + * // fails with `"0 is not positive"` + * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`) + * ``` + * + * @category Condition Checking + * @since 3.4.0 + */ + (self: A, predicate: Refinement | Predicate, orFailWith: (a: EqualsWith>) => E): Effect; +}; +/** + * Replaces the value inside an effect with a constant value. + * + * **Details** + * + * This function allows you to ignore the original value inside an effect and + * replace it with a constant value. + * + * **When to Use** + * + * It is useful when you no longer need the value produced by an effect but want + * to ensure that the effect completes successfully with a specific constant + * result instead. For instance, you can replace the value produced by a + * computation with a predefined value, ignoring what was calculated before. + * + * **Example** (Replacing a Value) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Replaces the value 5 with the constant "new value" + * const program = pipe(Effect.succeed(5), Effect.as("new value")) + * + * Effect.runPromise(program).then(console.log) + * // Output: "new value" + * ``` + * + * @since 2.0.0 + * @category Mapping + */ +export declare const as: { + /** + * Replaces the value inside an effect with a constant value. + * + * **Details** + * + * This function allows you to ignore the original value inside an effect and + * replace it with a constant value. + * + * **When to Use** + * + * It is useful when you no longer need the value produced by an effect but want + * to ensure that the effect completes successfully with a specific constant + * result instead. For instance, you can replace the value produced by a + * computation with a predefined value, ignoring what was calculated before. + * + * **Example** (Replacing a Value) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Replaces the value 5 with the constant "new value" + * const program = pipe(Effect.succeed(5), Effect.as("new value")) + * + * Effect.runPromise(program).then(console.log) + * // Output: "new value" + * ``` + * + * @since 2.0.0 + * @category Mapping + */ + (value: B): (self: Effect) => Effect; + /** + * Replaces the value inside an effect with a constant value. + * + * **Details** + * + * This function allows you to ignore the original value inside an effect and + * replace it with a constant value. + * + * **When to Use** + * + * It is useful when you no longer need the value produced by an effect but want + * to ensure that the effect completes successfully with a specific constant + * result instead. For instance, you can replace the value produced by a + * computation with a predefined value, ignoring what was calculated before. + * + * **Example** (Replacing a Value) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Replaces the value 5 with the constant "new value" + * const program = pipe(Effect.succeed(5), Effect.as("new value")) + * + * Effect.runPromise(program).then(console.log) + * // Output: "new value" + * ``` + * + * @since 2.0.0 + * @category Mapping + */ + (self: Effect, value: B): Effect; +}; +/** + * This function maps the success value of an `Effect` value to a `Some` value + * in an `Option` value. If the original `Effect` value fails, the returned + * `Effect` value will also fail. + * + * @category Mapping + * @since 2.0.0 + */ +export declare const asSome: (self: Effect) => Effect, E, R>; +/** + * This function maps the error value of an `Effect` value to a `Some` value + * in an `Option` value. If the original `Effect` value succeeds, the returned + * `Effect` value will also succeed. + * + * @category Mapping + * @since 2.0.0 + */ +export declare const asSomeError: (self: Effect) => Effect, R>; +/** + * This function maps the success value of an `Effect` value to `void`. If the + * original `Effect` value succeeds, the returned `Effect` value will also + * succeed. If the original `Effect` value fails, the returned `Effect` value + * will fail with the same error. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const asVoid: (self: Effect) => Effect; +/** + * Swaps the success and error channels of an effect. + * + * **Details** + * + * This function reverses the flow of an effect by swapping its success and + * error channels. The success value becomes an error, and the error value + * becomes a success. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.fail("Oh uh!").pipe(Effect.as(2)) + * + * // ┌─── Effect + * // ▼ + * const flipped = Effect.flip(program) + * ``` + * + * @since 2.0.0 + * @category Mapping + */ +export declare const flip: (self: Effect) => Effect; +/** + * Swaps the error/value parameters, applies the function `f` and flips the + * parameters back + * + * @since 2.0.0 + * @category Mapping + */ +export declare const flipWith: { + /** + * Swaps the error/value parameters, applies the function `f` and flips the + * parameters back + * + * @since 2.0.0 + * @category Mapping + */ + (f: (effect: Effect) => Effect): (self: Effect) => Effect; + /** + * Swaps the error/value parameters, applies the function `f` and flips the + * parameters back + * + * @since 2.0.0 + * @category Mapping + */ + (self: Effect, f: (effect: Effect) => Effect): Effect; +}; +/** + * Transforms the value inside an effect by applying a function to it. + * + * **Syntax** + * + * ```ts skip-type-checking + * const mappedEffect = pipe(myEffect, Effect.map(transformation)) + * // or + * const mappedEffect = Effect.map(myEffect, transformation) + * // or + * const mappedEffect = myEffect.pipe(Effect.map(transformation)) + * ``` + * + * **Details** + * + * `map` takes a function and applies it to the value contained within an + * effect, creating a new effect with the transformed value. + * + * It's important to note that effects are immutable, meaning that the original + * effect is not modified. Instead, a new effect is returned with the updated + * value. + * + * **Example** (Adding a Service Charge) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * const addServiceCharge = (amount: number) => amount + 1 + * + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * Effect.map(addServiceCharge) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: 101 + * ``` + * + * @see {@link mapError} for a version that operates on the error channel. + * @see {@link mapBoth} for a version that operates on both channels. + * @see {@link flatMap} or {@link andThen} for a version that can return a new effect. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const map: { + /** + * Transforms the value inside an effect by applying a function to it. + * + * **Syntax** + * + * ```ts skip-type-checking + * const mappedEffect = pipe(myEffect, Effect.map(transformation)) + * // or + * const mappedEffect = Effect.map(myEffect, transformation) + * // or + * const mappedEffect = myEffect.pipe(Effect.map(transformation)) + * ``` + * + * **Details** + * + * `map` takes a function and applies it to the value contained within an + * effect, creating a new effect with the transformed value. + * + * It's important to note that effects are immutable, meaning that the original + * effect is not modified. Instead, a new effect is returned with the updated + * value. + * + * **Example** (Adding a Service Charge) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * const addServiceCharge = (amount: number) => amount + 1 + * + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * Effect.map(addServiceCharge) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: 101 + * ``` + * + * @see {@link mapError} for a version that operates on the error channel. + * @see {@link mapBoth} for a version that operates on both channels. + * @see {@link flatMap} or {@link andThen} for a version that can return a new effect. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (a: A) => B): (self: Effect) => Effect; + /** + * Transforms the value inside an effect by applying a function to it. + * + * **Syntax** + * + * ```ts skip-type-checking + * const mappedEffect = pipe(myEffect, Effect.map(transformation)) + * // or + * const mappedEffect = Effect.map(myEffect, transformation) + * // or + * const mappedEffect = myEffect.pipe(Effect.map(transformation)) + * ``` + * + * **Details** + * + * `map` takes a function and applies it to the value contained within an + * effect, creating a new effect with the transformed value. + * + * It's important to note that effects are immutable, meaning that the original + * effect is not modified. Instead, a new effect is returned with the updated + * value. + * + * **Example** (Adding a Service Charge) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * const addServiceCharge = (amount: number) => amount + 1 + * + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * Effect.map(addServiceCharge) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: 101 + * ``` + * + * @see {@link mapError} for a version that operates on the error channel. + * @see {@link mapBoth} for a version that operates on both channels. + * @see {@link flatMap} or {@link andThen} for a version that can return a new effect. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Effect, f: (a: A) => B): Effect; +}; +/** + * Applies a stateful transformation to each element of a collection, producing + * new elements along with an updated state. + * + * **When to Use** + * + * Use `mapAccum` when you need to process each element of a collection while + * keeping track of some state across iterations. + * + * **Details** + * + * `mapAccum` takes an initial state (`initial`) and a function (`f`) that is + * applied to each element. This function returns a new state and a transformed + * element. The final effect produces both the accumulated state and the + * transformed collection. + * + * If the input collection is a non-empty array, the return type will match the + * input collection type. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // Define an initial state and a transformation function + * const initialState = 0 + * + * const transformation = (state: number, element: string) => + * Effect.succeed<[number, string]>([state + element.length, element.toUpperCase()]) + * + * // Apply mapAccum to transform an array of strings + * const program = Effect.mapAccum(["a", "bb", "ccc"], initialState, transformation) + * + * Effect.runPromise(program).then(([finalState, transformedCollection]) => { + * console.log(finalState) + * console.log(transformedCollection) + * }) + * // Output: + * // 6 + * // [ 'A', 'BB', 'CCC' ] + * ``` + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapAccum: { + /** + * Applies a stateful transformation to each element of a collection, producing + * new elements along with an updated state. + * + * **When to Use** + * + * Use `mapAccum` when you need to process each element of a collection while + * keeping track of some state across iterations. + * + * **Details** + * + * `mapAccum` takes an initial state (`initial`) and a function (`f`) that is + * applied to each element. This function returns a new state and a transformed + * element. The final effect produces both the accumulated state and the + * transformed collection. + * + * If the input collection is a non-empty array, the return type will match the + * input collection type. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // Define an initial state and a transformation function + * const initialState = 0 + * + * const transformation = (state: number, element: string) => + * Effect.succeed<[number, string]>([state + element.length, element.toUpperCase()]) + * + * // Apply mapAccum to transform an array of strings + * const program = Effect.mapAccum(["a", "bb", "ccc"], initialState, transformation) + * + * Effect.runPromise(program).then(([finalState, transformedCollection]) => { + * console.log(finalState) + * console.log(transformedCollection) + * }) + * // Output: + * // 6 + * // [ 'A', 'BB', 'CCC' ] + * ``` + * + * @since 2.0.0 + * @category Mapping + */ + = Iterable>(initial: S, f: (state: S, a: RA.ReadonlyArray.Infer, i: number) => Effect): (elements: I) => Effect<[S, RA.ReadonlyArray.With], E, R>; + /** + * Applies a stateful transformation to each element of a collection, producing + * new elements along with an updated state. + * + * **When to Use** + * + * Use `mapAccum` when you need to process each element of a collection while + * keeping track of some state across iterations. + * + * **Details** + * + * `mapAccum` takes an initial state (`initial`) and a function (`f`) that is + * applied to each element. This function returns a new state and a transformed + * element. The final effect produces both the accumulated state and the + * transformed collection. + * + * If the input collection is a non-empty array, the return type will match the + * input collection type. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // Define an initial state and a transformation function + * const initialState = 0 + * + * const transformation = (state: number, element: string) => + * Effect.succeed<[number, string]>([state + element.length, element.toUpperCase()]) + * + * // Apply mapAccum to transform an array of strings + * const program = Effect.mapAccum(["a", "bb", "ccc"], initialState, transformation) + * + * Effect.runPromise(program).then(([finalState, transformedCollection]) => { + * console.log(finalState) + * console.log(transformedCollection) + * }) + * // Output: + * // 6 + * // [ 'A', 'BB', 'CCC' ] + * ``` + * + * @since 2.0.0 + * @category Mapping + */ + = Iterable>(elements: I, initial: S, f: (state: S, a: RA.ReadonlyArray.Infer, i: number) => Effect): Effect<[S, RA.ReadonlyArray.With], E, R>; +}; +/** + * Applies transformations to both the success and error channels of an effect. + * + * **Details** + * + * This function takes two map functions as arguments: one for the error channel + * and one for the success channel. You can use it when you want to modify both + * the error and the success values without altering the overall success or + * failure status of the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1)) + * + * // ┌─── Effect + * // ▼ + * const modified = Effect.mapBoth(simulatedTask, { + * onFailure: (message) => new Error(message), + * onSuccess: (n) => n > 0 + * }) + * ``` + * + * @see {@link map} for a version that operates on the success channel. + * @see {@link mapError} for a version that operates on the error channel. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapBoth: { + /** + * Applies transformations to both the success and error channels of an effect. + * + * **Details** + * + * This function takes two map functions as arguments: one for the error channel + * and one for the success channel. You can use it when you want to modify both + * the error and the success values without altering the overall success or + * failure status of the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1)) + * + * // ┌─── Effect + * // ▼ + * const modified = Effect.mapBoth(simulatedTask, { + * onFailure: (message) => new Error(message), + * onSuccess: (n) => n > 0 + * }) + * ``` + * + * @see {@link map} for a version that operates on the success channel. + * @see {@link mapError} for a version that operates on the error channel. + * + * @since 2.0.0 + * @category Mapping + */ + (options: { + readonly onFailure: (e: E) => E2; + readonly onSuccess: (a: A) => A2; + }): (self: Effect) => Effect; + /** + * Applies transformations to both the success and error channels of an effect. + * + * **Details** + * + * This function takes two map functions as arguments: one for the error channel + * and one for the success channel. You can use it when you want to modify both + * the error and the success values without altering the overall success or + * failure status of the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1)) + * + * // ┌─── Effect + * // ▼ + * const modified = Effect.mapBoth(simulatedTask, { + * onFailure: (message) => new Error(message), + * onSuccess: (n) => n > 0 + * }) + * ``` + * + * @see {@link map} for a version that operates on the success channel. + * @see {@link mapError} for a version that operates on the error channel. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Effect, options: { + readonly onFailure: (e: E) => E2; + readonly onSuccess: (a: A) => A2; + }): Effect; +}; +/** + * Transforms or modifies the error produced by an effect without affecting its + * success value. + * + * **When to Use** + * + * This function is helpful when you want to enhance the error with additional + * information, change the error type, or apply custom error handling while + * keeping the original behavior of the effect's success values intact. It only + * operates on the error channel and leaves the success channel unchanged. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1)) + * + * // ┌─── Effect + * // ▼ + * const mapped = Effect.mapError( + * simulatedTask, + * (message) => new Error(message) + * ) + * ``` + * + * @see {@link map} for a version that operates on the success channel. + * @see {@link mapBoth} for a version that operates on both channels. + * @see {@link orElseFail} if you want to replace the error with a new one. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapError: { + /** + * Transforms or modifies the error produced by an effect without affecting its + * success value. + * + * **When to Use** + * + * This function is helpful when you want to enhance the error with additional + * information, change the error type, or apply custom error handling while + * keeping the original behavior of the effect's success values intact. It only + * operates on the error channel and leaves the success channel unchanged. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1)) + * + * // ┌─── Effect + * // ▼ + * const mapped = Effect.mapError( + * simulatedTask, + * (message) => new Error(message) + * ) + * ``` + * + * @see {@link map} for a version that operates on the success channel. + * @see {@link mapBoth} for a version that operates on both channels. + * @see {@link orElseFail} if you want to replace the error with a new one. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (e: E) => E2): (self: Effect) => Effect; + /** + * Transforms or modifies the error produced by an effect without affecting its + * success value. + * + * **When to Use** + * + * This function is helpful when you want to enhance the error with additional + * information, change the error type, or apply custom error handling while + * keeping the original behavior of the effect's success values intact. It only + * operates on the error channel and leaves the success channel unchanged. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1)) + * + * // ┌─── Effect + * // ▼ + * const mapped = Effect.mapError( + * simulatedTask, + * (message) => new Error(message) + * ) + * ``` + * + * @see {@link map} for a version that operates on the success channel. + * @see {@link mapBoth} for a version that operates on both channels. + * @see {@link orElseFail} if you want to replace the error with a new one. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Effect, f: (e: E) => E2): Effect; +}; +/** + * Maps the cause of failure of an effect using a specified function. + * + * @see {@link sandbox} for a version that exposes the full cause of failures, defects, or interruptions. + * @see {@link catchAllCause} for a version that can recover from all types of defects. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapErrorCause: { + /** + * Maps the cause of failure of an effect using a specified function. + * + * @see {@link sandbox} for a version that exposes the full cause of failures, defects, or interruptions. + * @see {@link catchAllCause} for a version that can recover from all types of defects. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (cause: Cause.Cause) => Cause.Cause): (self: Effect) => Effect; + /** + * Maps the cause of failure of an effect using a specified function. + * + * @see {@link sandbox} for a version that exposes the full cause of failures, defects, or interruptions. + * @see {@link catchAllCause} for a version that can recover from all types of defects. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Effect, f: (cause: Cause.Cause) => Cause.Cause): Effect; +}; +/** + * Combines both success and error channels of an effect into a single outcome. + * + * **Details** + * + * This function transforms an effect that may fail into one that always returns + * a value, where both success and failure outcomes are handled as values in the + * success channel. + * + * **When to Use** + * + * This can be useful when you want to continue execution regardless of the + * error type and still capture both successful results and errors as part of + * the outcome. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.fail("Oh uh!").pipe(Effect.as(2)) + * + * // ┌─── Effect + * // ▼ + * const recovered = Effect.merge(program) + * ``` + * + * @since 2.0.0 + * @category Mapping + */ +export declare const merge: (self: Effect) => Effect; +/** + * Returns a new effect with the boolean value of this effect negated. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const negate: (self: Effect) => Effect; +/** + * Creates a scoped resource using an `acquire` and `release` effect. + * + * **Details** + * + * This function helps manage resources by combining two `Effect` values: one + * for acquiring the resource and one for releasing it. + * + * `acquireRelease` does the following: + * + * 1. Ensures that the effect that acquires the resource will not be + * interrupted. Note that acquisition may still fail due to internal + * reasons (such as an uncaught exception). + * 2. Ensures that the `release` effect will not be interrupted, and will be + * executed as long as the acquisition effect successfully acquires the + * resource. + * + * If the `acquire` function succeeds, the `release` function is added to the + * list of finalizers for the scope. This ensures that the release will happen + * automatically when the scope is closed. + * + * Both `acquire` and `release` run uninterruptibly, meaning they cannot be + * interrupted while they are executing. + * + * Additionally, the `release` function can be influenced by the exit value when + * the scope closes, allowing for custom handling of how the resource is + * released based on the execution outcome. + * + * **When to Use** + * + * This function is used to ensure that an effect that represents the + * acquisition of a resource (for example, opening a file, launching a thread, + * etc.) will not be interrupted, and that the resource will always be released + * when the `Effect` completes execution. + * + * **Example** (Defining a Simple Resource) + * + * ```ts + * import { Effect } from "effect" + * + * // Define an interface for a resource + * interface MyResource { + * readonly contents: string + * readonly close: () => Promise + * } + * + * // Simulate resource acquisition + * const getMyResource = (): Promise => + * Promise.resolve({ + * contents: "lorem ipsum", + * close: () => + * new Promise((resolve) => { + * console.log("Resource released") + * resolve() + * }) + * }) + * + * // Define how the resource is acquired + * const acquire = Effect.tryPromise({ + * try: () => + * getMyResource().then((res) => { + * console.log("Resource acquired") + * return res + * }), + * catch: () => new Error("getMyResourceError") + * }) + * + * // Define how the resource is released + * const release = (res: MyResource) => Effect.promise(() => res.close()) + * + * // Create the resource management workflow + * // + * // ┌─── Effect + * // ▼ + * const resource = Effect.acquireRelease(acquire, release) + * ``` + * + * @see {@link acquireUseRelease} for a version that automatically handles the scoping of resources. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const acquireRelease: { + /** + * Creates a scoped resource using an `acquire` and `release` effect. + * + * **Details** + * + * This function helps manage resources by combining two `Effect` values: one + * for acquiring the resource and one for releasing it. + * + * `acquireRelease` does the following: + * + * 1. Ensures that the effect that acquires the resource will not be + * interrupted. Note that acquisition may still fail due to internal + * reasons (such as an uncaught exception). + * 2. Ensures that the `release` effect will not be interrupted, and will be + * executed as long as the acquisition effect successfully acquires the + * resource. + * + * If the `acquire` function succeeds, the `release` function is added to the + * list of finalizers for the scope. This ensures that the release will happen + * automatically when the scope is closed. + * + * Both `acquire` and `release` run uninterruptibly, meaning they cannot be + * interrupted while they are executing. + * + * Additionally, the `release` function can be influenced by the exit value when + * the scope closes, allowing for custom handling of how the resource is + * released based on the execution outcome. + * + * **When to Use** + * + * This function is used to ensure that an effect that represents the + * acquisition of a resource (for example, opening a file, launching a thread, + * etc.) will not be interrupted, and that the resource will always be released + * when the `Effect` completes execution. + * + * **Example** (Defining a Simple Resource) + * + * ```ts + * import { Effect } from "effect" + * + * // Define an interface for a resource + * interface MyResource { + * readonly contents: string + * readonly close: () => Promise + * } + * + * // Simulate resource acquisition + * const getMyResource = (): Promise => + * Promise.resolve({ + * contents: "lorem ipsum", + * close: () => + * new Promise((resolve) => { + * console.log("Resource released") + * resolve() + * }) + * }) + * + * // Define how the resource is acquired + * const acquire = Effect.tryPromise({ + * try: () => + * getMyResource().then((res) => { + * console.log("Resource acquired") + * return res + * }), + * catch: () => new Error("getMyResourceError") + * }) + * + * // Define how the resource is released + * const release = (res: MyResource) => Effect.promise(() => res.close()) + * + * // Create the resource management workflow + * // + * // ┌─── Effect + * // ▼ + * const resource = Effect.acquireRelease(acquire, release) + * ``` + * + * @see {@link acquireUseRelease} for a version that automatically handles the scoping of resources. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (release: (a: A, exit: Exit.Exit) => Effect): (acquire: Effect) => Effect; + /** + * Creates a scoped resource using an `acquire` and `release` effect. + * + * **Details** + * + * This function helps manage resources by combining two `Effect` values: one + * for acquiring the resource and one for releasing it. + * + * `acquireRelease` does the following: + * + * 1. Ensures that the effect that acquires the resource will not be + * interrupted. Note that acquisition may still fail due to internal + * reasons (such as an uncaught exception). + * 2. Ensures that the `release` effect will not be interrupted, and will be + * executed as long as the acquisition effect successfully acquires the + * resource. + * + * If the `acquire` function succeeds, the `release` function is added to the + * list of finalizers for the scope. This ensures that the release will happen + * automatically when the scope is closed. + * + * Both `acquire` and `release` run uninterruptibly, meaning they cannot be + * interrupted while they are executing. + * + * Additionally, the `release` function can be influenced by the exit value when + * the scope closes, allowing for custom handling of how the resource is + * released based on the execution outcome. + * + * **When to Use** + * + * This function is used to ensure that an effect that represents the + * acquisition of a resource (for example, opening a file, launching a thread, + * etc.) will not be interrupted, and that the resource will always be released + * when the `Effect` completes execution. + * + * **Example** (Defining a Simple Resource) + * + * ```ts + * import { Effect } from "effect" + * + * // Define an interface for a resource + * interface MyResource { + * readonly contents: string + * readonly close: () => Promise + * } + * + * // Simulate resource acquisition + * const getMyResource = (): Promise => + * Promise.resolve({ + * contents: "lorem ipsum", + * close: () => + * new Promise((resolve) => { + * console.log("Resource released") + * resolve() + * }) + * }) + * + * // Define how the resource is acquired + * const acquire = Effect.tryPromise({ + * try: () => + * getMyResource().then((res) => { + * console.log("Resource acquired") + * return res + * }), + * catch: () => new Error("getMyResourceError") + * }) + * + * // Define how the resource is released + * const release = (res: MyResource) => Effect.promise(() => res.close()) + * + * // Create the resource management workflow + * // + * // ┌─── Effect + * // ▼ + * const resource = Effect.acquireRelease(acquire, release) + * ``` + * + * @see {@link acquireUseRelease} for a version that automatically handles the scoping of resources. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (acquire: Effect, release: (a: A, exit: Exit.Exit) => Effect): Effect; +}; +/** + * Creates a scoped resource with an interruptible acquire action. + * + * **Details** + * + * This function is similar to {@link acquireRelease}, but it allows the + * acquisition of the resource to be interrupted. The `acquire` effect, which + * represents the process of obtaining the resource, can be interrupted if + * necessary. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const acquireReleaseInterruptible: { + /** + * Creates a scoped resource with an interruptible acquire action. + * + * **Details** + * + * This function is similar to {@link acquireRelease}, but it allows the + * acquisition of the resource to be interrupted. The `acquire` effect, which + * represents the process of obtaining the resource, can be interrupted if + * necessary. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (release: (exit: Exit.Exit) => Effect): (acquire: Effect) => Effect; + /** + * Creates a scoped resource with an interruptible acquire action. + * + * **Details** + * + * This function is similar to {@link acquireRelease}, but it allows the + * acquisition of the resource to be interrupted. The `acquire` effect, which + * represents the process of obtaining the resource, can be interrupted if + * necessary. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (acquire: Effect, release: (exit: Exit.Exit) => Effect): Effect; +}; +/** + * Many real-world operations involve working with resources that must be released when no longer needed, such as: + * + * - Database connections + * - File handles + * - Network requests + * + * This function ensures that a resource is: + * + * 1. **Acquired** properly. + * 2. **Used** for its intended purpose. + * 3. **Released** even if an error occurs. + * + * **Example** (Automatically Managing Resource Lifetime) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Define an interface for a resource + * interface MyResource { + * readonly contents: string + * readonly close: () => Promise + * } + * + * // Simulate resource acquisition + * const getMyResource = (): Promise => + * Promise.resolve({ + * contents: "lorem ipsum", + * close: () => + * new Promise((resolve) => { + * console.log("Resource released") + * resolve() + * }) + * }) + * + * // Define how the resource is acquired + * const acquire = Effect.tryPromise({ + * try: () => + * getMyResource().then((res) => { + * console.log("Resource acquired") + * return res + * }), + * catch: () => new Error("getMyResourceError") + * }) + * + * // Define how the resource is released + * const release = (res: MyResource) => Effect.promise(() => res.close()) + * + * const use = (res: MyResource) => Console.log(`content is ${res.contents}`) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.acquireUseRelease(acquire, use, release) + * + * Effect.runPromise(program) + * // Output: + * // Resource acquired + * // content is lorem ipsum + * // Resource released + * ``` + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const acquireUseRelease: { + /** + * Many real-world operations involve working with resources that must be released when no longer needed, such as: + * + * - Database connections + * - File handles + * - Network requests + * + * This function ensures that a resource is: + * + * 1. **Acquired** properly. + * 2. **Used** for its intended purpose. + * 3. **Released** even if an error occurs. + * + * **Example** (Automatically Managing Resource Lifetime) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Define an interface for a resource + * interface MyResource { + * readonly contents: string + * readonly close: () => Promise + * } + * + * // Simulate resource acquisition + * const getMyResource = (): Promise => + * Promise.resolve({ + * contents: "lorem ipsum", + * close: () => + * new Promise((resolve) => { + * console.log("Resource released") + * resolve() + * }) + * }) + * + * // Define how the resource is acquired + * const acquire = Effect.tryPromise({ + * try: () => + * getMyResource().then((res) => { + * console.log("Resource acquired") + * return res + * }), + * catch: () => new Error("getMyResourceError") + * }) + * + * // Define how the resource is released + * const release = (res: MyResource) => Effect.promise(() => res.close()) + * + * const use = (res: MyResource) => Console.log(`content is ${res.contents}`) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.acquireUseRelease(acquire, use, release) + * + * Effect.runPromise(program) + * // Output: + * // Resource acquired + * // content is lorem ipsum + * // Resource released + * ``` + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (use: (a: A) => Effect, release: (a: A, exit: Exit.Exit) => Effect): (acquire: Effect) => Effect; + /** + * Many real-world operations involve working with resources that must be released when no longer needed, such as: + * + * - Database connections + * - File handles + * - Network requests + * + * This function ensures that a resource is: + * + * 1. **Acquired** properly. + * 2. **Used** for its intended purpose. + * 3. **Released** even if an error occurs. + * + * **Example** (Automatically Managing Resource Lifetime) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Define an interface for a resource + * interface MyResource { + * readonly contents: string + * readonly close: () => Promise + * } + * + * // Simulate resource acquisition + * const getMyResource = (): Promise => + * Promise.resolve({ + * contents: "lorem ipsum", + * close: () => + * new Promise((resolve) => { + * console.log("Resource released") + * resolve() + * }) + * }) + * + * // Define how the resource is acquired + * const acquire = Effect.tryPromise({ + * try: () => + * getMyResource().then((res) => { + * console.log("Resource acquired") + * return res + * }), + * catch: () => new Error("getMyResourceError") + * }) + * + * // Define how the resource is released + * const release = (res: MyResource) => Effect.promise(() => res.close()) + * + * const use = (res: MyResource) => Console.log(`content is ${res.contents}`) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.acquireUseRelease(acquire, use, release) + * + * Effect.runPromise(program) + * // Output: + * // Resource acquired + * // content is lorem ipsum + * // Resource released + * ``` + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (acquire: Effect, use: (a: A) => Effect, release: (a: A, exit: Exit.Exit) => Effect): Effect; +}; +/** + * Ensures a finalizer is added to the scope of the calling effect, guaranteeing + * it runs when the scope is closed. + * + * **Details** + * + * This function adds a finalizer that will execute whenever the scope of the + * effect is closed, regardless of whether the effect succeeds, fails, or is + * interrupted. The finalizer receives the `Exit` value of the effect's scope, + * allowing it to react differently depending on how the effect concludes. + * + * Finalizers are a reliable way to manage resource cleanup, ensuring that + * resources such as file handles, network connections, or database transactions + * are properly closed even in the event of an unexpected interruption or error. + * + * Finalizers operate in conjunction with Effect's scoped resources. If an + * effect with a finalizer is wrapped in a scope, the finalizer will execute + * automatically when the scope ends. + * + * **Example** (Adding a Finalizer on Success) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * yield* Effect.addFinalizer((exit) => + * Console.log(`Finalizer executed. Exit status: ${exit._tag}`) + * ) + * return "some result" + * }) + * + * // Wrapping the effect in a scope + * // + * // ┌─── Effect + * // ▼ + * const runnable = Effect.scoped(program) + * + * Effect.runPromiseExit(runnable).then(console.log) + * // Output: + * // Finalizer executed. Exit status: Success + * // { _id: 'Exit', _tag: 'Success', value: 'some result' } + * ``` + * + * **Example** (Adding a Finalizer on Failure) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * yield* Effect.addFinalizer((exit) => + * Console.log(`Finalizer executed. Exit status: ${exit._tag}`) + * ) + * return yield* Effect.fail("Uh oh!") + * }) + * + * // Wrapping the effect in a scope + * // + * // ┌─── Effect + * // ▼ + * const runnable = Effect.scoped(program) + * + * Effect.runPromiseExit(runnable).then(console.log) + * // Output: + * // Finalizer executed. Exit status: Failure + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'Uh oh!' } + * // } + * ``` + * + * **Example** (Adding a Finalizer on Interruption) + * + * ```ts + * import { Effect, Console } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * yield* Effect.addFinalizer((exit) => + * Console.log(`Finalizer executed. Exit status: ${exit._tag}`) + * ) + * return yield* Effect.interrupt + * }) + * + * // Wrapping the effect in a scope + * // + * // ┌─── Effect + * // ▼ + * const runnable = Effect.scoped(program) + * + * Effect.runPromiseExit(runnable).then(console.log) + * // Output: + * // Finalizer executed. Exit status: Failure + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Interrupt', + * // fiberId: { + * // _id: 'FiberId', + * // _tag: 'Runtime', + * // id: 0, + * // startTimeMillis: ... + * // } + * // } + * // } + * ``` + * + * @see {@link onExit} for attaching a finalizer directly to an effect. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const addFinalizer: (finalizer: (exit: Exit.Exit) => Effect) => Effect; +/** + * Guarantees the execution of a finalizer when an effect starts execution. + * + * **Details** + * + * This function allows you to specify a `finalizer` effect that will always be + * run once the effect starts execution, regardless of whether the effect + * succeeds, fails, or is interrupted. + * + * **When to Use** + * + * This is useful when you need to ensure that certain cleanup or final steps + * are executed in all cases, such as releasing resources or performing + * necessary logging. + * + * While this function provides strong guarantees about executing the finalizer, + * it is considered a low-level tool, which may not be ideal for more complex + * resource management. For higher-level resource management with automatic + * acquisition and release, see the {@link acquireRelease} family of functions. + * For use cases where you need access to the result of an effect, consider + * using {@link onExit}. + * + * **Example** (Running a Finalizer in All Outcomes) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // Define a cleanup effect + * const handler = Effect.ensuring(Console.log("Cleanup completed")) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * // Cleanup completed + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed + * ``` + * + * @see {@link onExit} for a version that provides access to the result of an + * effect. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const ensuring: { + /** + * Guarantees the execution of a finalizer when an effect starts execution. + * + * **Details** + * + * This function allows you to specify a `finalizer` effect that will always be + * run once the effect starts execution, regardless of whether the effect + * succeeds, fails, or is interrupted. + * + * **When to Use** + * + * This is useful when you need to ensure that certain cleanup or final steps + * are executed in all cases, such as releasing resources or performing + * necessary logging. + * + * While this function provides strong guarantees about executing the finalizer, + * it is considered a low-level tool, which may not be ideal for more complex + * resource management. For higher-level resource management with automatic + * acquisition and release, see the {@link acquireRelease} family of functions. + * For use cases where you need access to the result of an effect, consider + * using {@link onExit}. + * + * **Example** (Running a Finalizer in All Outcomes) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // Define a cleanup effect + * const handler = Effect.ensuring(Console.log("Cleanup completed")) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * // Cleanup completed + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed + * ``` + * + * @see {@link onExit} for a version that provides access to the result of an + * effect. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (finalizer: Effect): (self: Effect) => Effect; + /** + * Guarantees the execution of a finalizer when an effect starts execution. + * + * **Details** + * + * This function allows you to specify a `finalizer` effect that will always be + * run once the effect starts execution, regardless of whether the effect + * succeeds, fails, or is interrupted. + * + * **When to Use** + * + * This is useful when you need to ensure that certain cleanup or final steps + * are executed in all cases, such as releasing resources or performing + * necessary logging. + * + * While this function provides strong guarantees about executing the finalizer, + * it is considered a low-level tool, which may not be ideal for more complex + * resource management. For higher-level resource management with automatic + * acquisition and release, see the {@link acquireRelease} family of functions. + * For use cases where you need access to the result of an effect, consider + * using {@link onExit}. + * + * **Example** (Running a Finalizer in All Outcomes) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // Define a cleanup effect + * const handler = Effect.ensuring(Console.log("Cleanup completed")) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * // Cleanup completed + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed + * ``` + * + * @see {@link onExit} for a version that provides access to the result of an + * effect. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (self: Effect, finalizer: Effect): Effect; +}; +/** + * Ensures a cleanup effect runs whenever the calling effect fails, providing + * the failure cause to the cleanup effect. + * + * **Details** + * + * This function allows you to attach a cleanup effect that runs whenever the + * calling effect fails. The cleanup effect receives the cause of the failure, + * allowing you to perform actions such as logging, releasing resources, or + * executing additional recovery logic based on the error. The cleanup effect + * will execute even if the failure is due to interruption. + * + * Importantly, the cleanup effect itself is uninterruptible, ensuring that it + * completes regardless of external interruptions. + * + * **Example** (Running Cleanup Only on Failure) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // This handler logs the failure cause when the effect fails + * const handler = Effect.onError((cause) => + * Console.log(`Cleanup completed: ${cause}`) + * ) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed: Error: some error + * + * // Define a failing effect + * const defect = Console.log("Task failed with defect").pipe( + * Effect.andThen(Effect.die("Boom!")), + * handler + * ) + * + * Effect.runFork(defect) + * // Output: + * // Task failed with defect + * // Cleanup completed: Error: Boom! + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed: All fibers interrupted without errors. + * ``` + * + * @see {@link ensuring} for attaching a cleanup effect that runs on both success and failure. + * @see {@link onExit} for attaching a cleanup effect that runs on all possible exits. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const onError: { + /** + * Ensures a cleanup effect runs whenever the calling effect fails, providing + * the failure cause to the cleanup effect. + * + * **Details** + * + * This function allows you to attach a cleanup effect that runs whenever the + * calling effect fails. The cleanup effect receives the cause of the failure, + * allowing you to perform actions such as logging, releasing resources, or + * executing additional recovery logic based on the error. The cleanup effect + * will execute even if the failure is due to interruption. + * + * Importantly, the cleanup effect itself is uninterruptible, ensuring that it + * completes regardless of external interruptions. + * + * **Example** (Running Cleanup Only on Failure) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // This handler logs the failure cause when the effect fails + * const handler = Effect.onError((cause) => + * Console.log(`Cleanup completed: ${cause}`) + * ) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed: Error: some error + * + * // Define a failing effect + * const defect = Console.log("Task failed with defect").pipe( + * Effect.andThen(Effect.die("Boom!")), + * handler + * ) + * + * Effect.runFork(defect) + * // Output: + * // Task failed with defect + * // Cleanup completed: Error: Boom! + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed: All fibers interrupted without errors. + * ``` + * + * @see {@link ensuring} for attaching a cleanup effect that runs on both success and failure. + * @see {@link onExit} for attaching a cleanup effect that runs on all possible exits. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (cleanup: (cause: Cause.Cause) => Effect): (self: Effect) => Effect; + /** + * Ensures a cleanup effect runs whenever the calling effect fails, providing + * the failure cause to the cleanup effect. + * + * **Details** + * + * This function allows you to attach a cleanup effect that runs whenever the + * calling effect fails. The cleanup effect receives the cause of the failure, + * allowing you to perform actions such as logging, releasing resources, or + * executing additional recovery logic based on the error. The cleanup effect + * will execute even if the failure is due to interruption. + * + * Importantly, the cleanup effect itself is uninterruptible, ensuring that it + * completes regardless of external interruptions. + * + * **Example** (Running Cleanup Only on Failure) + * + * ```ts + * import { Console, Effect } from "effect" + * + * // This handler logs the failure cause when the effect fails + * const handler = Effect.onError((cause) => + * Console.log(`Cleanup completed: ${cause}`) + * ) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed: Error: some error + * + * // Define a failing effect + * const defect = Console.log("Task failed with defect").pipe( + * Effect.andThen(Effect.die("Boom!")), + * handler + * ) + * + * Effect.runFork(defect) + * // Output: + * // Task failed with defect + * // Cleanup completed: Error: Boom! + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed: All fibers interrupted without errors. + * ``` + * + * @see {@link ensuring} for attaching a cleanup effect that runs on both success and failure. + * @see {@link onExit} for attaching a cleanup effect that runs on all possible exits. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (self: Effect, cleanup: (cause: Cause.Cause) => Effect): Effect; +}; +/** + * Guarantees that a cleanup function runs regardless of whether the effect + * succeeds, fails, or is interrupted. + * + * **Details** + * + * This function ensures that a provided cleanup function is executed after the + * effect completes, regardless of the outcome. The cleanup function is given + * the `Exit` value of the effect, which provides detailed information about the + * result: + * - If the effect succeeds, the `Exit` contains the success value. + * - If the effect fails, the `Exit` contains the error or failure cause. + * - If the effect is interrupted, the `Exit` reflects the interruption. + * + * The cleanup function is guaranteed to run uninterruptibly, ensuring reliable + * resource management even in complex or high-concurrency scenarios. + * + * **Example** (Running a Cleanup Function with the Effect’s Result) + * + * ```ts + * import { Console, Effect, Exit } from "effect" + * + * // Define a cleanup effect that logs the result + * const handler = Effect.onExit((exit) => + * Console.log(`Cleanup completed: ${Exit.getOrElse(exit, String)}`) + * ) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * // Cleanup completed: some result + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed: Error: some error + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed: All fibers interrupted without errors. + * ``` + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const onExit: { + /** + * Guarantees that a cleanup function runs regardless of whether the effect + * succeeds, fails, or is interrupted. + * + * **Details** + * + * This function ensures that a provided cleanup function is executed after the + * effect completes, regardless of the outcome. The cleanup function is given + * the `Exit` value of the effect, which provides detailed information about the + * result: + * - If the effect succeeds, the `Exit` contains the success value. + * - If the effect fails, the `Exit` contains the error or failure cause. + * - If the effect is interrupted, the `Exit` reflects the interruption. + * + * The cleanup function is guaranteed to run uninterruptibly, ensuring reliable + * resource management even in complex or high-concurrency scenarios. + * + * **Example** (Running a Cleanup Function with the Effect’s Result) + * + * ```ts + * import { Console, Effect, Exit } from "effect" + * + * // Define a cleanup effect that logs the result + * const handler = Effect.onExit((exit) => + * Console.log(`Cleanup completed: ${Exit.getOrElse(exit, String)}`) + * ) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * // Cleanup completed: some result + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed: Error: some error + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed: All fibers interrupted without errors. + * ``` + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (cleanup: (exit: Exit.Exit) => Effect): (self: Effect) => Effect; + /** + * Guarantees that a cleanup function runs regardless of whether the effect + * succeeds, fails, or is interrupted. + * + * **Details** + * + * This function ensures that a provided cleanup function is executed after the + * effect completes, regardless of the outcome. The cleanup function is given + * the `Exit` value of the effect, which provides detailed information about the + * result: + * - If the effect succeeds, the `Exit` contains the success value. + * - If the effect fails, the `Exit` contains the error or failure cause. + * - If the effect is interrupted, the `Exit` reflects the interruption. + * + * The cleanup function is guaranteed to run uninterruptibly, ensuring reliable + * resource management even in complex or high-concurrency scenarios. + * + * **Example** (Running a Cleanup Function with the Effect’s Result) + * + * ```ts + * import { Console, Effect, Exit } from "effect" + * + * // Define a cleanup effect that logs the result + * const handler = Effect.onExit((exit) => + * Console.log(`Cleanup completed: ${Exit.getOrElse(exit, String)}`) + * ) + * + * // Define a successful effect + * const success = Console.log("Task completed").pipe( + * Effect.as("some result"), + * handler + * ) + * + * Effect.runFork(success) + * // Output: + * // Task completed + * // Cleanup completed: some result + * + * // Define a failing effect + * const failure = Console.log("Task failed").pipe( + * Effect.andThen(Effect.fail("some error")), + * handler + * ) + * + * Effect.runFork(failure) + * // Output: + * // Task failed + * // Cleanup completed: Error: some error + * + * // Define an interrupted effect + * const interruption = Console.log("Task interrupted").pipe( + * Effect.andThen(Effect.interrupt), + * handler + * ) + * + * Effect.runFork(interruption) + * // Output: + * // Task interrupted + * // Cleanup completed: All fibers interrupted without errors. + * ``` + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (self: Effect, cleanup: (exit: Exit.Exit) => Effect): Effect; +}; +/** + * Ensures that finalizers are run concurrently when the scope of an effect is + * closed. + * + * **Details** + * + * This function modifies the behavior of finalizers within a scoped workflow to + * allow them to run concurrently when the scope is closed. + * + * By default, finalizers are executed sequentially in reverse order of their + * addition, but this function changes that behavior to execute all finalizers + * concurrently. + * + * **When to Use** + * + * Running finalizers concurrently can improve performance when multiple + * independent cleanup tasks need to be performed. However, it requires that + * these tasks do not depend on the order of execution or introduce race + * conditions. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * // Define a program that adds multiple finalizers + * const program = Effect.gen(function*() { + * yield* Effect.addFinalizer(() => Console.log("Finalizer 1 executed").pipe(Effect.delay("300 millis"))) + * yield* Effect.addFinalizer(() => Console.log("Finalizer 2 executed").pipe(Effect.delay("100 millis"))) + * yield* Effect.addFinalizer(() => Console.log("Finalizer 3 executed").pipe(Effect.delay("200 millis"))) + * return "some result" + * }) + * + * // Modify the program to ensure finalizers run in parallel + * const modified = program.pipe(Effect.parallelFinalizers) + * + * const runnable = Effect.scoped(modified) + * + * Effect.runFork(runnable) + * // Output: + * // Finalizer 2 executed + * // Finalizer 3 executed + * // Finalizer 1 executed + * ``` + * + * @see {@link sequentialFinalizers} for a version that ensures finalizers are run sequentially. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const parallelFinalizers: (self: Effect) => Effect; +/** + * Ensures that finalizers are run sequentially in reverse order of their + * addition. + * + * **Details** + * + * This function modifies the behavior of finalizers within a scoped workflow to + * ensure they are run sequentially in reverse order when the scope is closed. + * + * By default, finalizers are executed sequentially, so this only changes the + * behavior if the scope is configured to run finalizers concurrently. + * + * @see {@link parallelFinalizers} for a version that ensures finalizers are run concurrently. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const sequentialFinalizers: (self: Effect) => Effect; +/** + * Applies a custom execution strategy to finalizers within a scoped workflow. + * + * **Details** + * + * This function allows you to control how finalizers are executed in a scope by + * applying a specified `ExecutionStrategy`. The `strategy` can dictate whether + * finalizers run (e.g., sequentially or in parallel). + * + * Additionally, the function provides a `restore` operation, which ensures that + * the effect passed to it is executed under the default execution strategy. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const finalizersMask: (strategy: ExecutionStrategy) => (self: (restore: (self: Effect) => Effect) => Effect) => Effect; +/** + * Provides access to the current scope in a scoped workflow. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const scope: Effect; +/** + * Accesses the current scope and uses it to perform the specified effect. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const scopeWith: (f: (scope: Scope.Scope) => Effect) => Effect; +/** + * Creates a `Scope`, passes it to the specified effectful function, and closes + * the scope when the effect completes (whether through success, failure, or + * interruption). + * + * @since 3.11.0 + * @category Scoping, Resources & Finalization + */ +export declare const scopedWith: (f: (scope: Scope.Scope) => Effect) => Effect; +/** + * Scopes all resources used in an effect to the lifetime of the effect. + * + * **Details** + * + * This function ensures that all resources used within an effect are tied to + * its lifetime. Finalizers for these resources are executed automatically when + * the effect completes, whether through success, failure, or interruption. This + * guarantees proper resource cleanup without requiring explicit management. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const scoped: (effect: Effect) => Effect>; +/** + * Scopes all resources acquired by one effect to the lifetime of another + * effect. + * + * **Details** + * + * This function allows you to scope the resources acquired by one effect + * (`self`) to the lifetime of another effect (`use`). This ensures that the + * resources are cleaned up as soon as the `use` effect completes, regardless of + * how the `use` effect ends (success, failure, or interruption). + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const acquire = Console.log("Acquiring resource").pipe( + * Effect.as(1), + * Effect.tap(Effect.addFinalizer(() => Console.log("Releasing resource"))) + * ) + * const use = (resource: number) => Console.log(`Using resource: ${resource}`) + * + * const program = acquire.pipe(Effect.using(use)) + * + * Effect.runFork(program) + * // Output: + * // Acquiring resource + * // Using resource: 1 + * // Releasing resource + * ``` + * + * @see {@link scopedWith} Manage scoped operations with a temporary scope. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const using: { + /** + * Scopes all resources acquired by one effect to the lifetime of another + * effect. + * + * **Details** + * + * This function allows you to scope the resources acquired by one effect + * (`self`) to the lifetime of another effect (`use`). This ensures that the + * resources are cleaned up as soon as the `use` effect completes, regardless of + * how the `use` effect ends (success, failure, or interruption). + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const acquire = Console.log("Acquiring resource").pipe( + * Effect.as(1), + * Effect.tap(Effect.addFinalizer(() => Console.log("Releasing resource"))) + * ) + * const use = (resource: number) => Console.log(`Using resource: ${resource}`) + * + * const program = acquire.pipe(Effect.using(use)) + * + * Effect.runFork(program) + * // Output: + * // Acquiring resource + * // Using resource: 1 + * // Releasing resource + * ``` + * + * @see {@link scopedWith} Manage scoped operations with a temporary scope. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (use: (a: A) => Effect): (self: Effect) => Effect>; + /** + * Scopes all resources acquired by one effect to the lifetime of another + * effect. + * + * **Details** + * + * This function allows you to scope the resources acquired by one effect + * (`self`) to the lifetime of another effect (`use`). This ensures that the + * resources are cleaned up as soon as the `use` effect completes, regardless of + * how the `use` effect ends (success, failure, or interruption). + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const acquire = Console.log("Acquiring resource").pipe( + * Effect.as(1), + * Effect.tap(Effect.addFinalizer(() => Console.log("Releasing resource"))) + * ) + * const use = (resource: number) => Console.log(`Using resource: ${resource}`) + * + * const program = acquire.pipe(Effect.using(use)) + * + * Effect.runFork(program) + * // Output: + * // Acquiring resource + * // Using resource: 1 + * // Releasing resource + * ``` + * + * @see {@link scopedWith} Manage scoped operations with a temporary scope. + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ + (self: Effect, use: (a: A) => Effect): Effect>; +}; +/** + * Returns the result of the effect and a finalizer to close its scope. + * + * **Details** + * + * This function allows you to retrieve both the result of an effect and a + * finalizer that can be used to manually close its scope. This is useful for + * workflows where you need early access to the result while retaining control + * over the resource cleanup process. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const acquire = Console.log("Acquiring resource").pipe( + * Effect.as(1), + * Effect.tap(Effect.addFinalizer(() => Console.log("Releasing resource"))) + * ) + * const program = Effect.gen(function*() { + * const [finalizer, resource] = yield* Effect.withEarlyRelease(acquire) + * console.log(`Using resource: ${resource}`) + * yield* Effect.sleep("1 second") + * yield* finalizer + * }) + * + * Effect.runFork(program.pipe(Effect.scoped)) + * // Output: + * // Acquiring resource + * // Using resource: 1 + * // Releasing resource + * ``` + * + * @since 2.0.0 + * @category Scoping, Resources & Finalization + */ +export declare const withEarlyRelease: (self: Effect) => Effect<[finalizer: Effect, result: A], E, R | Scope.Scope>; +/** + * Returns a new effect that will not succeed with its value before first + * waiting for the end of all child fibers forked by the effect. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const awaitAllChildren: (self: Effect) => Effect; +/** + * Returns a new workflow that will not supervise any fibers forked by this + * workflow. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const daemonChildren: (self: Effect) => Effect; +/** + * Constructs an effect with information about the current `Fiber`. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const descriptor: Effect; +/** + * Constructs an effect based on information about the current `Fiber`. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const descriptorWith: (f: (descriptor: Fiber.Fiber.Descriptor) => Effect) => Effect; +/** + * Returns a new workflow that executes this one and captures the changes in + * `FiberRef` values. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const diffFiberRefs: (self: Effect) => Effect<[FiberRefsPatch.FiberRefsPatch, A], E, R>; +/** + * Acts on the children of this fiber (collected into a single fiber), + * guaranteeing the specified callback will be invoked, whether or not this + * effect succeeds. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const ensuringChild: { + /** + * Acts on the children of this fiber (collected into a single fiber), + * guaranteeing the specified callback will be invoked, whether or not this + * effect succeeds. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (f: (fiber: Fiber.Fiber, any>) => Effect): (self: Effect) => Effect; + /** + * Acts on the children of this fiber (collected into a single fiber), + * guaranteeing the specified callback will be invoked, whether or not this + * effect succeeds. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (self: Effect, f: (fiber: Fiber.Fiber, any>) => Effect): Effect; +}; +/** + * Acts on the children of this fiber, guaranteeing the specified callback + * will be invoked, whether or not this effect succeeds. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const ensuringChildren: { + /** + * Acts on the children of this fiber, guaranteeing the specified callback + * will be invoked, whether or not this effect succeeds. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (children: (fibers: ReadonlyArray>) => Effect): (self: Effect) => Effect; + /** + * Acts on the children of this fiber, guaranteeing the specified callback + * will be invoked, whether or not this effect succeeds. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (self: Effect, children: (fibers: ReadonlyArray>) => Effect): Effect; +}; +/** + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const fiberId: Effect; +/** + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const fiberIdWith: (f: (descriptor: FiberId.Runtime) => Effect) => Effect; +/** + * Creates a new fiber to run an effect concurrently. + * + * **Details** + * + * This function takes an effect and forks it into a separate fiber, allowing it + * to run concurrently without blocking the original effect. The new fiber + * starts execution immediately after being created, and the fiber object is + * returned immediately without waiting for the effect to begin. This is useful + * when you want to run tasks concurrently while continuing other tasks in the + * parent fiber. + * + * The forked fiber is attached to the parent fiber's scope. This means that + * when the parent fiber terminates, the child fiber will also be terminated + * automatically. This feature, known as "auto supervision," ensures that no + * fibers are left running unintentionally. If you prefer not to have this auto + * supervision behavior, you can use {@link forkDaemon} or {@link forkIn}. + * + * **When to Use** + * + * Use this function when you need to run an effect concurrently without + * blocking the current execution flow. For example, you might use it to launch + * background tasks or concurrent computations. However, working with fibers can + * be complex, so before using this function directly, you might want to explore + * higher-level functions like {@link raceWith}, {@link zip}, or others that can + * manage concurrency for you. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const fib = (n: number): Effect.Effect => + * n < 2 + * ? Effect.succeed(n) + * : Effect.zipWith(fib(n - 1), fib(n - 2), (a, b) => a + b) + * + * // ┌─── Effect, never, never> + * // ▼ + * const fib10Fiber = Effect.fork(fib(10)) + * ``` + * + * @see {@link forkWithErrorHandler} for a version that allows you to handle errors. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const fork: (self: Effect) => Effect, never, R>; +/** + * Creates a long-running background fiber that is independent of its parent. + * + * **Details** + * + * This function creates a "daemon" fiber that runs in the background and is not + * tied to the lifecycle of its parent fiber. Unlike normal fibers that stop + * when the parent fiber terminates, a daemon fiber will continue running until + * the global scope closes or the fiber completes naturally. This makes it + * useful for tasks that need to run in the background independently, such as + * periodic logging, monitoring, or background data processing. + * + * **Example** (Creating a Daemon Fiber) + * + * ```ts + * import { Effect, Console, Schedule } from "effect" + * + * // Daemon fiber that logs a message repeatedly every second + * const daemon = Effect.repeat( + * Console.log("daemon: still running!"), + * Schedule.fixed("1 second") + * ) + * + * const parent = Effect.gen(function* () { + * console.log("parent: started!") + * // Daemon fiber running independently + * yield* Effect.forkDaemon(daemon) + * yield* Effect.sleep("3 seconds") + * console.log("parent: finished!") + * }) + * + * Effect.runFork(parent) + * // Output: + * // parent: started! + * // daemon: still running! + * // daemon: still running! + * // daemon: still running! + * // parent: finished! + * // daemon: still running! + * // daemon: still running! + * // daemon: still running! + * // daemon: still running! + * // daemon: still running! + * // ...etc... + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const forkDaemon: (self: Effect) => Effect, never, R>; +/** + * Returns an effect that forks all of the specified values, and returns a + * composite fiber that produces a list of their results, in order. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const forkAll: { + /** + * Returns an effect that forks all of the specified values, and returns a + * composite fiber that produces a list of their results, in order. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (options?: { + readonly discard?: false | undefined; + } | undefined): >(effects: Iterable) => Effect>, Effect.Error>, never, Effect.Context>; + /** + * Returns an effect that forks all of the specified values, and returns a + * composite fiber that produces a list of their results, in order. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (options: { + readonly discard: true; + }): >(effects: Iterable) => Effect>; + /** + * Returns an effect that forks all of the specified values, and returns a + * composite fiber that produces a list of their results, in order. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + >(effects: Iterable, options?: { + readonly discard?: false | undefined; + } | undefined): Effect>, Effect.Error>, never, Effect.Context>; + /** + * Returns an effect that forks all of the specified values, and returns a + * composite fiber that produces a list of their results, in order. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + >(effects: Iterable, options: { + readonly discard: true; + }): Effect>; +}; +/** + * Forks an effect in a specific scope, allowing finer control over its + * execution. + * + * **Details** + * + * There are some cases where we need more fine-grained control, so we want to + * fork a fiber in a specific scope. We can use the `Effect.forkIn` operator + * which takes the target scope as an argument. + * + * The fiber will be interrupted when the scope is closed. + * + * **Example** (Forking a Fiber in a Specific Scope) + * + * In this example, the child fiber is forked into the outerScope, + * allowing it to outlive the inner scope but still be terminated + * when the outerScope is closed. + * + * ```ts + * import { Console, Effect, Schedule } from "effect" + * + * // Child fiber that logs a message repeatedly every second + * const child = Effect.repeat( + * Console.log("child: still running!"), + * Schedule.fixed("1 second") + * ) + * + * const program = Effect.scoped( + * Effect.gen(function* () { + * yield* Effect.addFinalizer(() => + * Console.log("The outer scope is about to be closed!") + * ) + * + * // Capture the outer scope + * const outerScope = yield* Effect.scope + * + * // Create an inner scope + * yield* Effect.scoped( + * Effect.gen(function* () { + * yield* Effect.addFinalizer(() => + * Console.log("The inner scope is about to be closed!") + * ) + * // Fork the child fiber in the outer scope + * yield* Effect.forkIn(child, outerScope) + * yield* Effect.sleep("3 seconds") + * }) + * ) + * + * yield* Effect.sleep("5 seconds") + * }) + * ) + * + * Effect.runFork(program) + * // Output: + * // child: still running! + * // child: still running! + * // child: still running! + * // The inner scope is about to be closed! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // The outer scope is about to be closed! + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const forkIn: { + /** + * Forks an effect in a specific scope, allowing finer control over its + * execution. + * + * **Details** + * + * There are some cases where we need more fine-grained control, so we want to + * fork a fiber in a specific scope. We can use the `Effect.forkIn` operator + * which takes the target scope as an argument. + * + * The fiber will be interrupted when the scope is closed. + * + * **Example** (Forking a Fiber in a Specific Scope) + * + * In this example, the child fiber is forked into the outerScope, + * allowing it to outlive the inner scope but still be terminated + * when the outerScope is closed. + * + * ```ts + * import { Console, Effect, Schedule } from "effect" + * + * // Child fiber that logs a message repeatedly every second + * const child = Effect.repeat( + * Console.log("child: still running!"), + * Schedule.fixed("1 second") + * ) + * + * const program = Effect.scoped( + * Effect.gen(function* () { + * yield* Effect.addFinalizer(() => + * Console.log("The outer scope is about to be closed!") + * ) + * + * // Capture the outer scope + * const outerScope = yield* Effect.scope + * + * // Create an inner scope + * yield* Effect.scoped( + * Effect.gen(function* () { + * yield* Effect.addFinalizer(() => + * Console.log("The inner scope is about to be closed!") + * ) + * // Fork the child fiber in the outer scope + * yield* Effect.forkIn(child, outerScope) + * yield* Effect.sleep("3 seconds") + * }) + * ) + * + * yield* Effect.sleep("5 seconds") + * }) + * ) + * + * Effect.runFork(program) + * // Output: + * // child: still running! + * // child: still running! + * // child: still running! + * // The inner scope is about to be closed! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // The outer scope is about to be closed! + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (scope: Scope.Scope): (self: Effect) => Effect, never, R>; + /** + * Forks an effect in a specific scope, allowing finer control over its + * execution. + * + * **Details** + * + * There are some cases where we need more fine-grained control, so we want to + * fork a fiber in a specific scope. We can use the `Effect.forkIn` operator + * which takes the target scope as an argument. + * + * The fiber will be interrupted when the scope is closed. + * + * **Example** (Forking a Fiber in a Specific Scope) + * + * In this example, the child fiber is forked into the outerScope, + * allowing it to outlive the inner scope but still be terminated + * when the outerScope is closed. + * + * ```ts + * import { Console, Effect, Schedule } from "effect" + * + * // Child fiber that logs a message repeatedly every second + * const child = Effect.repeat( + * Console.log("child: still running!"), + * Schedule.fixed("1 second") + * ) + * + * const program = Effect.scoped( + * Effect.gen(function* () { + * yield* Effect.addFinalizer(() => + * Console.log("The outer scope is about to be closed!") + * ) + * + * // Capture the outer scope + * const outerScope = yield* Effect.scope + * + * // Create an inner scope + * yield* Effect.scoped( + * Effect.gen(function* () { + * yield* Effect.addFinalizer(() => + * Console.log("The inner scope is about to be closed!") + * ) + * // Fork the child fiber in the outer scope + * yield* Effect.forkIn(child, outerScope) + * yield* Effect.sleep("3 seconds") + * }) + * ) + * + * yield* Effect.sleep("5 seconds") + * }) + * ) + * + * Effect.runFork(program) + * // Output: + * // child: still running! + * // child: still running! + * // child: still running! + * // The inner scope is about to be closed! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // child: still running! + * // The outer scope is about to be closed! + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (self: Effect, scope: Scope.Scope): Effect, never, R>; +}; +/** + * Forks a fiber in a local scope, ensuring it outlives its parent. + * + * **Details** + * + * This function is used to create fibers that are tied to a local scope, + * meaning they are not dependent on their parent fiber's lifecycle. Instead, + * they will continue running until the scope they were created in is closed. + * This is particularly useful when you need a fiber to run independently of the + * parent fiber, but still want it to be terminated when the scope ends. + * + * Fibers created with this function are isolated from the parent fiber’s + * termination, so they can run for a longer period. This behavior is different + * from fibers created with {@link fork}, which are terminated when the parent fiber + * terminates. With `forkScoped`, the child fiber will keep running until the + * local scope ends, regardless of the state of the parent fiber. + * + * **Example** (Forking a Fiber in a Local Scope) + * + * In this example, the child fiber continues to run beyond the lifetime of the parent fiber. + * The child fiber is tied to the local scope and will be terminated only when the scope ends. + * + * ```ts + * import { Effect, Console, Schedule } from "effect" + * + * // Child fiber that logs a message repeatedly every second + * const child = Effect.repeat( + * Console.log("child: still running!"), + * Schedule.fixed("1 second") + * ) + * + * // ┌─── Effect + * // ▼ + * const parent = Effect.gen(function* () { + * console.log("parent: started!") + * // Child fiber attached to local scope + * yield* Effect.forkScoped(child) + * yield* Effect.sleep("3 seconds") + * console.log("parent: finished!") + * }) + * + * // Program runs within a local scope + * const program = Effect.scoped( + * Effect.gen(function* () { + * console.log("Local scope started!") + * yield* Effect.fork(parent) + * // Scope lasts for 5 seconds + * yield* Effect.sleep("5 seconds") + * console.log("Leaving the local scope!") + * }) + * ) + * + * Effect.runFork(program) + * // Output: + * // Local scope started! + * // parent: started! + * // child: still running! + * // child: still running! + * // child: still running! + * // parent: finished! + * // child: still running! + * // child: still running! + * // Leaving the local scope! + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const forkScoped: (self: Effect) => Effect, never, Scope.Scope | R>; +/** + * Like {@link fork} but handles an error with the provided handler. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const forkWithErrorHandler: { + /** + * Like {@link fork} but handles an error with the provided handler. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (handler: (e: E) => Effect): (self: Effect) => Effect, never, R>; + /** + * Like {@link fork} but handles an error with the provided handler. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (self: Effect, handler: (e: E) => Effect): Effect, never, R>; +}; +/** + * Creates an `Effect` value that represents the exit value of the specified + * fiber. + * + * @see {@link fromFiberEffect} for creating an effect from a fiber obtained from an effect. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const fromFiber: (fiber: Fiber.Fiber) => Effect; +/** + * Creates an `Effect` value that represents the exit value of a fiber obtained + * from an effect. + * + * @see {@link fromFiber} for creating an effect from a fiber. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const fromFiberEffect: (fiber: Effect, E, R>) => Effect; +/** + * Supervises child fibers by reporting them to a specified supervisor. + * + * **Details** + * + * This function takes a supervisor as an argument and returns an effect where + * all child fibers forked within it are supervised by the provided supervisor. + * This enables you to capture detailed information about these child fibers, + * such as their status, through the supervisor. + * + * **Example** (Monitoring Fiber Count) + * + * ```ts + * import { Effect, Supervisor, Schedule, Fiber, FiberStatus } from "effect" + * + * // Main program that monitors fibers while calculating a Fibonacci number + * const program = Effect.gen(function* () { + * // Create a supervisor to track child fibers + * const supervisor = yield* Supervisor.track + * + * // Start a Fibonacci calculation, supervised by the supervisor + * const fibFiber = yield* fib(20).pipe( + * Effect.supervised(supervisor), + * // Fork the Fibonacci effect into a fiber + * Effect.fork + * ) + * + * // Define a schedule to periodically monitor the fiber count every 500ms + * const policy = Schedule.spaced("500 millis").pipe( + * Schedule.whileInputEffect((_) => + * Fiber.status(fibFiber).pipe( + * // Continue while the Fibonacci fiber is not done + * Effect.andThen((status) => status !== FiberStatus.done) + * ) + * ) + * ) + * + * // Start monitoring the fibers, using the supervisor to track the count + * const monitorFiber = yield* monitorFibers(supervisor).pipe( + * // Repeat the monitoring according to the schedule + * Effect.repeat(policy), + * // Fork the monitoring into its own fiber + * Effect.fork + * ) + * + * // Join the monitor and Fibonacci fibers to ensure they complete + * yield* Fiber.join(monitorFiber) + * const result = yield* Fiber.join(fibFiber) + * + * console.log(`fibonacci result: ${result}`) + * }) + * + * // Function to monitor and log the number of active fibers + * const monitorFibers = ( + * supervisor: Supervisor.Supervisor>> + * ): Effect.Effect => + * Effect.gen(function* () { + * const fibers = yield* supervisor.value // Get the current set of fibers + * console.log(`number of fibers: ${fibers.length}`) + * }) + * + * // Recursive Fibonacci calculation, spawning fibers for each recursive step + * const fib = (n: number): Effect.Effect => + * Effect.gen(function* () { + * if (n <= 1) { + * return 1 + * } + * yield* Effect.sleep("500 millis") // Simulate work by delaying + * + * // Fork two fibers for the recursive Fibonacci calls + * const fiber1 = yield* Effect.fork(fib(n - 2)) + * const fiber2 = yield* Effect.fork(fib(n - 1)) + * + * // Join the fibers to retrieve their results + * const v1 = yield* Fiber.join(fiber1) + * const v2 = yield* Fiber.join(fiber2) + * + * return v1 + v2 // Combine the results + * }) + * + * Effect.runPromise(program) + * // Output: + * // number of fibers: 0 + * // number of fibers: 2 + * // number of fibers: 6 + * // number of fibers: 14 + * // number of fibers: 30 + * // number of fibers: 62 + * // number of fibers: 126 + * // number of fibers: 254 + * // number of fibers: 510 + * // number of fibers: 1022 + * // number of fibers: 2034 + * // number of fibers: 3795 + * // number of fibers: 5810 + * // number of fibers: 6474 + * // number of fibers: 4942 + * // number of fibers: 2515 + * // number of fibers: 832 + * // number of fibers: 170 + * // number of fibers: 18 + * // number of fibers: 0 + * // fibonacci result: 10946 + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const supervised: { + /** + * Supervises child fibers by reporting them to a specified supervisor. + * + * **Details** + * + * This function takes a supervisor as an argument and returns an effect where + * all child fibers forked within it are supervised by the provided supervisor. + * This enables you to capture detailed information about these child fibers, + * such as their status, through the supervisor. + * + * **Example** (Monitoring Fiber Count) + * + * ```ts + * import { Effect, Supervisor, Schedule, Fiber, FiberStatus } from "effect" + * + * // Main program that monitors fibers while calculating a Fibonacci number + * const program = Effect.gen(function* () { + * // Create a supervisor to track child fibers + * const supervisor = yield* Supervisor.track + * + * // Start a Fibonacci calculation, supervised by the supervisor + * const fibFiber = yield* fib(20).pipe( + * Effect.supervised(supervisor), + * // Fork the Fibonacci effect into a fiber + * Effect.fork + * ) + * + * // Define a schedule to periodically monitor the fiber count every 500ms + * const policy = Schedule.spaced("500 millis").pipe( + * Schedule.whileInputEffect((_) => + * Fiber.status(fibFiber).pipe( + * // Continue while the Fibonacci fiber is not done + * Effect.andThen((status) => status !== FiberStatus.done) + * ) + * ) + * ) + * + * // Start monitoring the fibers, using the supervisor to track the count + * const monitorFiber = yield* monitorFibers(supervisor).pipe( + * // Repeat the monitoring according to the schedule + * Effect.repeat(policy), + * // Fork the monitoring into its own fiber + * Effect.fork + * ) + * + * // Join the monitor and Fibonacci fibers to ensure they complete + * yield* Fiber.join(monitorFiber) + * const result = yield* Fiber.join(fibFiber) + * + * console.log(`fibonacci result: ${result}`) + * }) + * + * // Function to monitor and log the number of active fibers + * const monitorFibers = ( + * supervisor: Supervisor.Supervisor>> + * ): Effect.Effect => + * Effect.gen(function* () { + * const fibers = yield* supervisor.value // Get the current set of fibers + * console.log(`number of fibers: ${fibers.length}`) + * }) + * + * // Recursive Fibonacci calculation, spawning fibers for each recursive step + * const fib = (n: number): Effect.Effect => + * Effect.gen(function* () { + * if (n <= 1) { + * return 1 + * } + * yield* Effect.sleep("500 millis") // Simulate work by delaying + * + * // Fork two fibers for the recursive Fibonacci calls + * const fiber1 = yield* Effect.fork(fib(n - 2)) + * const fiber2 = yield* Effect.fork(fib(n - 1)) + * + * // Join the fibers to retrieve their results + * const v1 = yield* Fiber.join(fiber1) + * const v2 = yield* Fiber.join(fiber2) + * + * return v1 + v2 // Combine the results + * }) + * + * Effect.runPromise(program) + * // Output: + * // number of fibers: 0 + * // number of fibers: 2 + * // number of fibers: 6 + * // number of fibers: 14 + * // number of fibers: 30 + * // number of fibers: 62 + * // number of fibers: 126 + * // number of fibers: 254 + * // number of fibers: 510 + * // number of fibers: 1022 + * // number of fibers: 2034 + * // number of fibers: 3795 + * // number of fibers: 5810 + * // number of fibers: 6474 + * // number of fibers: 4942 + * // number of fibers: 2515 + * // number of fibers: 832 + * // number of fibers: 170 + * // number of fibers: 18 + * // number of fibers: 0 + * // fibonacci result: 10946 + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (supervisor: Supervisor.Supervisor): (self: Effect) => Effect; + /** + * Supervises child fibers by reporting them to a specified supervisor. + * + * **Details** + * + * This function takes a supervisor as an argument and returns an effect where + * all child fibers forked within it are supervised by the provided supervisor. + * This enables you to capture detailed information about these child fibers, + * such as their status, through the supervisor. + * + * **Example** (Monitoring Fiber Count) + * + * ```ts + * import { Effect, Supervisor, Schedule, Fiber, FiberStatus } from "effect" + * + * // Main program that monitors fibers while calculating a Fibonacci number + * const program = Effect.gen(function* () { + * // Create a supervisor to track child fibers + * const supervisor = yield* Supervisor.track + * + * // Start a Fibonacci calculation, supervised by the supervisor + * const fibFiber = yield* fib(20).pipe( + * Effect.supervised(supervisor), + * // Fork the Fibonacci effect into a fiber + * Effect.fork + * ) + * + * // Define a schedule to periodically monitor the fiber count every 500ms + * const policy = Schedule.spaced("500 millis").pipe( + * Schedule.whileInputEffect((_) => + * Fiber.status(fibFiber).pipe( + * // Continue while the Fibonacci fiber is not done + * Effect.andThen((status) => status !== FiberStatus.done) + * ) + * ) + * ) + * + * // Start monitoring the fibers, using the supervisor to track the count + * const monitorFiber = yield* monitorFibers(supervisor).pipe( + * // Repeat the monitoring according to the schedule + * Effect.repeat(policy), + * // Fork the monitoring into its own fiber + * Effect.fork + * ) + * + * // Join the monitor and Fibonacci fibers to ensure they complete + * yield* Fiber.join(monitorFiber) + * const result = yield* Fiber.join(fibFiber) + * + * console.log(`fibonacci result: ${result}`) + * }) + * + * // Function to monitor and log the number of active fibers + * const monitorFibers = ( + * supervisor: Supervisor.Supervisor>> + * ): Effect.Effect => + * Effect.gen(function* () { + * const fibers = yield* supervisor.value // Get the current set of fibers + * console.log(`number of fibers: ${fibers.length}`) + * }) + * + * // Recursive Fibonacci calculation, spawning fibers for each recursive step + * const fib = (n: number): Effect.Effect => + * Effect.gen(function* () { + * if (n <= 1) { + * return 1 + * } + * yield* Effect.sleep("500 millis") // Simulate work by delaying + * + * // Fork two fibers for the recursive Fibonacci calls + * const fiber1 = yield* Effect.fork(fib(n - 2)) + * const fiber2 = yield* Effect.fork(fib(n - 1)) + * + * // Join the fibers to retrieve their results + * const v1 = yield* Fiber.join(fiber1) + * const v2 = yield* Fiber.join(fiber2) + * + * return v1 + v2 // Combine the results + * }) + * + * Effect.runPromise(program) + * // Output: + * // number of fibers: 0 + * // number of fibers: 2 + * // number of fibers: 6 + * // number of fibers: 14 + * // number of fibers: 30 + * // number of fibers: 62 + * // number of fibers: 126 + * // number of fibers: 254 + * // number of fibers: 510 + * // number of fibers: 1022 + * // number of fibers: 2034 + * // number of fibers: 3795 + * // number of fibers: 5810 + * // number of fibers: 6474 + * // number of fibers: 4942 + * // number of fibers: 2515 + * // number of fibers: 832 + * // number of fibers: 170 + * // number of fibers: 18 + * // number of fibers: 0 + * // fibonacci result: 10946 + * ``` + * + * @since 2.0.0 + * @category Supervision & Fibers + */ + (self: Effect, supervisor: Supervisor.Supervisor): Effect; +}; +/** + * Transplants specified effects so that when those effects fork other + * effects, the forked effects will be governed by the scope of the fiber that + * executes this effect. + * + * This can be used to "graft" deep grandchildren onto a higher-level scope, + * effectively extending their lifespans into the parent scope. + * + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const transplant: (f: (grafter: (effect: Effect) => Effect) => Effect) => Effect; +/** + * @since 2.0.0 + * @category Supervision & Fibers + */ +export declare const withConcurrency: { + /** + * @since 2.0.0 + * @category Supervision & Fibers + */ + (concurrency: number | "unbounded"): (self: Effect) => Effect; + /** + * @since 2.0.0 + * @category Supervision & Fibers + */ + (self: Effect, concurrency: number | "unbounded"): Effect; +}; +/** + * Sets the provided scheduler for usage in the wrapped effect + * + * @since 2.0.0 + * @category Scheduler + */ +export declare const withScheduler: { + /** + * Sets the provided scheduler for usage in the wrapped effect + * + * @since 2.0.0 + * @category Scheduler + */ + (scheduler: Scheduler.Scheduler): (self: Effect) => Effect; + /** + * Sets the provided scheduler for usage in the wrapped effect + * + * @since 2.0.0 + * @category Scheduler + */ + (self: Effect, scheduler: Scheduler.Scheduler): Effect; +}; +/** + * Sets the scheduling priority used when yielding + * + * @since 2.0.0 + * @category Scheduler + */ +export declare const withSchedulingPriority: { + /** + * Sets the scheduling priority used when yielding + * + * @since 2.0.0 + * @category Scheduler + */ + (priority: number): (self: Effect) => Effect; + /** + * Sets the scheduling priority used when yielding + * + * @since 2.0.0 + * @category Scheduler + */ + (self: Effect, priority: number): Effect; +}; +/** + * Sets the maximum number of operations before yield by the default schedulers + * + * @since 2.0.0 + * @category Scheduler + */ +export declare const withMaxOpsBeforeYield: { + /** + * Sets the maximum number of operations before yield by the default schedulers + * + * @since 2.0.0 + * @category Scheduler + */ + (priority: number): (self: Effect) => Effect; + /** + * Sets the maximum number of operations before yield by the default schedulers + * + * @since 2.0.0 + * @category Scheduler + */ + (self: Effect, priority: number): Effect; +}; +/** + * Retrieves the `Clock` service from the context. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * const clock = yield* Effect.clock + * const currentTime = yield* clock.currentTimeMillis + * console.log(`Current time in milliseconds: ${currentTime}`) + * }) + * + * Effect.runFork(program) + * // Example Output: + * // Current time in milliseconds: 1735484796134 + * ``` + * + * @since 2.0.0 + * @category Clock + */ +export declare const clock: Effect; +/** + * Retrieves the `Clock` service from the context and provides it to the + * specified effectful function. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const program = Effect.clockWith((clock) => + * clock.currentTimeMillis.pipe( + * Effect.map((currentTime) => `Current time is: ${currentTime}`), + * Effect.tap(Console.log) + * ) + * ) + * + * Effect.runFork(program) + * // Example Output: + * // Current time is: 1735484929744 + * ``` + * + * @since 2.0.0 + * @category Clock + */ +export declare const clockWith: (f: (clock: Clock.Clock) => Effect) => Effect; +/** + * Sets the implementation of the `Clock` service to the specified value and + * restores it to its original value when the scope is closed. + * + * @since 2.0.0 + * @category Clock + */ +export declare const withClockScoped: (clock: C) => Effect; +/** + * Executes the specified workflow with the specified implementation of the + * `Clock` service. + * + * @since 2.0.0 + * @category Clock + */ +export declare const withClock: { + /** + * Executes the specified workflow with the specified implementation of the + * `Clock` service. + * + * @since 2.0.0 + * @category Clock + */ + (clock: C): (effect: Effect) => Effect; + /** + * Executes the specified workflow with the specified implementation of the + * `Clock` service. + * + * @since 2.0.0 + * @category Clock + */ + (effect: Effect, clock: C): Effect; +}; +/** + * Retreives the `Console` service from the context + * + * @since 2.0.0 + * @category Console + */ +export declare const console: Effect; +/** + * Retreives the `Console` service from the context and provides it to the + * specified effectful function. + * + * @since 2.0.0 + * @category Console + */ +export declare const consoleWith: (f: (console: Console) => Effect) => Effect; +/** + * Sets the implementation of the console service to the specified value and + * restores it to its original value when the scope is closed. + * + * @since 2.0.0 + * @category Creating Effects + */ +export declare const withConsoleScoped: (console: A) => Effect; +/** + * Executes the specified workflow with the specified implementation of the + * console service. + * + * @since 2.0.0 + * @category Console + */ +export declare const withConsole: { + /** + * Executes the specified workflow with the specified implementation of the + * console service. + * + * @since 2.0.0 + * @category Console + */ + (console: C): (effect: Effect) => Effect; + /** + * Executes the specified workflow with the specified implementation of the + * console service. + * + * @since 2.0.0 + * @category Console + */ + (effect: Effect, console: C): Effect; +}; +/** + * Delays the execution of an effect by a specified `Duration`. + * + * **Details + * + * This function postpones the execution of the provided effect by the specified + * duration. The duration can be provided in various formats supported by the + * `Duration` module. + * + * Internally, this function does not block the thread; instead, it uses an + * efficient, non-blocking mechanism to introduce the delay. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const task = Console.log("Task executed") + * + * const program = Console.log("start").pipe( + * Effect.andThen( + * // Delays the log message by 2 seconds + * task.pipe(Effect.delay("2 seconds")) + * ) + * ) + * + * Effect.runFork(program) + * // Output: + * // start + * // Task executed + * ``` + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const delay: { + /** + * Delays the execution of an effect by a specified `Duration`. + * + * **Details + * + * This function postpones the execution of the provided effect by the specified + * duration. The duration can be provided in various formats supported by the + * `Duration` module. + * + * Internally, this function does not block the thread; instead, it uses an + * efficient, non-blocking mechanism to introduce the delay. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const task = Console.log("Task executed") + * + * const program = Console.log("start").pipe( + * Effect.andThen( + * // Delays the log message by 2 seconds + * task.pipe(Effect.delay("2 seconds")) + * ) + * ) + * + * Effect.runFork(program) + * // Output: + * // start + * // Task executed + * ``` + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (duration: Duration.DurationInput): (self: Effect) => Effect; + /** + * Delays the execution of an effect by a specified `Duration`. + * + * **Details + * + * This function postpones the execution of the provided effect by the specified + * duration. The duration can be provided in various formats supported by the + * `Duration` module. + * + * Internally, this function does not block the thread; instead, it uses an + * efficient, non-blocking mechanism to introduce the delay. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const task = Console.log("Task executed") + * + * const program = Console.log("start").pipe( + * Effect.andThen( + * // Delays the log message by 2 seconds + * task.pipe(Effect.delay("2 seconds")) + * ) + * ) + * + * Effect.runFork(program) + * // Output: + * // start + * // Task executed + * ``` + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (self: Effect, duration: Duration.DurationInput): Effect; +}; +/** + * Suspends the execution of an effect for a specified `Duration`. + * + * **Details** + * + * This function pauses the execution of an effect for a given duration. It is + * asynchronous, meaning that it does not block the fiber executing the effect. + * Instead, the fiber is suspended during the delay period and can resume once + * the specified time has passed. + * + * The duration can be specified using various formats supported by the + * `Duration` module, such as a string (`"2 seconds"`) or numeric value + * representing milliseconds. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * console.log("Starting task...") + * yield* Effect.sleep("3 seconds") // Waits for 3 seconds + * console.log("Task completed!") + * }) + * + * Effect.runFork(program) + * // Output: + * // Starting task... + * // Task completed! + * ``` + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const sleep: (duration: Duration.DurationInput) => Effect; +/** + * Executes an effect and measures the time it takes to complete. + * + * **Details** + * + * This function wraps the provided effect and returns a new effect that, when + * executed, performs the original effect and calculates its execution duration. + * + * The result of the new effect includes both the execution time (as a + * `Duration`) and the original effect's result. This is useful for monitoring + * performance or gaining insights into the time taken by specific operations. + * + * The original effect's behavior (success, failure, or interruption) remains + * unchanged, and the timing information is provided alongside the result in a + * tuple. + * + * **Example** + * + * ```ts + * import { Duration, Effect } from "effect" + * + * const task = Effect.gen(function*() { + * yield* Effect.sleep("2 seconds") // Simulates some work + * return "some result" + * }) + * + * const timedTask = task.pipe(Effect.timed) + * + * const program = Effect.gen(function*() { + * const [duration, result] = yield* timedTask + * console.log(`Task completed in ${Duration.toMillis(duration)} ms with result: ${result}`) + * }) + * + * Effect.runFork(program) + * // Output: Task completed in 2003.749125 ms with result: some result + * ``` + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const timed: (self: Effect) => Effect<[duration: Duration.Duration, result: A], E, R>; +/** + * Executes an effect and measures its execution time using a custom clock. + * + * **Details** + * + * This function extends the functionality of {@link timed} by allowing you to + * specify a custom clock for measuring the execution duration. The provided + * effect (`nanoseconds`) represents the clock and should return the current + * time in nanoseconds. The timing information is computed using this custom + * clock instead of the default system clock. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const timedWith: { + /** + * Executes an effect and measures its execution time using a custom clock. + * + * **Details** + * + * This function extends the functionality of {@link timed} by allowing you to + * specify a custom clock for measuring the execution duration. The provided + * effect (`nanoseconds`) represents the clock and should return the current + * time in nanoseconds. The timing information is computed using this custom + * clock instead of the default system clock. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (nanoseconds: Effect): (self: Effect) => Effect<[Duration.Duration, A], E1 | E, R1 | R>; + /** + * Executes an effect and measures its execution time using a custom clock. + * + * **Details** + * + * This function extends the functionality of {@link timed} by allowing you to + * specify a custom clock for measuring the execution duration. The provided + * effect (`nanoseconds`) represents the clock and should return the current + * time in nanoseconds. The timing information is computed using this custom + * clock instead of the default system clock. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (self: Effect, nanoseconds: Effect): Effect<[Duration.Duration, A], E | E1, R | R1>; +}; +/** + * Adds a time limit to an effect, triggering a timeout if the effect exceeds + * the duration. + * + * **Details** + * + * This function allows you to enforce a time limit on the execution of an + * effect. If the effect does not complete within the given duration, it fails + * with a `TimeoutException`. This is useful for preventing tasks from hanging + * indefinitely, especially in scenarios where responsiveness or resource limits + * are critical. + * + * The returned effect will either: + * - Succeed with the original effect's result if it completes within the + * specified duration. + * - Fail with a `TimeoutException` if the time limit is exceeded. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * // Output will show a TimeoutException as the task takes longer + * // than the specified timeout duration + * const timedEffect = task.pipe(Effect.timeout("1 second")) + * + * Effect.runPromiseExit(timedEffect).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: { _tag: 'TimeoutException' } + * // } + * // } + * ``` + * + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const timeout: { + /** + * Adds a time limit to an effect, triggering a timeout if the effect exceeds + * the duration. + * + * **Details** + * + * This function allows you to enforce a time limit on the execution of an + * effect. If the effect does not complete within the given duration, it fails + * with a `TimeoutException`. This is useful for preventing tasks from hanging + * indefinitely, especially in scenarios where responsiveness or resource limits + * are critical. + * + * The returned effect will either: + * - Succeed with the original effect's result if it completes within the + * specified duration. + * - Fail with a `TimeoutException` if the time limit is exceeded. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * // Output will show a TimeoutException as the task takes longer + * // than the specified timeout duration + * const timedEffect = task.pipe(Effect.timeout("1 second")) + * + * Effect.runPromiseExit(timedEffect).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: { _tag: 'TimeoutException' } + * // } + * // } + * ``` + * + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (duration: Duration.DurationInput): (self: Effect) => Effect; + /** + * Adds a time limit to an effect, triggering a timeout if the effect exceeds + * the duration. + * + * **Details** + * + * This function allows you to enforce a time limit on the execution of an + * effect. If the effect does not complete within the given duration, it fails + * with a `TimeoutException`. This is useful for preventing tasks from hanging + * indefinitely, especially in scenarios where responsiveness or resource limits + * are critical. + * + * The returned effect will either: + * - Succeed with the original effect's result if it completes within the + * specified duration. + * - Fail with a `TimeoutException` if the time limit is exceeded. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * // Output will show a TimeoutException as the task takes longer + * // than the specified timeout duration + * const timedEffect = task.pipe(Effect.timeout("1 second")) + * + * Effect.runPromiseExit(timedEffect).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: { _tag: 'TimeoutException' } + * // } + * // } + * ``` + * + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (self: Effect, duration: Duration.DurationInput): Effect; +}; +/** + * Gracefully handles timeouts by returning an `Option` that represents either + * the result or a timeout. + * + * **Details** + * + * This function wraps the outcome of an effect in an `Option` type. If the + * effect completes within the specified duration, it returns a `Some` + * containing the result. If the effect times out, it returns a `None`. Unlike + * other timeout methods, this approach does not raise errors or exceptions; + * instead, it allows you to treat timeouts as a regular outcome, simplifying + * the logic for handling delays. + * + * **When to Use** + * + * This is useful when you want to handle timeouts without causing the program + * to fail, making it easier to manage situations where you expect tasks might + * take too long but want to continue executing other tasks. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const timedOutEffect = Effect.all([ + * task.pipe(Effect.timeoutOption("3 seconds")), + * task.pipe(Effect.timeoutOption("1 second")) + * ]) + * + * Effect.runPromise(timedOutEffect).then(console.log) + * // Output: + * // Start processing... + * // Processing complete. + * // Start processing... + * // [ + * // { _id: 'Option', _tag: 'Some', value: 'Result' }, + * // { _id: 'Option', _tag: 'None' } + * // ] + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 3.1.0 + * @category Delays & Timeouts + */ +export declare const timeoutOption: { + /** + * Gracefully handles timeouts by returning an `Option` that represents either + * the result or a timeout. + * + * **Details** + * + * This function wraps the outcome of an effect in an `Option` type. If the + * effect completes within the specified duration, it returns a `Some` + * containing the result. If the effect times out, it returns a `None`. Unlike + * other timeout methods, this approach does not raise errors or exceptions; + * instead, it allows you to treat timeouts as a regular outcome, simplifying + * the logic for handling delays. + * + * **When to Use** + * + * This is useful when you want to handle timeouts without causing the program + * to fail, making it easier to manage situations where you expect tasks might + * take too long but want to continue executing other tasks. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const timedOutEffect = Effect.all([ + * task.pipe(Effect.timeoutOption("3 seconds")), + * task.pipe(Effect.timeoutOption("1 second")) + * ]) + * + * Effect.runPromise(timedOutEffect).then(console.log) + * // Output: + * // Start processing... + * // Processing complete. + * // Start processing... + * // [ + * // { _id: 'Option', _tag: 'Some', value: 'Result' }, + * // { _id: 'Option', _tag: 'None' } + * // ] + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 3.1.0 + * @category Delays & Timeouts + */ + (duration: Duration.DurationInput): (self: Effect) => Effect, E, R>; + /** + * Gracefully handles timeouts by returning an `Option` that represents either + * the result or a timeout. + * + * **Details** + * + * This function wraps the outcome of an effect in an `Option` type. If the + * effect completes within the specified duration, it returns a `Some` + * containing the result. If the effect times out, it returns a `None`. Unlike + * other timeout methods, this approach does not raise errors or exceptions; + * instead, it allows you to treat timeouts as a regular outcome, simplifying + * the logic for handling delays. + * + * **When to Use** + * + * This is useful when you want to handle timeouts without causing the program + * to fail, making it easier to manage situations where you expect tasks might + * take too long but want to continue executing other tasks. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const timedOutEffect = Effect.all([ + * task.pipe(Effect.timeoutOption("3 seconds")), + * task.pipe(Effect.timeoutOption("1 second")) + * ]) + * + * Effect.runPromise(timedOutEffect).then(console.log) + * // Output: + * // Start processing... + * // Processing complete. + * // Start processing... + * // [ + * // { _id: 'Option', _tag: 'Some', value: 'Result' }, + * // { _id: 'Option', _tag: 'None' } + * // ] + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 3.1.0 + * @category Delays & Timeouts + */ + (self: Effect, duration: Duration.DurationInput): Effect, E, R>; +}; +/** + * Specifies a custom error to be produced when a timeout occurs. + * + * **Details** + * + * This function allows you to handle timeouts in a customized way by defining a + * specific error to be raised when an effect exceeds the given duration. Unlike + * default timeout behaviors that use generic exceptions, this function gives + * you the flexibility to specify a meaningful error type that aligns with your + * application's needs. + * + * When you apply this function, you provide: + * - A `duration`: The time limit for the effect. + * - An `onTimeout` function: A lazy evaluation function that generates the + * custom error if the timeout occurs. + * + * If the effect completes within the time limit, its result is returned + * normally. Otherwise, the `onTimeout` function is triggered, and its output is + * used as the error for the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * class MyTimeoutError { + * readonly _tag = "MyTimeoutError" + * } + * + * const program = task.pipe( + * Effect.timeoutFail({ + * duration: "1 second", + * onTimeout: () => new MyTimeoutError() // Custom timeout error + * }) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: MyTimeoutError { _tag: 'MyTimeoutError' } + * // } + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const timeoutFail: { + /** + * Specifies a custom error to be produced when a timeout occurs. + * + * **Details** + * + * This function allows you to handle timeouts in a customized way by defining a + * specific error to be raised when an effect exceeds the given duration. Unlike + * default timeout behaviors that use generic exceptions, this function gives + * you the flexibility to specify a meaningful error type that aligns with your + * application's needs. + * + * When you apply this function, you provide: + * - A `duration`: The time limit for the effect. + * - An `onTimeout` function: A lazy evaluation function that generates the + * custom error if the timeout occurs. + * + * If the effect completes within the time limit, its result is returned + * normally. Otherwise, the `onTimeout` function is triggered, and its output is + * used as the error for the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * class MyTimeoutError { + * readonly _tag = "MyTimeoutError" + * } + * + * const program = task.pipe( + * Effect.timeoutFail({ + * duration: "1 second", + * onTimeout: () => new MyTimeoutError() // Custom timeout error + * }) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: MyTimeoutError { _tag: 'MyTimeoutError' } + * // } + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (options: { + readonly onTimeout: LazyArg; + readonly duration: Duration.DurationInput; + }): (self: Effect) => Effect; + /** + * Specifies a custom error to be produced when a timeout occurs. + * + * **Details** + * + * This function allows you to handle timeouts in a customized way by defining a + * specific error to be raised when an effect exceeds the given duration. Unlike + * default timeout behaviors that use generic exceptions, this function gives + * you the flexibility to specify a meaningful error type that aligns with your + * application's needs. + * + * When you apply this function, you provide: + * - A `duration`: The time limit for the effect. + * - An `onTimeout` function: A lazy evaluation function that generates the + * custom error if the timeout occurs. + * + * If the effect completes within the time limit, its result is returned + * normally. Otherwise, the `onTimeout` function is triggered, and its output is + * used as the error for the effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * class MyTimeoutError { + * readonly _tag = "MyTimeoutError" + * } + * + * const program = task.pipe( + * Effect.timeoutFail({ + * duration: "1 second", + * onTimeout: () => new MyTimeoutError() // Custom timeout error + * }) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: MyTimeoutError { _tag: 'MyTimeoutError' } + * // } + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (self: Effect, options: { + readonly onTimeout: LazyArg; + readonly duration: Duration.DurationInput; + }): Effect; +}; +/** + * Specifies a custom defect to be thrown when a timeout occurs. + * + * **Details** + * + * This function allows you to handle timeouts as exceptional cases by + * generating a custom defect when an effect exceeds the specified duration. You + * provide: + * - A `duration`: The time limit for the effect. + * - An `onTimeout` function: A lazy evaluation function that generates the + * custom defect (typically created using `Cause.die`). + * + * If the effect completes within the time limit, its result is returned + * normally. Otherwise, the custom defect is triggered, and the effect fails + * with that defect. + * + * **When to Use** + * + * This is especially useful when you need to treat timeouts as critical + * failures in your application and wish to include meaningful information in + * the defect. + * + * **Example** + * + * ```ts + * import { Effect, Cause } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const program = task.pipe( + * Effect.timeoutFailCause({ + * duration: "1 second", + * onTimeout: () => Cause.die("Timed out!") // Custom defect for timeout + * }) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Die', defect: 'Timed out!' } + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const timeoutFailCause: { + /** + * Specifies a custom defect to be thrown when a timeout occurs. + * + * **Details** + * + * This function allows you to handle timeouts as exceptional cases by + * generating a custom defect when an effect exceeds the specified duration. You + * provide: + * - A `duration`: The time limit for the effect. + * - An `onTimeout` function: A lazy evaluation function that generates the + * custom defect (typically created using `Cause.die`). + * + * If the effect completes within the time limit, its result is returned + * normally. Otherwise, the custom defect is triggered, and the effect fails + * with that defect. + * + * **When to Use** + * + * This is especially useful when you need to treat timeouts as critical + * failures in your application and wish to include meaningful information in + * the defect. + * + * **Example** + * + * ```ts + * import { Effect, Cause } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const program = task.pipe( + * Effect.timeoutFailCause({ + * duration: "1 second", + * onTimeout: () => Cause.die("Timed out!") // Custom defect for timeout + * }) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Die', defect: 'Timed out!' } + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (options: { + readonly onTimeout: LazyArg>; + readonly duration: Duration.DurationInput; + }): (self: Effect) => Effect; + /** + * Specifies a custom defect to be thrown when a timeout occurs. + * + * **Details** + * + * This function allows you to handle timeouts as exceptional cases by + * generating a custom defect when an effect exceeds the specified duration. You + * provide: + * - A `duration`: The time limit for the effect. + * - An `onTimeout` function: A lazy evaluation function that generates the + * custom defect (typically created using `Cause.die`). + * + * If the effect completes within the time limit, its result is returned + * normally. Otherwise, the custom defect is triggered, and the effect fails + * with that defect. + * + * **When to Use** + * + * This is especially useful when you need to treat timeouts as critical + * failures in your application and wish to include meaningful information in + * the defect. + * + * **Example** + * + * ```ts + * import { Effect, Cause } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const program = task.pipe( + * Effect.timeoutFailCause({ + * duration: "1 second", + * onTimeout: () => Cause.die("Timed out!") // Custom defect for timeout + * }) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Die', defect: 'Timed out!' } + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutTo} for a version that allows specifying both success and + * timeout handlers. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (self: Effect, options: { + readonly onTimeout: LazyArg>; + readonly duration: Duration.DurationInput; + }): Effect; +}; +/** + * Provides custom behavior for successful and timed-out operations. + * + * **Details** + * + * This function allows you to define distinct outcomes for an effect depending + * on whether it completes within a specified time frame or exceeds the timeout + * duration. You can provide: + * - `onSuccess`: A handler for processing the result of the effect if it + * completes successfully within the time limit. + * - `onTimeout`: A handler for generating a result when the effect times out. + * - `duration`: The maximum allowed time for the effect to complete. + * + * **When to Use** + * + * Unlike {@link timeout}, which raises an exception for timeouts, this function + * gives you full control over the behavior for both success and timeout + * scenarios. It is particularly useful when you want to encapsulate timeouts + * and successes into a specific data structure, like an `Either` type, to + * represent these outcomes in a meaningful way. + * + * **Example** + * + * ```ts + * import { Effect, Either } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const program = task.pipe( + * Effect.timeoutTo({ + * duration: "1 second", + * onSuccess: (result): Either.Either => + * Either.right(result), + * onTimeout: (): Either.Either => + * Either.left("Timed out!") + * }) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: "Either", + * // _tag: "Left", + * // left: "Timed out!" + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ +export declare const timeoutTo: { + /** + * Provides custom behavior for successful and timed-out operations. + * + * **Details** + * + * This function allows you to define distinct outcomes for an effect depending + * on whether it completes within a specified time frame or exceeds the timeout + * duration. You can provide: + * - `onSuccess`: A handler for processing the result of the effect if it + * completes successfully within the time limit. + * - `onTimeout`: A handler for generating a result when the effect times out. + * - `duration`: The maximum allowed time for the effect to complete. + * + * **When to Use** + * + * Unlike {@link timeout}, which raises an exception for timeouts, this function + * gives you full control over the behavior for both success and timeout + * scenarios. It is particularly useful when you want to encapsulate timeouts + * and successes into a specific data structure, like an `Either` type, to + * represent these outcomes in a meaningful way. + * + * **Example** + * + * ```ts + * import { Effect, Either } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const program = task.pipe( + * Effect.timeoutTo({ + * duration: "1 second", + * onSuccess: (result): Either.Either => + * Either.right(result), + * onTimeout: (): Either.Either => + * Either.left("Timed out!") + * }) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: "Either", + * // _tag: "Left", + * // left: "Timed out!" + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (options: { + readonly onTimeout: LazyArg; + readonly onSuccess: (a: A) => B; + readonly duration: Duration.DurationInput; + }): (self: Effect) => Effect; + /** + * Provides custom behavior for successful and timed-out operations. + * + * **Details** + * + * This function allows you to define distinct outcomes for an effect depending + * on whether it completes within a specified time frame or exceeds the timeout + * duration. You can provide: + * - `onSuccess`: A handler for processing the result of the effect if it + * completes successfully within the time limit. + * - `onTimeout`: A handler for generating a result when the effect times out. + * - `duration`: The maximum allowed time for the effect to complete. + * + * **When to Use** + * + * Unlike {@link timeout}, which raises an exception for timeouts, this function + * gives you full control over the behavior for both success and timeout + * scenarios. It is particularly useful when you want to encapsulate timeouts + * and successes into a specific data structure, like an `Either` type, to + * represent these outcomes in a meaningful way. + * + * **Example** + * + * ```ts + * import { Effect, Either } from "effect" + * + * const task = Effect.gen(function* () { + * console.log("Start processing...") + * yield* Effect.sleep("2 seconds") // Simulates a delay in processing + * console.log("Processing complete.") + * return "Result" + * }) + * + * const program = task.pipe( + * Effect.timeoutTo({ + * duration: "1 second", + * onSuccess: (result): Either.Either => + * Either.right(result), + * onTimeout: (): Either.Either => + * Either.left("Timed out!") + * }) + * ) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // Start processing... + * // { + * // _id: "Either", + * // _tag: "Left", + * // left: "Timed out!" + * // } + * ``` + * + * @see {@link timeout} for a version that raises a `TimeoutException`. + * @see {@link timeoutFail} for a version that raises a custom error. + * @see {@link timeoutFailCause} for a version that raises a custom defect. + * + * @since 2.0.0 + * @category Delays & Timeouts + */ + (self: Effect, options: { + readonly onTimeout: LazyArg; + readonly onSuccess: (a: A) => B; + readonly duration: Duration.DurationInput; + }): Effect; +}; +/** + * Allows working with the default configuration provider. + * + * **Details** + * + * This function retrieves the default configuration provider and passes it to + * the provided function, which can use it to perform computations or retrieve + * configuration values. The function can return an effect that leverages the + * configuration provider for its operations. + * + * @since 2.0.0 + * @category Config + */ +export declare const configProviderWith: (f: (provider: ConfigProvider) => Effect) => Effect; +/** + * Executes an effect using a specific configuration provider. + * + * **Details** + * + * This function lets you run an effect with a specified configuration provider. + * The custom provider will override the default configuration provider for the + * duration of the effect's execution. + * + * **When to Use** + * + * This is particularly useful when you need to use a different set of + * configuration values or sources for specific parts of your application. + * + * **Example** + * + * ```ts + * import { Config, ConfigProvider, Effect } from "effect" + * + * const customProvider: ConfigProvider.ConfigProvider = ConfigProvider.fromMap( + * new Map([["custom-key", "custom-value"]]) + * ) + * + * const program = Effect.withConfigProvider(customProvider)( + * Effect.gen(function*() { + * const value = yield* Config.string("custom-key") + * console.log(`Config value: ${value}`) + * }) + * ) + * + * Effect.runPromise(program) + * // Output: + * // Config value: custom-value + * ``` + * + * @since 2.0.0 + * @category Config + */ +export declare const withConfigProvider: { + /** + * Executes an effect using a specific configuration provider. + * + * **Details** + * + * This function lets you run an effect with a specified configuration provider. + * The custom provider will override the default configuration provider for the + * duration of the effect's execution. + * + * **When to Use** + * + * This is particularly useful when you need to use a different set of + * configuration values or sources for specific parts of your application. + * + * **Example** + * + * ```ts + * import { Config, ConfigProvider, Effect } from "effect" + * + * const customProvider: ConfigProvider.ConfigProvider = ConfigProvider.fromMap( + * new Map([["custom-key", "custom-value"]]) + * ) + * + * const program = Effect.withConfigProvider(customProvider)( + * Effect.gen(function*() { + * const value = yield* Config.string("custom-key") + * console.log(`Config value: ${value}`) + * }) + * ) + * + * Effect.runPromise(program) + * // Output: + * // Config value: custom-value + * ``` + * + * @since 2.0.0 + * @category Config + */ + (provider: ConfigProvider): (self: Effect) => Effect; + /** + * Executes an effect using a specific configuration provider. + * + * **Details** + * + * This function lets you run an effect with a specified configuration provider. + * The custom provider will override the default configuration provider for the + * duration of the effect's execution. + * + * **When to Use** + * + * This is particularly useful when you need to use a different set of + * configuration values or sources for specific parts of your application. + * + * **Example** + * + * ```ts + * import { Config, ConfigProvider, Effect } from "effect" + * + * const customProvider: ConfigProvider.ConfigProvider = ConfigProvider.fromMap( + * new Map([["custom-key", "custom-value"]]) + * ) + * + * const program = Effect.withConfigProvider(customProvider)( + * Effect.gen(function*() { + * const value = yield* Config.string("custom-key") + * console.log(`Config value: ${value}`) + * }) + * ) + * + * Effect.runPromise(program) + * // Output: + * // Config value: custom-value + * ``` + * + * @since 2.0.0 + * @category Config + */ + (self: Effect, provider: ConfigProvider): Effect; +}; +/** + * Sets a configuration provider within a scope. + * + * **Details** + * + * This function sets the configuration provider to a specified value and + * ensures that it is restored to its original value when the scope is closed. + * + * @since 2.0.0 + * @category Config + */ +export declare const withConfigProviderScoped: (provider: ConfigProvider) => Effect; +/** + * Accesses the full context of the effect. + * + * **Details** + * + * This function provides the ability to access the entire context required by + * an effect. The context is a container that holds dependencies or environment + * values needed by an effect to run. By using this function, you can retrieve + * and work with the context directly within an effect. + * + * @since 2.0.0 + * @category Context + */ +export declare const context: () => Effect, never, R>; +/** + * Accesses the context and applies a transformation function. + * + * **Details** + * + * This function retrieves the context of the effect and applies a pure + * transformation function to it. The result of the transformation is then + * returned within the effect. + * + * @see {@link contextWithEffect} for a version that allows effectful transformations. + * + * @since 2.0.0 + * @category Context + */ +export declare const contextWith: (f: (context: Context.Context) => A) => Effect; +/** + * Accesses the context and performs an effectful transformation. + * + * **Details** + * + * This function retrieves the context and allows you to transform it + * effectually using another effect. It is useful when the transformation + * involves asynchronous or effectful operations. + * + * @see {@link contextWith} for a version that allows pure transformations. + * + * @since 2.0.0 + * @category Context + */ +export declare const contextWithEffect: (f: (context: Context.Context) => Effect) => Effect; +/** + * Provides part of the required context while leaving the rest unchanged. + * + * **Details** + * + * This function allows you to transform the context required by an effect, + * providing part of the context and leaving the rest to be fulfilled later. + * + * **Example** + * + * ```ts + * import { Context, Effect } from "effect" + * + * class Service1 extends Context.Tag("Service1")() {} + * class Service2 extends Context.Tag("Service2")() {} + * + * const program = Effect.gen(function*() { + * const service1 = yield* Service1 + * console.log(service1.port) + * const service2 = yield* Service2 + * console.log(service2.connection) + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const programWithService1 = Effect.mapInputContext( + * program, + * (ctx: Context.Context) => Context.add(ctx, Service1, { port: 3000 }) + * ) + * + * const runnable = programWithService1.pipe( + * Effect.provideService(Service2, { connection: "localhost" }), + * Effect.provideService(Service1, { port: 3001 }) + * ) + * + * Effect.runPromise(runnable) + * // Output: + * // 3000 + * // localhost + * ``` + * + * @since 2.0.0 + * @category Context + */ +export declare const mapInputContext: { + /** + * Provides part of the required context while leaving the rest unchanged. + * + * **Details** + * + * This function allows you to transform the context required by an effect, + * providing part of the context and leaving the rest to be fulfilled later. + * + * **Example** + * + * ```ts + * import { Context, Effect } from "effect" + * + * class Service1 extends Context.Tag("Service1")() {} + * class Service2 extends Context.Tag("Service2")() {} + * + * const program = Effect.gen(function*() { + * const service1 = yield* Service1 + * console.log(service1.port) + * const service2 = yield* Service2 + * console.log(service2.connection) + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const programWithService1 = Effect.mapInputContext( + * program, + * (ctx: Context.Context) => Context.add(ctx, Service1, { port: 3000 }) + * ) + * + * const runnable = programWithService1.pipe( + * Effect.provideService(Service2, { connection: "localhost" }), + * Effect.provideService(Service1, { port: 3001 }) + * ) + * + * Effect.runPromise(runnable) + * // Output: + * // 3000 + * // localhost + * ``` + * + * @since 2.0.0 + * @category Context + */ + (f: (context: Context.Context) => Context.Context): (self: Effect) => Effect; + /** + * Provides part of the required context while leaving the rest unchanged. + * + * **Details** + * + * This function allows you to transform the context required by an effect, + * providing part of the context and leaving the rest to be fulfilled later. + * + * **Example** + * + * ```ts + * import { Context, Effect } from "effect" + * + * class Service1 extends Context.Tag("Service1")() {} + * class Service2 extends Context.Tag("Service2")() {} + * + * const program = Effect.gen(function*() { + * const service1 = yield* Service1 + * console.log(service1.port) + * const service2 = yield* Service2 + * console.log(service2.connection) + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const programWithService1 = Effect.mapInputContext( + * program, + * (ctx: Context.Context) => Context.add(ctx, Service1, { port: 3000 }) + * ) + * + * const runnable = programWithService1.pipe( + * Effect.provideService(Service2, { connection: "localhost" }), + * Effect.provideService(Service1, { port: 3001 }) + * ) + * + * Effect.runPromise(runnable) + * // Output: + * // 3000 + * // localhost + * ``` + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, f: (context: Context.Context) => Context.Context): Effect; +}; +/** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ +export declare const provide: { + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + ]>(layers: Layers): (self: Effect) => Effect; + }[number], { + [k in keyof Layers]: Layer.Layer.Context; + }[number] | Exclude; + }[number]>>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (layer: Layer.Layer): (self: Effect) => Effect>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (context: Context.Context): (self: Effect) => Effect>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (runtime: Runtime.Runtime): (self: Effect) => Effect>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (managedRuntime: ManagedRuntime.ManagedRuntime): (self: Effect) => Effect>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + ]>(self: Effect, layers: Layers): Effect; + }[number], { + [k in keyof Layers]: Layer.Layer.Context; + }[number] | Exclude; + }[number]>>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, layer: Layer.Layer): Effect>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, context: Context.Context): Effect>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, runtime: Runtime.Runtime): Effect>; + /** + * Provides necessary dependencies to an effect, removing its environmental + * requirements. + * + * **Details** + * + * This function allows you to supply the required environment for an effect. + * The environment can be provided in the form of one or more `Layer`s, a + * `Context`, a `Runtime`, or a `ManagedRuntime`. Once the environment is + * provided, the effect can run without requiring external dependencies. + * + * You can compose layers to create a modular and reusable way of setting up the + * environment for effects. For example, layers can be used to configure + * databases, logging services, or any other required dependencies. + * + * **Example** + * + * ```ts + * import { Context, Effect, Layer } from "effect" + * + * class Database extends Context.Tag("Database")< + * Database, + * { readonly query: (sql: string) => Effect.Effect> } + * >() {} + * + * const DatabaseLive = Layer.succeed( + * Database, + * { + * // Simulate a database query + * query: (sql: string) => Effect.log(`Executing query: ${sql}`).pipe(Effect.as([])) + * } + * ) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function*() { + * const database = yield* Database + * const result = yield* database.query("SELECT * FROM users") + * return result + * }) + * + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provide(program, DatabaseLive) + * + * Effect.runPromise(runnable).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users" + * // [] + * ``` + * + * @see {@link provideService} for providing a service to an effect. + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, runtime: ManagedRuntime.ManagedRuntime): Effect>; +}; +/** + * Provides an implementation for a service in the context of an effect. + * + * **Details** + * + * This function allows you to supply a specific implementation for a service + * required by an effect. Services are typically defined using `Context.Tag`, + * which acts as a unique identifier for the service. By using this function, + * you link the service to its concrete implementation, enabling the effect to + * execute successfully without additional requirements. + * + * For example, you can use this function to provide a random number generator, + * a logger, or any other service your effect depends on. Once the service is + * provided, all parts of the effect that rely on the service will automatically + * use the implementation you supplied. + * + * **Example** + * + * ```ts + * import { Effect, Context } from "effect" + * + * // Declaring a tag for a service that generates random numbers + * class Random extends Context.Tag("MyRandomService")< + * Random, + * { readonly next: Effect.Effect } + * >() {} + * + * // Using the service + * const program = Effect.gen(function* () { + * const random = yield* Random + * const randomNumber = yield* random.next + * console.log(`random number: ${randomNumber}`) + * }) + * + * // Providing the implementation + * // + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provideService(program, Random, { + * next: Effect.sync(() => Math.random()) + * }) + * + * // Run successfully + * Effect.runPromise(runnable) + * // Example Output: + * // random number: 0.8241872233134417 + * ``` + * + * @see {@link provide} for providing multiple layers to an effect. + * + * @since 2.0.0 + * @category Context + */ +export declare const provideService: { + /** + * Provides an implementation for a service in the context of an effect. + * + * **Details** + * + * This function allows you to supply a specific implementation for a service + * required by an effect. Services are typically defined using `Context.Tag`, + * which acts as a unique identifier for the service. By using this function, + * you link the service to its concrete implementation, enabling the effect to + * execute successfully without additional requirements. + * + * For example, you can use this function to provide a random number generator, + * a logger, or any other service your effect depends on. Once the service is + * provided, all parts of the effect that rely on the service will automatically + * use the implementation you supplied. + * + * **Example** + * + * ```ts + * import { Effect, Context } from "effect" + * + * // Declaring a tag for a service that generates random numbers + * class Random extends Context.Tag("MyRandomService")< + * Random, + * { readonly next: Effect.Effect } + * >() {} + * + * // Using the service + * const program = Effect.gen(function* () { + * const random = yield* Random + * const randomNumber = yield* random.next + * console.log(`random number: ${randomNumber}`) + * }) + * + * // Providing the implementation + * // + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provideService(program, Random, { + * next: Effect.sync(() => Math.random()) + * }) + * + * // Run successfully + * Effect.runPromise(runnable) + * // Example Output: + * // random number: 0.8241872233134417 + * ``` + * + * @see {@link provide} for providing multiple layers to an effect. + * + * @since 2.0.0 + * @category Context + */ + (tag: Context.Tag, service: NoInfer): (self: Effect) => Effect>; + /** + * Provides an implementation for a service in the context of an effect. + * + * **Details** + * + * This function allows you to supply a specific implementation for a service + * required by an effect. Services are typically defined using `Context.Tag`, + * which acts as a unique identifier for the service. By using this function, + * you link the service to its concrete implementation, enabling the effect to + * execute successfully without additional requirements. + * + * For example, you can use this function to provide a random number generator, + * a logger, or any other service your effect depends on. Once the service is + * provided, all parts of the effect that rely on the service will automatically + * use the implementation you supplied. + * + * **Example** + * + * ```ts + * import { Effect, Context } from "effect" + * + * // Declaring a tag for a service that generates random numbers + * class Random extends Context.Tag("MyRandomService")< + * Random, + * { readonly next: Effect.Effect } + * >() {} + * + * // Using the service + * const program = Effect.gen(function* () { + * const random = yield* Random + * const randomNumber = yield* random.next + * console.log(`random number: ${randomNumber}`) + * }) + * + * // Providing the implementation + * // + * // ┌─── Effect + * // ▼ + * const runnable = Effect.provideService(program, Random, { + * next: Effect.sync(() => Math.random()) + * }) + * + * // Run successfully + * Effect.runPromise(runnable) + * // Example Output: + * // random number: 0.8241872233134417 + * ``` + * + * @see {@link provide} for providing multiple layers to an effect. + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, tag: Context.Tag, service: NoInfer): Effect>; +}; +/** + * Dynamically provides an implementation for a service using an effect. + * + * **Details** + * + * This function allows you to provide an implementation for a service + * dynamically by using another effect. The provided effect is executed to + * produce the service implementation, which is then made available to the + * consuming effect. This is particularly useful when the service implementation + * itself requires asynchronous or resource-intensive initialization. + * + * For example, you can use this function to lazily initialize a database + * connection or fetch configuration values from an external source before + * making the service available to your effect. + * + * @since 2.0.0 + * @category Context + */ +export declare const provideServiceEffect: { + /** + * Dynamically provides an implementation for a service using an effect. + * + * **Details** + * + * This function allows you to provide an implementation for a service + * dynamically by using another effect. The provided effect is executed to + * produce the service implementation, which is then made available to the + * consuming effect. This is particularly useful when the service implementation + * itself requires asynchronous or resource-intensive initialization. + * + * For example, you can use this function to lazily initialize a database + * connection or fetch configuration values from an external source before + * making the service available to your effect. + * + * @since 2.0.0 + * @category Context + */ + (tag: Context.Tag, effect: Effect, E1, R1>): (self: Effect) => Effect>; + /** + * Dynamically provides an implementation for a service using an effect. + * + * **Details** + * + * This function allows you to provide an implementation for a service + * dynamically by using another effect. The provided effect is executed to + * produce the service implementation, which is then made available to the + * consuming effect. This is particularly useful when the service implementation + * itself requires asynchronous or resource-intensive initialization. + * + * For example, you can use this function to lazily initialize a database + * connection or fetch configuration values from an external source before + * making the service available to your effect. + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, tag: Context.Tag, effect: Effect, E1, R1>): Effect>; +}; +/** + * Creates a function that uses a service from the context to produce a value. + * + * @see {@link serviceFunctionEffect} for a version that returns an effect. + * + * @since 2.0.0 + * @category Context + */ +export declare const serviceFunction: , Args extends Array, A>(getService: T, f: (_: Effect.Success) => (...args: Args) => A) => (...args: Args) => Effect, Effect.Context>; +/** + * Creates a function that uses a service from the context to produce an effect. + * + * @see {@link serviceFunction} for a version that returns a value. + * + * @since 2.0.0 + * @category Context + */ +export declare const serviceFunctionEffect: , Args extends Array, A, E, R>(getService: T, f: (_: Effect.Success) => (...args: Args) => Effect) => (...args: Args) => Effect, R | Effect.Context>; +/** + * @since 2.0.0 + * @category Context + */ +export declare const serviceFunctions: (getService: Effect) => { + [k in keyof S as S[k] extends (...args: Array) => Effect ? k : never]: S[k] extends (...args: infer Args) => Effect ? (...args: Args) => Effect : never; +}; +/** + * @since 2.0.0 + * @category Context + */ +export declare const serviceConstants: (getService: Effect) => { + [k in { + [k in keyof S]: k; + }[keyof S]]: S[k] extends Effect ? Effect : Effect; +}; +/** + * @since 2.0.0 + * @category Context + */ +export declare const serviceMembers: (getService: Effect) => { + functions: { + [k in keyof S as S[k] extends (...args: Array) => Effect ? k : never]: S[k] extends (...args: infer Args) => Effect ? (...args: Args) => Effect : never; + }; + constants: { + [k in { + [k in keyof S]: k; + }[keyof S]]: S[k] extends Effect ? Effect : Effect; + }; +}; +/** + * Retrieves an optional service from the context as an `Option`. + * + * **Details** + * + * This function retrieves a service from the context and wraps it in an + * `Option`. If the service is available, it returns a `Some` containing the + * service. If the service is not found, it returns a `None`. This approach is + * useful when you want to handle the absence of a service gracefully without + * causing an error. + * + * **When to Use** + * + * Use this function when: + * - You need to access a service that may or may not be present in the context. + * - You want to handle the absence of a service using the `Option` type instead + * of throwing an error. + * + * @see {@link serviceOptional} for a version that throws an error if the service is missing. + * + * @since 2.0.0 + * @category Context + */ +export declare const serviceOption: (tag: Context.Tag) => Effect>; +/** + * Retrieves a service from the context, throwing an error if it is missing. + * + * **Details** + * + * This function retrieves a required service from the context. If the service + * is available, it returns the service. If the service is missing, it throws a + * `NoSuchElementException`, which can be handled using Effect's error-handling + * mechanisms. This is useful for services that are critical to the execution of + * your effect. + * + * @see {@link serviceOption} for a version that returns an `Option` instead of throwing an error. + * + * @since 2.0.0 + * @category Context + */ +export declare const serviceOptional: (tag: Context.Tag) => Effect; +/** + * Updates a service in the context with a new implementation. + * + * **Details** + * + * This function modifies the existing implementation of a service in the + * context. It retrieves the current service, applies the provided + * transformation function `f`, and replaces the old service with the + * transformed one. + * + * **When to Use** + * + * This is useful for adapting or extending a service's behavior during the + * execution of an effect. + * + * @since 2.0.0 + * @category Context + */ +export declare const updateService: { + /** + * Updates a service in the context with a new implementation. + * + * **Details** + * + * This function modifies the existing implementation of a service in the + * context. It retrieves the current service, applies the provided + * transformation function `f`, and replaces the old service with the + * transformed one. + * + * **When to Use** + * + * This is useful for adapting or extending a service's behavior during the + * execution of an effect. + * + * @since 2.0.0 + * @category Context + */ + (tag: Context.Tag, f: (service: NoInfer) => NoInfer): (self: Effect) => Effect; + /** + * Updates a service in the context with a new implementation. + * + * **Details** + * + * This function modifies the existing implementation of a service in the + * context. It retrieves the current service, applies the provided + * transformation function `f`, and replaces the old service with the + * transformed one. + * + * **When to Use** + * + * This is useful for adapting or extending a service's behavior during the + * execution of an effect. + * + * @since 2.0.0 + * @category Context + */ + (self: Effect, tag: Context.Tag, f: (service: NoInfer) => NoInfer): Effect; +}; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * ``` + * + * @see {@link bind} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ +export declare const Do: Effect<{}>; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ +export declare const bind: { + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (name: Exclude, f: (a: NoInfer) => Effect): (self: Effect) => Effect<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E2 | E1, R2 | R1>; + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (self: Effect, name: Exclude, f: (a: NoInfer) => Effect): Effect<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E1 | E2, R1 | R2>; +}; +/** + * `bindAll` combines `all` with `bind`. It is useful + * when you want to concurrently run multiple effects and then combine their + * results in a Do notation pipeline. + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, Either, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bindAll(({ x }) => ({ + * a: Effect.succeed(x), + * b: Effect.fail("oops"), + * }), { concurrency: 2, mode: "either" }) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, a: Either.right(2), b: Either.left("oops") }) + * ``` + * + * @category Do notation + * @since 3.7.0 + */ +export declare const bindAll: { + /** + * `bindAll` combines `all` with `bind`. It is useful + * when you want to concurrently run multiple effects and then combine their + * results in a Do notation pipeline. + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, Either, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bindAll(({ x }) => ({ + * a: Effect.succeed(x), + * b: Effect.fail("oops"), + * }), { concurrency: 2, mode: "either" }) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, a: Either.right(2), b: Either.left("oops") }) + * ``` + * + * @category Do notation + * @since 3.7.0 + */ + >, O extends NoExcessProperties<{ + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly mode?: "default" | "validate" | "either" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }, O>>(f: (a: NoInfer) => [Extract] extends [never] ? X : `Duplicate keys`, options?: undefined | O): (self: Effect) => [All.ReturnObject>] extends [Effect] ? Effect<{ + [K in keyof A | keyof Success]: K extends keyof A ? A[K] : K extends keyof Success ? Success[K] : never; + }, E1 | Error, R1 | Context> : never; + /** + * `bindAll` combines `all` with `bind`. It is useful + * when you want to concurrently run multiple effects and then combine their + * results in a Do notation pipeline. + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, Either, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bindAll(({ x }) => ({ + * a: Effect.succeed(x), + * b: Effect.fail("oops"), + * }), { concurrency: 2, mode: "either" }) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, a: Either.right(2), b: Either.left("oops") }) + * ``` + * + * @category Do notation + * @since 3.7.0 + */ + >, O extends NoExcessProperties<{ + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly mode?: "default" | "validate" | "either" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }, O>, E1, R1>(self: Effect, f: (a: NoInfer) => [Extract] extends [never] ? X : `Duplicate keys`, options?: undefined | { + readonly concurrency?: Concurrency | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly mode?: "default" | "validate" | "either" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }): [All.ReturnObject>] extends [Effect] ? Effect<{ + [K in keyof A | keyof Success]: K extends keyof A ? A[K] : K extends keyof Success ? Success[K] : never; + }, E1 | Error, R1 | Context> : never; +}; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ +export declare const bindTo: { + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (name: N): (self: Effect) => Effect<{ + [K in N]: A; + }, E, R>; + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (self: Effect, name: N): Effect<{ + [K in N]: A; + }, E, R>; +}; +declare const let_: { + (name: Exclude, f: (a: NoInfer) => B): (self: Effect) => Effect<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E, R>; + (self: Effect, name: Exclude, f: (a: NoInfer) => B): Effect<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E, R>; +}; +export { +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Effect` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * **Example** + * + * ```ts + * import * as assert from "node:assert" + * import { Effect, pipe } from "effect" + * + * const result = pipe( + * Effect.Do, + * Effect.bind("x", () => Effect.succeed(2)), + * Effect.bind("y", () => Effect.succeed(3)), + * Effect.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 }) + * + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link bindTo} + * + * @category Do notation + * @since 2.0.0 + */ +let_ as let }; +/** + * Encapsulates the result of an effect in an `Option`. + * + * **Details** + * + * This function wraps the outcome of an effect in an `Option` type. If the + * original effect succeeds, the success value is wrapped in `Option.some`. If + * the effect fails, the failure is converted to `Option.none`. + * + * This is particularly useful for scenarios where you want to represent the + * absence of a value explicitly, without causing the resulting effect to fail. + * The resulting effect has an error type of `never`, meaning it cannot fail + * directly. However, unrecoverable errors, also referred to as defects, are + * not captured and will still result in failure. + * + * **Example** (Using Effect.option to Handle Errors) + * + * ```ts + * import { Effect } from "effect" + * + * const maybe1 = Effect.option(Effect.succeed(1)) + * + * Effect.runPromiseExit(maybe1).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Success', + * // value: { _id: 'Option', _tag: 'Some', value: 1 } + * // } + * + * const maybe2 = Effect.option(Effect.fail("Uh oh!")) + * + * Effect.runPromiseExit(maybe2).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Success', + * // value: { _id: 'Option', _tag: 'None' } + * // } + * + * const maybe3 = Effect.option(Effect.die("Boom!")) + * + * Effect.runPromiseExit(maybe3).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Die', defect: 'Boom!' } + * // } + * ``` + * + * @see {@link either} for a version that uses `Either` instead. + * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`. + * + * @since 2.0.0 + * @category Outcome Encapsulation + */ +export declare const option: (self: Effect) => Effect, never, R>; +/** + * Encapsulates both success and failure of an `Effect` into an `Either` type. + * + * **Details** + * + * This function converts an effect that may fail into an effect that always + * succeeds, wrapping the outcome in an `Either` type. The result will be + * `Either.Left` if the effect fails, containing the recoverable error, or + * `Either.Right` if it succeeds, containing the result. + * + * Using this function, you can handle recoverable errors explicitly without + * causing the effect to fail. This is particularly useful in scenarios where + * you want to chain effects and manage both success and failure in the same + * logical flow. + * + * It's important to note that unrecoverable errors, often referred to as + * "defects," are still thrown and not captured within the `Either` type. Only + * failures that are explicitly represented as recoverable errors in the effect + * are encapsulated. + * + * The resulting effect cannot fail directly because all recoverable failures + * are represented inside the `Either` type. + * + * **Example** + * + * ```ts + * import { Effect, Either, Random } from "effect" + * + * class HttpError { + * readonly _tag = "HttpError" + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * } + * + * // ┌─── Effect + * // ▼ + * const program = Effect.gen(function* () { + * const n1 = yield* Random.next + * const n2 = yield* Random.next + * if (n1 < 0.5) { + * yield* Effect.fail(new HttpError()) + * } + * if (n2 < 0.5) { + * yield* Effect.fail(new ValidationError()) + * } + * return "some result" + * }) + * + * // ┌─── Effect + * // ▼ + * const recovered = Effect.gen(function* () { + * // ┌─── Either + * // ▼ + * const failureOrSuccess = yield* Effect.either(program) + * return Either.match(failureOrSuccess, { + * onLeft: (error) => `Recovering from ${error._tag}`, + * onRight: (value) => value // Do nothing in case of success + * }) + * }) + * ``` + * + * @see {@link option} for a version that uses `Option` instead. + * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`. + * + * @since 2.0.0 + * @category Outcome Encapsulation + */ +export declare const either: (self: Effect) => Effect, never, R>; +/** + * Encapsulates both success and failure of an `Effect` using the `Exit` type. + * + * **Details** + * + * This function converts an effect into one that always succeeds, wrapping its + * outcome in the `Exit` type. The `Exit` type provides explicit handling of + * both success (`Exit.Success`) and failure (`Exit.Failure`) cases, including + * defects (unrecoverable errors). + * + * Unlike {@link either} or {@link option}, this function also encapsulates + * defects, which are typically unrecoverable and would otherwise terminate the + * effect. With the `Exit` type, defects are represented in `Exit.Failure`, + * allowing for detailed introspection and structured error handling. + * + * This makes the resulting effect robust and incapable of direct failure (its + * error type is `never`). It is particularly useful for workflows where all + * outcomes, including unexpected defects, must be managed and analyzed. + * + * **Example** + * + * ```ts + * import { Effect, Cause, Console, Exit } from "effect" + * + * // Simulating a runtime error + * const task = Effect.dieMessage("Boom!") + * + * const program = Effect.gen(function* () { + * const exit = yield* Effect.exit(task) + * if (Exit.isFailure(exit)) { + * const cause = exit.cause + * if ( + * Cause.isDieType(cause) && + * Cause.isRuntimeException(cause.defect) + * ) { + * yield* Console.log( + * `RuntimeException defect caught: ${cause.defect.message}` + * ) + * } else { + * yield* Console.log("Unknown failure caught.") + * } + * } + * }) + * + * // We get an Exit.Success because we caught all failures + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // RuntimeException defect caught: Boom! + * // { + * // _id: "Exit", + * // _tag: "Success", + * // value: undefined + * // } + * ``` + * + * @see {@link option} for a version that uses `Option` instead. + * @see {@link either} for a version that uses `Either` instead. + * + * @since 2.0.0 + * @category Outcome Encapsulation + */ +export declare const exit: (self: Effect) => Effect, never, R>; +/** + * Converts an `Effect` into an operation that completes a `Deferred` with its result. + * + * **Details** + * + * The `intoDeferred` function takes an effect and a `Deferred` and ensures that the `Deferred` + * is completed based on the outcome of the effect. If the effect succeeds, the `Deferred` is + * completed with the success value. If the effect fails, the `Deferred` is completed with the + * failure. Additionally, if the effect is interrupted, the `Deferred` will also be interrupted. + * + * **Example** + * + * ```ts + * import { Deferred, Effect } from "effect" + * + * // Define an effect that succeeds + * const successEffect = Effect.succeed(42) + * + * const program = Effect.gen(function*() { + * // Create a deferred + * const deferred = yield* Deferred.make() + * + * // Complete the deferred using the successEffect + * const isCompleted = yield* Effect.intoDeferred(successEffect, deferred) + * + * // Access the value of the deferred + * const value = yield* Deferred.await(deferred) + * console.log(value) + * + * return isCompleted + * }) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // 42 + * // true + * ``` + * + * @since 2.0.0 + * @category Synchronization Utilities + */ +export declare const intoDeferred: { + /** + * Converts an `Effect` into an operation that completes a `Deferred` with its result. + * + * **Details** + * + * The `intoDeferred` function takes an effect and a `Deferred` and ensures that the `Deferred` + * is completed based on the outcome of the effect. If the effect succeeds, the `Deferred` is + * completed with the success value. If the effect fails, the `Deferred` is completed with the + * failure. Additionally, if the effect is interrupted, the `Deferred` will also be interrupted. + * + * **Example** + * + * ```ts + * import { Deferred, Effect } from "effect" + * + * // Define an effect that succeeds + * const successEffect = Effect.succeed(42) + * + * const program = Effect.gen(function*() { + * // Create a deferred + * const deferred = yield* Deferred.make() + * + * // Complete the deferred using the successEffect + * const isCompleted = yield* Effect.intoDeferred(successEffect, deferred) + * + * // Access the value of the deferred + * const value = yield* Deferred.await(deferred) + * console.log(value) + * + * return isCompleted + * }) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // 42 + * // true + * ``` + * + * @since 2.0.0 + * @category Synchronization Utilities + */ + (deferred: Deferred.Deferred): (self: Effect) => Effect; + /** + * Converts an `Effect` into an operation that completes a `Deferred` with its result. + * + * **Details** + * + * The `intoDeferred` function takes an effect and a `Deferred` and ensures that the `Deferred` + * is completed based on the outcome of the effect. If the effect succeeds, the `Deferred` is + * completed with the success value. If the effect fails, the `Deferred` is completed with the + * failure. Additionally, if the effect is interrupted, the `Deferred` will also be interrupted. + * + * **Example** + * + * ```ts + * import { Deferred, Effect } from "effect" + * + * // Define an effect that succeeds + * const successEffect = Effect.succeed(42) + * + * const program = Effect.gen(function*() { + * // Create a deferred + * const deferred = yield* Deferred.make() + * + * // Complete the deferred using the successEffect + * const isCompleted = yield* Effect.intoDeferred(successEffect, deferred) + * + * // Access the value of the deferred + * const value = yield* Deferred.await(deferred) + * console.log(value) + * + * return isCompleted + * }) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // 42 + * // true + * ``` + * + * @since 2.0.0 + * @category Synchronization Utilities + */ + (self: Effect, deferred: Deferred.Deferred): Effect; +}; +declare const if_: { + (options: { + readonly onTrue: LazyArg>; + readonly onFalse: LazyArg>; + }): (self: boolean | Effect) => Effect; + (self: boolean | Effect, options: { + readonly onTrue: LazyArg>; + readonly onFalse: LazyArg>; + }): Effect; +}; +export { +/** + * Executes one of two effects based on a condition evaluated by an effectful predicate. + * + * Use `if` to run one of two effects depending on whether the predicate effect + * evaluates to `true` or `false`. If the predicate is `true`, the `onTrue` effect + * is executed. If it is `false`, the `onFalse` effect is executed instead. + * + * **Example** (Simulating a Coin Flip) + * + * ```ts + * import { Effect, Random, Console } from "effect" + * + * const flipTheCoin = Effect.if(Random.nextBoolean, { + * onTrue: () => Console.log("Head"), // Runs if the predicate is true + * onFalse: () => Console.log("Tail") // Runs if the predicate is false + * }) + * + * Effect.runFork(flipTheCoin) + * ``` + * + * @since 2.0.0 + * @category Conditional Operators + */ +if_ as if }; +/** + * Filters an effect, dying with a custom defect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect dies with a custom defect + * generated by the `orDieWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints on values and treating violations as + * fatal program errors. + * + * @since 2.0.0 + * @category Filtering + */ +export declare const filterOrDie: { + /** + * Filters an effect, dying with a custom defect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect dies with a custom defect + * generated by the `orDieWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints on values and treating violations as + * fatal program errors. + * + * @since 2.0.0 + * @category Filtering + */ + (refinement: Refinement, B>, orDieWith: (a: EqualsWith>) => unknown): (self: Effect) => Effect; + /** + * Filters an effect, dying with a custom defect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect dies with a custom defect + * generated by the `orDieWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints on values and treating violations as + * fatal program errors. + * + * @since 2.0.0 + * @category Filtering + */ + (predicate: Predicate>, orDieWith: (a: NoInfer) => unknown): (self: Effect) => Effect; + /** + * Filters an effect, dying with a custom defect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect dies with a custom defect + * generated by the `orDieWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints on values and treating violations as + * fatal program errors. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, refinement: Refinement, orDieWith: (a: EqualsWith>) => unknown): Effect; + /** + * Filters an effect, dying with a custom defect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect dies with a custom defect + * generated by the `orDieWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints on values and treating violations as + * fatal program errors. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, predicate: Predicate, orDieWith: (a: A) => unknown): Effect; +}; +/** + * Filters an effect, dying with a custom message if the predicate fails. + * + * **Details** + * + * This function works like {@link filterOrDie} but allows you to specify a + * custom error message to describe the reason for the failure. The message is + * included in the defect when the predicate evaluates to `false`. + * + * @since 2.0.0 + * @category Filtering + */ +export declare const filterOrDieMessage: { + /** + * Filters an effect, dying with a custom message if the predicate fails. + * + * **Details** + * + * This function works like {@link filterOrDie} but allows you to specify a + * custom error message to describe the reason for the failure. The message is + * included in the defect when the predicate evaluates to `false`. + * + * @since 2.0.0 + * @category Filtering + */ + (refinement: Refinement, B>, message: string): (self: Effect) => Effect; + /** + * Filters an effect, dying with a custom message if the predicate fails. + * + * **Details** + * + * This function works like {@link filterOrDie} but allows you to specify a + * custom error message to describe the reason for the failure. The message is + * included in the defect when the predicate evaluates to `false`. + * + * @since 2.0.0 + * @category Filtering + */ + (predicate: Predicate>, message: string): (self: Effect) => Effect; + /** + * Filters an effect, dying with a custom message if the predicate fails. + * + * **Details** + * + * This function works like {@link filterOrDie} but allows you to specify a + * custom error message to describe the reason for the failure. The message is + * included in the defect when the predicate evaluates to `false`. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, refinement: Refinement, message: string): Effect; + /** + * Filters an effect, dying with a custom message if the predicate fails. + * + * **Details** + * + * This function works like {@link filterOrDie} but allows you to specify a + * custom error message to describe the reason for the failure. The message is + * included in the defect when the predicate evaluates to `false`. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, predicate: Predicate, message: string): Effect; +}; +/** + * Filters an effect, providing an alternative effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, it executes the `orElse` effect instead. The + * `orElse` effect can produce an alternative value or perform additional + * computations. + * + * @since 2.0.0 + * @category Filtering + */ +export declare const filterOrElse: { + /** + * Filters an effect, providing an alternative effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, it executes the `orElse` effect instead. The + * `orElse` effect can produce an alternative value or perform additional + * computations. + * + * @since 2.0.0 + * @category Filtering + */ + (refinement: Refinement, B>, orElse: (a: EqualsWith, Exclude, B>>) => Effect): (self: Effect) => Effect; + /** + * Filters an effect, providing an alternative effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, it executes the `orElse` effect instead. The + * `orElse` effect can produce an alternative value or perform additional + * computations. + * + * @since 2.0.0 + * @category Filtering + */ + (predicate: Predicate>, orElse: (a: NoInfer) => Effect): (self: Effect) => Effect; + /** + * Filters an effect, providing an alternative effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, it executes the `orElse` effect instead. The + * `orElse` effect can produce an alternative value or perform additional + * computations. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, refinement: Refinement, orElse: (a: EqualsWith>) => Effect): Effect; + /** + * Filters an effect, providing an alternative effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, it executes the `orElse` effect instead. The + * `orElse` effect can produce an alternative value or perform additional + * computations. + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, predicate: Predicate, orElse: (a: A) => Effect): Effect; +}; +/** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ +export declare const filterOrFail: { + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (refinement: Refinement, B>, orFailWith: (a: EqualsWith, Exclude, B>>) => E2): (self: Effect) => Effect, E2 | E, R>; + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (predicate: Predicate>, orFailWith: (a: NoInfer) => E2): (self: Effect) => Effect; + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, refinement: Refinement, orFailWith: (a: EqualsWith>) => E2): Effect, E2 | E, R>; + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, predicate: Predicate, orFailWith: (a: A) => E2): Effect; + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (refinement: Refinement, B>): (self: Effect) => Effect, Cause.NoSuchElementException | E, R>; + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (predicate: Predicate>): (self: Effect) => Effect; + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, refinement: Refinement): Effect, E | Cause.NoSuchElementException, R>; + /** + * Filters an effect, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Providing a Guard** + * + * In addition to the filtering capabilities discussed earlier, you have the + * option to further refine and narrow down the type of the success channel by + * providing a [user-defined type + * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates). + * Let's explore this concept through an example: + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterOrFail with a custom type guard to ensure user is not null + * Effect.filterOrFail( + * (user): user is User => user !== null, // Type guard + * () => new Error("Unauthorized") + * ), + * // 'user' now has the type `User` (not `User | null`) + * Effect.andThen((user) => user.name) + * ) + * ``` + * + * @since 2.0.0 + * @category Filtering + */ + (self: Effect, predicate: Predicate): Effect; +}; +/** + * Filters an effect with an effectful predicate, falling back to an alternative + * effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect falls back to the `orElse` + * effect. The `orElse` effect can produce an alternative value or perform + * additional computations. + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterEffectOrElse with an effectful predicate + * Effect.filterEffectOrElse({ + * predicate: (user) => Effect.succeed(user !== null), + * orElse: (user) => Effect.fail(new Error(`Unauthorized user: ${user}`)) + * }), + * ) + * ``` + * + * @since 3.13.0 + * @category Filtering + */ +export declare const filterEffectOrElse: { + /** + * Filters an effect with an effectful predicate, falling back to an alternative + * effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect falls back to the `orElse` + * effect. The `orElse` effect can produce an alternative value or perform + * additional computations. + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterEffectOrElse with an effectful predicate + * Effect.filterEffectOrElse({ + * predicate: (user) => Effect.succeed(user !== null), + * orElse: (user) => Effect.fail(new Error(`Unauthorized user: ${user}`)) + * }), + * ) + * ``` + * + * @since 3.13.0 + * @category Filtering + */ + (options: { + readonly predicate: (a: NoInfer) => Effect; + readonly orElse: (a: NoInfer) => Effect; + }): (self: Effect) => Effect; + /** + * Filters an effect with an effectful predicate, falling back to an alternative + * effect if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect falls back to the `orElse` + * effect. The `orElse` effect can produce an alternative value or perform + * additional computations. + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterEffectOrElse with an effectful predicate + * Effect.filterEffectOrElse({ + * predicate: (user) => Effect.succeed(user !== null), + * orElse: (user) => Effect.fail(new Error(`Unauthorized user: ${user}`)) + * }), + * ) + * ``` + * + * @since 3.13.0 + * @category Filtering + */ + (self: Effect, options: { + readonly predicate: (a: A) => Effect; + readonly orElse: (a: A) => Effect; + }): Effect; +}; +/** + * Filters an effect with an effectful predicate, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterEffectOrFail with an effectful predicate + * Effect.filterEffectOrFail({ + * predicate: (user) => Effect.succeed(user !== null), + * orFailWith: () => new Error("Unauthorized") + * }), + * ) + * ``` + * + * @since 3.13.0 + * @category Filtering + */ +export declare const filterEffectOrFail: { + /** + * Filters an effect with an effectful predicate, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterEffectOrFail with an effectful predicate + * Effect.filterEffectOrFail({ + * predicate: (user) => Effect.succeed(user !== null), + * orFailWith: () => new Error("Unauthorized") + * }), + * ) + * ``` + * + * @since 3.13.0 + * @category Filtering + */ + (options: { + readonly predicate: (a: NoInfer) => Effect; + readonly orFailWith: (a: NoInfer) => E3; + }): (self: Effect) => Effect; + /** + * Filters an effect with an effectful predicate, failing with a custom error if the predicate fails. + * + * **Details** + * + * This function applies a predicate to the result of an effect. If the + * predicate evaluates to `false`, the effect fails with a custom error + * generated by the `orFailWith` function. + * + * **When to Use** + * + * This is useful for enforcing constraints and treating violations as + * recoverable errors. + * + * **Example** + * + * ```ts + * import { Effect, pipe } from "effect" + * + * // Define a user interface + * interface User { + * readonly name: string + * } + * + * // Simulate an asynchronous authentication function + * declare const auth: () => Promise + * + * const program = pipe( + * Effect.promise(() => auth()), + * // Use filterEffectOrFail with an effectful predicate + * Effect.filterEffectOrFail({ + * predicate: (user) => Effect.succeed(user !== null), + * orFailWith: () => new Error("Unauthorized") + * }), + * ) + * ``` + * + * @since 3.13.0 + * @category Filtering + */ + (self: Effect, options: { + readonly predicate: (a: A) => Effect; + readonly orFailWith: (a: A) => E3; + }): Effect; +}; +/** + * Executes an effect only if the condition is `false`. + * + * @see {@link unlessEffect} for a version that allows the condition to be an effect. + * @see {@link when} for a version that executes the effect when the condition is `true`. + * + * @since 2.0.0 + * @category Conditional Operators + */ +export declare const unless: { + /** + * Executes an effect only if the condition is `false`. + * + * @see {@link unlessEffect} for a version that allows the condition to be an effect. + * @see {@link when} for a version that executes the effect when the condition is `true`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (condition: LazyArg): (self: Effect) => Effect, E, R>; + /** + * Executes an effect only if the condition is `false`. + * + * @see {@link unlessEffect} for a version that allows the condition to be an effect. + * @see {@link when} for a version that executes the effect when the condition is `true`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (self: Effect, condition: LazyArg): Effect, E, R>; +}; +/** + * Conditionally execute an effect based on the result of another effect. + * + * @see {@link unless} for a version that allows the condition to be a boolean. + * @see {@link whenEffect} for a version that executes the effect when the condition is `true`. + * + * @since 2.0.0 + * @category Conditional Operators + */ +export declare const unlessEffect: { + /** + * Conditionally execute an effect based on the result of another effect. + * + * @see {@link unless} for a version that allows the condition to be a boolean. + * @see {@link whenEffect} for a version that executes the effect when the condition is `true`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (condition: Effect): (self: Effect) => Effect, E2 | E, R2 | R>; + /** + * Conditionally execute an effect based on the result of another effect. + * + * @see {@link unless} for a version that allows the condition to be a boolean. + * @see {@link whenEffect} for a version that executes the effect when the condition is `true`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (self: Effect, condition: Effect): Effect, E | E2, R | R2>; +}; +/** + * Conditionally executes an effect based on a boolean condition. + * + * **Details** + * + * This function allows you to run an effect only if a given condition evaluates + * to `true`. If the condition is `true`, the effect is executed, and its result + * is wrapped in an `Option.some`. If the condition is `false`, the effect is + * skipped, and the result is `Option.none`. + * + * **When to Use** + * + * This function is useful for scenarios where you need to dynamically decide + * whether to execute an effect based on runtime logic, while also representing + * the skipped case explicitly. + * + * **Example** (Conditional Effect Execution) + * + * ```ts + * import { Effect, Option } from "effect" + * + * const validateWeightOption = ( + * weight: number + * ): Effect.Effect> => + * // Conditionally execute the effect if the weight is non-negative + * Effect.succeed(weight).pipe(Effect.when(() => weight >= 0)) + * + * // Run with a valid weight + * Effect.runPromise(validateWeightOption(100)).then(console.log) + * // Output: + * // { + * // _id: "Option", + * // _tag: "Some", + * // value: 100 + * // } + * + * // Run with an invalid weight + * Effect.runPromise(validateWeightOption(-5)).then(console.log) + * // Output: + * // { + * // _id: "Option", + * // _tag: "None" + * // } + * ``` + * + * @see {@link whenEffect} for a version that allows the condition to be an effect. + * @see {@link unless} for a version that executes the effect when the condition is `false`. + * + * @since 2.0.0 + * @category Conditional Operators + */ +export declare const when: { + /** + * Conditionally executes an effect based on a boolean condition. + * + * **Details** + * + * This function allows you to run an effect only if a given condition evaluates + * to `true`. If the condition is `true`, the effect is executed, and its result + * is wrapped in an `Option.some`. If the condition is `false`, the effect is + * skipped, and the result is `Option.none`. + * + * **When to Use** + * + * This function is useful for scenarios where you need to dynamically decide + * whether to execute an effect based on runtime logic, while also representing + * the skipped case explicitly. + * + * **Example** (Conditional Effect Execution) + * + * ```ts + * import { Effect, Option } from "effect" + * + * const validateWeightOption = ( + * weight: number + * ): Effect.Effect> => + * // Conditionally execute the effect if the weight is non-negative + * Effect.succeed(weight).pipe(Effect.when(() => weight >= 0)) + * + * // Run with a valid weight + * Effect.runPromise(validateWeightOption(100)).then(console.log) + * // Output: + * // { + * // _id: "Option", + * // _tag: "Some", + * // value: 100 + * // } + * + * // Run with an invalid weight + * Effect.runPromise(validateWeightOption(-5)).then(console.log) + * // Output: + * // { + * // _id: "Option", + * // _tag: "None" + * // } + * ``` + * + * @see {@link whenEffect} for a version that allows the condition to be an effect. + * @see {@link unless} for a version that executes the effect when the condition is `false`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (condition: LazyArg): (self: Effect) => Effect, E, R>; + /** + * Conditionally executes an effect based on a boolean condition. + * + * **Details** + * + * This function allows you to run an effect only if a given condition evaluates + * to `true`. If the condition is `true`, the effect is executed, and its result + * is wrapped in an `Option.some`. If the condition is `false`, the effect is + * skipped, and the result is `Option.none`. + * + * **When to Use** + * + * This function is useful for scenarios where you need to dynamically decide + * whether to execute an effect based on runtime logic, while also representing + * the skipped case explicitly. + * + * **Example** (Conditional Effect Execution) + * + * ```ts + * import { Effect, Option } from "effect" + * + * const validateWeightOption = ( + * weight: number + * ): Effect.Effect> => + * // Conditionally execute the effect if the weight is non-negative + * Effect.succeed(weight).pipe(Effect.when(() => weight >= 0)) + * + * // Run with a valid weight + * Effect.runPromise(validateWeightOption(100)).then(console.log) + * // Output: + * // { + * // _id: "Option", + * // _tag: "Some", + * // value: 100 + * // } + * + * // Run with an invalid weight + * Effect.runPromise(validateWeightOption(-5)).then(console.log) + * // Output: + * // { + * // _id: "Option", + * // _tag: "None" + * // } + * ``` + * + * @see {@link whenEffect} for a version that allows the condition to be an effect. + * @see {@link unless} for a version that executes the effect when the condition is `false`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (self: Effect, condition: LazyArg): Effect, E, R>; +}; +/** + * Conditionally executes an effect based on the result of another effect. + * + * **Details** + * + * This function allows you to run an effect only if a conditional effect + * evaluating to a boolean resolves to `true`. If the conditional effect + * evaluates to `true`, the specified effect is executed, and its result is + * wrapped in `Option.some`. If the conditional effect evaluates to `false`, the + * effect is skipped, and the result is `Option.none`. + * + * **When to Use** + * + * This function is particularly useful when the decision to execute an effect + * depends on the result of another effect, such as a random value, a + * user-provided input, or a network request result. + * + * **Example** (Using an Effect as a Condition) + * + * ```ts + * import { Effect, Random } from "effect" + * + * const randomIntOption = Random.nextInt.pipe( + * Effect.whenEffect(Random.nextBoolean) + * ) + * + * console.log(Effect.runSync(randomIntOption)) + * // Example Output: + * // { _id: 'Option', _tag: 'Some', value: 8609104974198840 } + * ``` + * + * @see {@link when} for a version that allows the condition to be a boolean. + * @see {@link unlessEffect} for a version that executes the effect when the condition is `false`. + * + * @since 2.0.0 + * @category Conditional Operators + */ +export declare const whenEffect: { + /** + * Conditionally executes an effect based on the result of another effect. + * + * **Details** + * + * This function allows you to run an effect only if a conditional effect + * evaluating to a boolean resolves to `true`. If the conditional effect + * evaluates to `true`, the specified effect is executed, and its result is + * wrapped in `Option.some`. If the conditional effect evaluates to `false`, the + * effect is skipped, and the result is `Option.none`. + * + * **When to Use** + * + * This function is particularly useful when the decision to execute an effect + * depends on the result of another effect, such as a random value, a + * user-provided input, or a network request result. + * + * **Example** (Using an Effect as a Condition) + * + * ```ts + * import { Effect, Random } from "effect" + * + * const randomIntOption = Random.nextInt.pipe( + * Effect.whenEffect(Random.nextBoolean) + * ) + * + * console.log(Effect.runSync(randomIntOption)) + * // Example Output: + * // { _id: 'Option', _tag: 'Some', value: 8609104974198840 } + * ``` + * + * @see {@link when} for a version that allows the condition to be a boolean. + * @see {@link unlessEffect} for a version that executes the effect when the condition is `false`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (condition: Effect): (effect: Effect) => Effect, E | E2, R | R2>; + /** + * Conditionally executes an effect based on the result of another effect. + * + * **Details** + * + * This function allows you to run an effect only if a conditional effect + * evaluating to a boolean resolves to `true`. If the conditional effect + * evaluates to `true`, the specified effect is executed, and its result is + * wrapped in `Option.some`. If the conditional effect evaluates to `false`, the + * effect is skipped, and the result is `Option.none`. + * + * **When to Use** + * + * This function is particularly useful when the decision to execute an effect + * depends on the result of another effect, such as a random value, a + * user-provided input, or a network request result. + * + * **Example** (Using an Effect as a Condition) + * + * ```ts + * import { Effect, Random } from "effect" + * + * const randomIntOption = Random.nextInt.pipe( + * Effect.whenEffect(Random.nextBoolean) + * ) + * + * console.log(Effect.runSync(randomIntOption)) + * // Example Output: + * // { _id: 'Option', _tag: 'Some', value: 8609104974198840 } + * ``` + * + * @see {@link when} for a version that allows the condition to be a boolean. + * @see {@link unlessEffect} for a version that executes the effect when the condition is `false`. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (self: Effect, condition: Effect): Effect, E2 | E, R2 | R>; +}; +/** + * Executes an effect conditionally based on the value of a `FiberRef` that + * satisfies a predicate. + * + * **Details** + * + * This function enables you to execute an effect only when the value of a + * specified `FiberRef` meets a certain condition defined by a predicate. If the + * value satisfies the predicate, the effect is executed, and the result is + * wrapped in an `Option.some`. If the predicate is not satisfied, the effect is + * skipped, and the result is `Option.none`. In both cases, the current value of + * the `FiberRef` is included in the result. + * + * @since 2.0.0 + * @category Conditional Operators + */ +export declare const whenFiberRef: { + /** + * Executes an effect conditionally based on the value of a `FiberRef` that + * satisfies a predicate. + * + * **Details** + * + * This function enables you to execute an effect only when the value of a + * specified `FiberRef` meets a certain condition defined by a predicate. If the + * value satisfies the predicate, the effect is executed, and the result is + * wrapped in an `Option.some`. If the predicate is not satisfied, the effect is + * skipped, and the result is `Option.none`. In both cases, the current value of + * the `FiberRef` is included in the result. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (fiberRef: FiberRef.FiberRef, predicate: Predicate): (self: Effect) => Effect<[S, Option.Option], E, R>; + /** + * Executes an effect conditionally based on the value of a `FiberRef` that + * satisfies a predicate. + * + * **Details** + * + * This function enables you to execute an effect only when the value of a + * specified `FiberRef` meets a certain condition defined by a predicate. If the + * value satisfies the predicate, the effect is executed, and the result is + * wrapped in an `Option.some`. If the predicate is not satisfied, the effect is + * skipped, and the result is `Option.none`. In both cases, the current value of + * the `FiberRef` is included in the result. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (self: Effect, fiberRef: FiberRef.FiberRef, predicate: Predicate): Effect<[S, Option.Option], E, R>; +}; +/** + * Executes an effect conditionally based on the value of a `Ref` that satisfies + * a predicate. + * + * **Details** + * + * This function allows you to execute an effect only when the value of a + * specified `Ref` meets a condition defined by a predicate. If the value + * satisfies the predicate, the effect is executed, and the result is wrapped in + * an `Option.some`. If the predicate is not satisfied, the effect is skipped, + * and the result is `Option.none`. In both cases, the current value of the + * `Ref` is included in the result. + * + * @since 2.0.0 + * @category Conditional Operators + */ +export declare const whenRef: { + /** + * Executes an effect conditionally based on the value of a `Ref` that satisfies + * a predicate. + * + * **Details** + * + * This function allows you to execute an effect only when the value of a + * specified `Ref` meets a condition defined by a predicate. If the value + * satisfies the predicate, the effect is executed, and the result is wrapped in + * an `Option.some`. If the predicate is not satisfied, the effect is skipped, + * and the result is `Option.none`. In both cases, the current value of the + * `Ref` is included in the result. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (ref: Ref.Ref, predicate: Predicate): (self: Effect) => Effect<[S, Option.Option], E, R>; + /** + * Executes an effect conditionally based on the value of a `Ref` that satisfies + * a predicate. + * + * **Details** + * + * This function allows you to execute an effect only when the value of a + * specified `Ref` meets a condition defined by a predicate. If the value + * satisfies the predicate, the effect is executed, and the result is wrapped in + * an `Option.some`. If the predicate is not satisfied, the effect is skipped, + * and the result is `Option.none`. In both cases, the current value of the + * `Ref` is included in the result. + * + * @since 2.0.0 + * @category Conditional Operators + */ + (self: Effect, ref: Ref.Ref, predicate: Predicate): Effect<[S, Option.Option], E, R>; +}; +/** + * Chains effects to produce new `Effect` instances, useful for combining + * operations that depend on previous results. + * + * **Syntax** + * + * ```ts skip-type-checking + * const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation)) + * // or + * const flatMappedEffect = Effect.flatMap(myEffect, transformation) + * // or + * const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation)) + * ``` + * + * **Details** + * + * `flatMap` lets you sequence effects so that the result of one effect can be + * used in the next step. It is similar to `flatMap` used with arrays but works + * specifically with `Effect` instances, allowing you to avoid deeply nested + * effect structures. + * + * Since effects are immutable, `flatMap` always returns a new effect instead of + * changing the original one. + * + * **When to Use** + * + * Use `flatMap` when you need to chain multiple effects, ensuring that each + * step produces a new `Effect` while flattening any nested effects that may + * occur. + * + * **Example** + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Chaining the fetch and discount application using `flatMap` + * const finalAmount = pipe( + * fetchTransactionAmount, + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: 95 + * ``` + * + * @see {@link tap} for a version that ignores the result of the effect. + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const flatMap: { + /** + * Chains effects to produce new `Effect` instances, useful for combining + * operations that depend on previous results. + * + * **Syntax** + * + * ```ts skip-type-checking + * const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation)) + * // or + * const flatMappedEffect = Effect.flatMap(myEffect, transformation) + * // or + * const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation)) + * ``` + * + * **Details** + * + * `flatMap` lets you sequence effects so that the result of one effect can be + * used in the next step. It is similar to `flatMap` used with arrays but works + * specifically with `Effect` instances, allowing you to avoid deeply nested + * effect structures. + * + * Since effects are immutable, `flatMap` always returns a new effect instead of + * changing the original one. + * + * **When to Use** + * + * Use `flatMap` when you need to chain multiple effects, ensuring that each + * step produces a new `Effect` while flattening any nested effects that may + * occur. + * + * **Example** + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Chaining the fetch and discount application using `flatMap` + * const finalAmount = pipe( + * fetchTransactionAmount, + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: 95 + * ``` + * + * @see {@link tap} for a version that ignores the result of the effect. + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (a: A) => Effect): (self: Effect) => Effect; + /** + * Chains effects to produce new `Effect` instances, useful for combining + * operations that depend on previous results. + * + * **Syntax** + * + * ```ts skip-type-checking + * const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation)) + * // or + * const flatMappedEffect = Effect.flatMap(myEffect, transformation) + * // or + * const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation)) + * ``` + * + * **Details** + * + * `flatMap` lets you sequence effects so that the result of one effect can be + * used in the next step. It is similar to `flatMap` used with arrays but works + * specifically with `Effect` instances, allowing you to avoid deeply nested + * effect structures. + * + * Since effects are immutable, `flatMap` always returns a new effect instead of + * changing the original one. + * + * **When to Use** + * + * Use `flatMap` when you need to chain multiple effects, ensuring that each + * step produces a new `Effect` while flattening any nested effects that may + * occur. + * + * **Example** + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Chaining the fetch and discount application using `flatMap` + * const finalAmount = pipe( + * fetchTransactionAmount, + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: 95 + * ``` + * + * @see {@link tap} for a version that ignores the result of the effect. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: (a: A) => Effect): Effect; +}; +/** + * Chains two actions, where the second action can depend on the result of the + * first. + * + * **Syntax** + * + * ```ts skip-type-checking + * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect)) + * // or + * const transformedEffect = Effect.andThen(myEffect, anotherEffect) + * // or + * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect)) + * ``` + * + * **When to Use** + * + * Use `andThen` when you need to run multiple actions in sequence, with the + * second action depending on the result of the first. This is useful for + * combining effects or handling computations that must happen in order. + * + * **Details** + * + * The second action can be: + * + * - A constant value (similar to {@link as}) + * - A function returning a value (similar to {@link map}) + * - A `Promise` + * - A function returning a `Promise` + * - An `Effect` + * - A function returning an `Effect` (similar to {@link flatMap}) + * + * **Note:** `andThen` works well with both `Option` and `Either` types, + * treating them as effects. + * + * **Example** (Applying a Discount Based on Fetched Amount) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Using Effect.map and Effect.flatMap + * const result1 = pipe( + * fetchTransactionAmount, + * Effect.map((amount) => amount * 2), + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result1).then(console.log) + * // Output: 190 + * + * // Using Effect.andThen + * const result2 = pipe( + * fetchTransactionAmount, + * Effect.andThen((amount) => amount * 2), + * Effect.andThen((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result2).then(console.log) + * // Output: 190 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const andThen: { + /** + * Chains two actions, where the second action can depend on the result of the + * first. + * + * **Syntax** + * + * ```ts skip-type-checking + * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect)) + * // or + * const transformedEffect = Effect.andThen(myEffect, anotherEffect) + * // or + * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect)) + * ``` + * + * **When to Use** + * + * Use `andThen` when you need to run multiple actions in sequence, with the + * second action depending on the result of the first. This is useful for + * combining effects or handling computations that must happen in order. + * + * **Details** + * + * The second action can be: + * + * - A constant value (similar to {@link as}) + * - A function returning a value (similar to {@link map}) + * - A `Promise` + * - A function returning a `Promise` + * - An `Effect` + * - A function returning an `Effect` (similar to {@link flatMap}) + * + * **Note:** `andThen` works well with both `Option` and `Either` types, + * treating them as effects. + * + * **Example** (Applying a Discount Based on Fetched Amount) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Using Effect.map and Effect.flatMap + * const result1 = pipe( + * fetchTransactionAmount, + * Effect.map((amount) => amount * 2), + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result1).then(console.log) + * // Output: 190 + * + * // Using Effect.andThen + * const result2 = pipe( + * fetchTransactionAmount, + * Effect.andThen((amount) => amount * 2), + * Effect.andThen((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result2).then(console.log) + * // Output: 190 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (a: NoInfer) => X): (self: Effect) => [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + /** + * Chains two actions, where the second action can depend on the result of the + * first. + * + * **Syntax** + * + * ```ts skip-type-checking + * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect)) + * // or + * const transformedEffect = Effect.andThen(myEffect, anotherEffect) + * // or + * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect)) + * ``` + * + * **When to Use** + * + * Use `andThen` when you need to run multiple actions in sequence, with the + * second action depending on the result of the first. This is useful for + * combining effects or handling computations that must happen in order. + * + * **Details** + * + * The second action can be: + * + * - A constant value (similar to {@link as}) + * - A function returning a value (similar to {@link map}) + * - A `Promise` + * - A function returning a `Promise` + * - An `Effect` + * - A function returning an `Effect` (similar to {@link flatMap}) + * + * **Note:** `andThen` works well with both `Option` and `Either` types, + * treating them as effects. + * + * **Example** (Applying a Discount Based on Fetched Amount) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Using Effect.map and Effect.flatMap + * const result1 = pipe( + * fetchTransactionAmount, + * Effect.map((amount) => amount * 2), + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result1).then(console.log) + * // Output: 190 + * + * // Using Effect.andThen + * const result2 = pipe( + * fetchTransactionAmount, + * Effect.andThen((amount) => amount * 2), + * Effect.andThen((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result2).then(console.log) + * // Output: 190 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (f: NotFunction): (self: Effect) => [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + /** + * Chains two actions, where the second action can depend on the result of the + * first. + * + * **Syntax** + * + * ```ts skip-type-checking + * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect)) + * // or + * const transformedEffect = Effect.andThen(myEffect, anotherEffect) + * // or + * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect)) + * ``` + * + * **When to Use** + * + * Use `andThen` when you need to run multiple actions in sequence, with the + * second action depending on the result of the first. This is useful for + * combining effects or handling computations that must happen in order. + * + * **Details** + * + * The second action can be: + * + * - A constant value (similar to {@link as}) + * - A function returning a value (similar to {@link map}) + * - A `Promise` + * - A function returning a `Promise` + * - An `Effect` + * - A function returning an `Effect` (similar to {@link flatMap}) + * + * **Note:** `andThen` works well with both `Option` and `Either` types, + * treating them as effects. + * + * **Example** (Applying a Discount Based on Fetched Amount) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Using Effect.map and Effect.flatMap + * const result1 = pipe( + * fetchTransactionAmount, + * Effect.map((amount) => amount * 2), + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result1).then(console.log) + * // Output: 190 + * + * // Using Effect.andThen + * const result2 = pipe( + * fetchTransactionAmount, + * Effect.andThen((amount) => amount * 2), + * Effect.andThen((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result2).then(console.log) + * // Output: 190 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: (a: NoInfer) => X): [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + /** + * Chains two actions, where the second action can depend on the result of the + * first. + * + * **Syntax** + * + * ```ts skip-type-checking + * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect)) + * // or + * const transformedEffect = Effect.andThen(myEffect, anotherEffect) + * // or + * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect)) + * ``` + * + * **When to Use** + * + * Use `andThen` when you need to run multiple actions in sequence, with the + * second action depending on the result of the first. This is useful for + * combining effects or handling computations that must happen in order. + * + * **Details** + * + * The second action can be: + * + * - A constant value (similar to {@link as}) + * - A function returning a value (similar to {@link map}) + * - A `Promise` + * - A function returning a `Promise` + * - An `Effect` + * - A function returning an `Effect` (similar to {@link flatMap}) + * + * **Note:** `andThen` works well with both `Option` and `Either` types, + * treating them as effects. + * + * **Example** (Applying a Discount Based on Fetched Amount) + * + * ```ts + * import { pipe, Effect } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * // Using Effect.map and Effect.flatMap + * const result1 = pipe( + * fetchTransactionAmount, + * Effect.map((amount) => amount * 2), + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result1).then(console.log) + * // Output: 190 + * + * // Using Effect.andThen + * const result2 = pipe( + * fetchTransactionAmount, + * Effect.andThen((amount) => amount * 2), + * Effect.andThen((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(result2).then(console.log) + * // Output: 190 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: NotFunction): [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; +}; +/** + * @since 2.0.0 + * @category Sequencing + */ +export declare const flatten: (self: Effect, E, R>) => Effect; +/** + * Races two effects and returns the result of the first successful one. + * + * **Details** + * + * This function takes two effects and runs them concurrently. The first effect + * that successfully completes will determine the result of the race, and the + * other effect will be interrupted. + * + * If neither effect succeeds, the function will fail with a `Cause` + * containing all the errors. + * + * **When to Use** + * + * This is useful when you want to run two effects concurrently, but only care + * about the first one to succeed. It is commonly used in cases like timeouts, + * retries, or when you want to optimize for the faster response without + * worrying about the other effect. + * + * **Handling Success or Failure with Either** + * + * If you want to handle the result of whichever task completes first, whether + * it succeeds or fails, you can use the `Effect.either` function. This function + * wraps the result in an `Either` type, allowing you to see if the result + * was a success (`Right`) or a failure (`Left`). + * + * **Example** (Both Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runFork(program) + * // Output: + * // task1 done + * // task2 interrupted + * ``` + * + * **Example** (One Task Fails, One Succeeds) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runFork(program) + * // Output: + * // task2 done + * ``` + * + * **Example** (Both Tasks Fail) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.fail("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Parallel', + * // left: { _id: 'Cause', _tag: 'Fail', failure: 'task1' }, + * // right: { _id: 'Cause', _tag: 'Fail', failure: 'task2' } + * // } + * // } + * ``` + * + * **Example** (Handling Success or Failure with Either) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * // Run both tasks concurrently, wrapping the result + * // in Either to capture success or failure + * const program = Effect.race(Effect.either(task1), Effect.either(task2)) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // task2 interrupted + * // { _id: 'Either', _tag: 'Left', left: 'task1' } + * ``` + * + * @see {@link raceAll} for a version that handles multiple effects. + * @see {@link raceFirst} for a version that returns the result of the first effect to complete. + * + * @since 2.0.0 + * @category Racing + */ +export declare const race: { + /** + * Races two effects and returns the result of the first successful one. + * + * **Details** + * + * This function takes two effects and runs them concurrently. The first effect + * that successfully completes will determine the result of the race, and the + * other effect will be interrupted. + * + * If neither effect succeeds, the function will fail with a `Cause` + * containing all the errors. + * + * **When to Use** + * + * This is useful when you want to run two effects concurrently, but only care + * about the first one to succeed. It is commonly used in cases like timeouts, + * retries, or when you want to optimize for the faster response without + * worrying about the other effect. + * + * **Handling Success or Failure with Either** + * + * If you want to handle the result of whichever task completes first, whether + * it succeeds or fails, you can use the `Effect.either` function. This function + * wraps the result in an `Either` type, allowing you to see if the result + * was a success (`Right`) or a failure (`Left`). + * + * **Example** (Both Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runFork(program) + * // Output: + * // task1 done + * // task2 interrupted + * ``` + * + * **Example** (One Task Fails, One Succeeds) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runFork(program) + * // Output: + * // task2 done + * ``` + * + * **Example** (Both Tasks Fail) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.fail("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Parallel', + * // left: { _id: 'Cause', _tag: 'Fail', failure: 'task1' }, + * // right: { _id: 'Cause', _tag: 'Fail', failure: 'task2' } + * // } + * // } + * ``` + * + * **Example** (Handling Success or Failure with Either) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * // Run both tasks concurrently, wrapping the result + * // in Either to capture success or failure + * const program = Effect.race(Effect.either(task1), Effect.either(task2)) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // task2 interrupted + * // { _id: 'Either', _tag: 'Left', left: 'task1' } + * ``` + * + * @see {@link raceAll} for a version that handles multiple effects. + * @see {@link raceFirst} for a version that returns the result of the first effect to complete. + * + * @since 2.0.0 + * @category Racing + */ + (that: Effect): (self: Effect) => Effect; + /** + * Races two effects and returns the result of the first successful one. + * + * **Details** + * + * This function takes two effects and runs them concurrently. The first effect + * that successfully completes will determine the result of the race, and the + * other effect will be interrupted. + * + * If neither effect succeeds, the function will fail with a `Cause` + * containing all the errors. + * + * **When to Use** + * + * This is useful when you want to run two effects concurrently, but only care + * about the first one to succeed. It is commonly used in cases like timeouts, + * retries, or when you want to optimize for the faster response without + * worrying about the other effect. + * + * **Handling Success or Failure with Either** + * + * If you want to handle the result of whichever task completes first, whether + * it succeeds or fails, you can use the `Effect.either` function. This function + * wraps the result in an `Either` type, allowing you to see if the result + * was a success (`Right`) or a failure (`Left`). + * + * **Example** (Both Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runFork(program) + * // Output: + * // task1 done + * // task2 interrupted + * ``` + * + * **Example** (One Task Fails, One Succeeds) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runFork(program) + * // Output: + * // task2 done + * ``` + * + * **Example** (Both Tasks Fail) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.fail("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const program = Effect.race(task1, task2) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Parallel', + * // left: { _id: 'Cause', _tag: 'Fail', failure: 'task1' }, + * // right: { _id: 'Cause', _tag: 'Fail', failure: 'task2' } + * // } + * // } + * ``` + * + * **Example** (Handling Success or Failure with Either) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * // Run both tasks concurrently, wrapping the result + * // in Either to capture success or failure + * const program = Effect.race(Effect.either(task1), Effect.either(task2)) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // task2 interrupted + * // { _id: 'Either', _tag: 'Left', left: 'task1' } + * ``` + * + * @see {@link raceAll} for a version that handles multiple effects. + * @see {@link raceFirst} for a version that returns the result of the first effect to complete. + * + * @since 2.0.0 + * @category Racing + */ + (self: Effect, that: Effect): Effect; +}; +/** + * Races multiple effects and returns the first successful result. + * + * **Details** + * + * This function runs multiple effects concurrently and returns the result of + * the first one to succeed. If one effect succeeds, the others will be + * interrupted. + * + * If none of the effects succeed, the function will fail with the last error + * encountered. + * + * **When to Use** + * + * This is useful when you want to race multiple effects, but only care about + * the first one to succeed. It is commonly used in cases like timeouts, + * retries, or when you want to optimize for the faster response without + * worrying about the other effects. + * + * **Example** (All Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const task3 = Effect.succeed("task3").pipe( + * Effect.delay("150 millis"), + * Effect.tap(Console.log("task3 done")), + * Effect.onInterrupt(() => Console.log("task3 interrupted")) + * ) + * + * const program = Effect.raceAll([task1, task2, task3]) + * + * Effect.runFork(program) + * // Output: + * // task1 done + * // task2 interrupted + * // task3 interrupted + * ``` + * + * **Example** (One Task Fails, Two Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const task3 = Effect.succeed("task3").pipe( + * Effect.delay("150 millis"), + * Effect.tap(Console.log("task3 done")), + * Effect.onInterrupt(() => Console.log("task3 interrupted")) + * ) + * + * const program = Effect.raceAll([task1, task2, task3]) + * + * Effect.runFork(program) + * // Output: + * // task3 done + * // task2 interrupted + * ``` + * + * **Example** (All Tasks Fail) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => Console.log("task1 interrupted")) + * ) + * const task2 = Effect.fail("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => Console.log("task2 interrupted")) + * ) + * + * const task3 = Effect.fail("task3").pipe( + * Effect.delay("150 millis"), + * Effect.tap(Console.log("task3 done")), + * Effect.onInterrupt(() => Console.log("task3 interrupted")) + * ) + * + * const program = Effect.raceAll([task1, task2, task3]) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'task2' } + * // } + * ``` + * + * @see {@link race} for a version that handles only two effects. + * + * @since 2.0.0 + * @category Racing + */ +export declare const raceAll: >(all: Iterable) => Effect, Effect.Error, Effect.Context>; +/** + * Races two effects and returns the result of the first one to complete. + * + * **Details** + * + * This function takes two effects and runs them concurrently, returning the + * result of the first one that completes, regardless of whether it succeeds or + * fails. + * + * **When to Use** + * + * This function is useful when you want to race two operations, and you want to + * proceed with whichever one finishes first, regardless of whether it succeeds + * or fails. + * + * **Disconnecting Effects** + * + * The `Effect.raceFirst` function safely interrupts the “loser” effect once the other completes, but it will not resume until the loser is cleanly terminated. + * + * If you want a quicker return, you can disconnect the interrupt signal for both effects. Instead of calling: + * + * ```ts skip-type-checking + * Effect.raceFirst(task1, task2) + * ``` + * + * You can use: + * + * ```ts skip-type-checking + * Effect.raceFirst(Effect.disconnect(task1), Effect.disconnect(task2)) + * ``` + * + * This allows both effects to complete independently while still terminating the losing effect in the background. + * + * **Example** (Both Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceFirst(task1, task2).pipe( + * Effect.tap(Console.log("more work...")) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 done + * // task2 interrupted + * // more work... + * // { _id: 'Exit', _tag: 'Success', value: 'task1' } + * ``` + * + * **Example** (One Task Fails, One Succeeds) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceFirst(task1, task2).pipe( + * Effect.tap(Console.log("more work...")) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task2 interrupted + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'task1' } + * // } + * ``` + * + * **Example** (Using Effect.disconnect for Quicker Return) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * // Race the two tasks with disconnect to allow quicker return + * const program = Effect.raceFirst( + * Effect.disconnect(task1), + * Effect.disconnect(task2) + * ).pipe(Effect.tap(Console.log("more work..."))) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 done + * // more work... + * // { _id: 'Exit', _tag: 'Success', value: 'task1' } + * // task2 interrupted + * ``` + * + * @since 2.0.0 + * @category Racing + */ +export declare const raceFirst: { + /** + * Races two effects and returns the result of the first one to complete. + * + * **Details** + * + * This function takes two effects and runs them concurrently, returning the + * result of the first one that completes, regardless of whether it succeeds or + * fails. + * + * **When to Use** + * + * This function is useful when you want to race two operations, and you want to + * proceed with whichever one finishes first, regardless of whether it succeeds + * or fails. + * + * **Disconnecting Effects** + * + * The `Effect.raceFirst` function safely interrupts the “loser” effect once the other completes, but it will not resume until the loser is cleanly terminated. + * + * If you want a quicker return, you can disconnect the interrupt signal for both effects. Instead of calling: + * + * ```ts skip-type-checking + * Effect.raceFirst(task1, task2) + * ``` + * + * You can use: + * + * ```ts skip-type-checking + * Effect.raceFirst(Effect.disconnect(task1), Effect.disconnect(task2)) + * ``` + * + * This allows both effects to complete independently while still terminating the losing effect in the background. + * + * **Example** (Both Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceFirst(task1, task2).pipe( + * Effect.tap(Console.log("more work...")) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 done + * // task2 interrupted + * // more work... + * // { _id: 'Exit', _tag: 'Success', value: 'task1' } + * ``` + * + * **Example** (One Task Fails, One Succeeds) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceFirst(task1, task2).pipe( + * Effect.tap(Console.log("more work...")) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task2 interrupted + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'task1' } + * // } + * ``` + * + * **Example** (Using Effect.disconnect for Quicker Return) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * // Race the two tasks with disconnect to allow quicker return + * const program = Effect.raceFirst( + * Effect.disconnect(task1), + * Effect.disconnect(task2) + * ).pipe(Effect.tap(Console.log("more work..."))) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 done + * // more work... + * // { _id: 'Exit', _tag: 'Success', value: 'task1' } + * // task2 interrupted + * ``` + * + * @since 2.0.0 + * @category Racing + */ + (that: Effect): (self: Effect) => Effect; + /** + * Races two effects and returns the result of the first one to complete. + * + * **Details** + * + * This function takes two effects and runs them concurrently, returning the + * result of the first one that completes, regardless of whether it succeeds or + * fails. + * + * **When to Use** + * + * This function is useful when you want to race two operations, and you want to + * proceed with whichever one finishes first, regardless of whether it succeeds + * or fails. + * + * **Disconnecting Effects** + * + * The `Effect.raceFirst` function safely interrupts the “loser” effect once the other completes, but it will not resume until the loser is cleanly terminated. + * + * If you want a quicker return, you can disconnect the interrupt signal for both effects. Instead of calling: + * + * ```ts skip-type-checking + * Effect.raceFirst(task1, task2) + * ``` + * + * You can use: + * + * ```ts skip-type-checking + * Effect.raceFirst(Effect.disconnect(task1), Effect.disconnect(task2)) + * ``` + * + * This allows both effects to complete independently while still terminating the losing effect in the background. + * + * **Example** (Both Tasks Succeed) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceFirst(task1, task2).pipe( + * Effect.tap(Console.log("more work...")) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 done + * // task2 interrupted + * // more work... + * // { _id: 'Exit', _tag: 'Success', value: 'task1' } + * ``` + * + * **Example** (One Task Fails, One Succeeds) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.fail("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceFirst(task1, task2).pipe( + * Effect.tap(Console.log("more work...")) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task2 interrupted + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'task1' } + * // } + * ``` + * + * **Example** (Using Effect.disconnect for Quicker Return) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * // Race the two tasks with disconnect to allow quicker return + * const program = Effect.raceFirst( + * Effect.disconnect(task1), + * Effect.disconnect(task2) + * ).pipe(Effect.tap(Console.log("more work..."))) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 done + * // more work... + * // { _id: 'Exit', _tag: 'Success', value: 'task1' } + * // task2 interrupted + * ``` + * + * @since 2.0.0 + * @category Racing + */ + (self: Effect, that: Effect): Effect; +}; +/** + * Races two effects and calls a finisher when the first one completes. + * + * **Details** + * + * This function runs two effects concurrently and calls a specified “finisher” + * function once one of the effects completes, regardless of whether it succeeds + * or fails. + * + * The finisher functions for each effect allow you to handle the results of + * each effect as soon as they complete. + * + * The function takes two finisher callbacks, one for each effect, and allows + * you to specify how to handle the result of the race. + * + * **When to Use** + * + * This function is useful when you need to react to the completion of either + * effect without waiting for both to finish. It can be used whenever you want + * to take action based on the first available result. + * + * **Example** (Handling Results of Concurrent Tasks) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceWith(task1, task2, { + * onSelfDone: (exit) => Console.log(`task1 exited with ${exit}`), + * onOtherDone: (exit) => Console.log(`task2 exited with ${exit}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // task1 done + * // task1 exited with { + * // "_id": "Exit", + * // "_tag": "Success", + * // "value": "task1" + * // } + * // task2 interrupted + * ``` + * + * @since 2.0.0 + * @category Racing + */ +export declare const raceWith: { + /** + * Races two effects and calls a finisher when the first one completes. + * + * **Details** + * + * This function runs two effects concurrently and calls a specified “finisher” + * function once one of the effects completes, regardless of whether it succeeds + * or fails. + * + * The finisher functions for each effect allow you to handle the results of + * each effect as soon as they complete. + * + * The function takes two finisher callbacks, one for each effect, and allows + * you to specify how to handle the result of the race. + * + * **When to Use** + * + * This function is useful when you need to react to the completion of either + * effect without waiting for both to finish. It can be used whenever you want + * to take action based on the first available result. + * + * **Example** (Handling Results of Concurrent Tasks) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceWith(task1, task2, { + * onSelfDone: (exit) => Console.log(`task1 exited with ${exit}`), + * onOtherDone: (exit) => Console.log(`task2 exited with ${exit}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // task1 done + * // task1 exited with { + * // "_id": "Exit", + * // "_tag": "Success", + * // "value": "task1" + * // } + * // task2 interrupted + * ``` + * + * @since 2.0.0 + * @category Racing + */ + (other: Effect, options: { + readonly onSelfDone: (exit: Exit.Exit, fiber: Fiber.Fiber) => Effect; + readonly onOtherDone: (exit: Exit.Exit, fiber: Fiber.Fiber) => Effect; + }): (self: Effect) => Effect; + /** + * Races two effects and calls a finisher when the first one completes. + * + * **Details** + * + * This function runs two effects concurrently and calls a specified “finisher” + * function once one of the effects completes, regardless of whether it succeeds + * or fails. + * + * The finisher functions for each effect allow you to handle the results of + * each effect as soon as they complete. + * + * The function takes two finisher callbacks, one for each effect, and allows + * you to specify how to handle the result of the race. + * + * **When to Use** + * + * This function is useful when you need to react to the completion of either + * effect without waiting for both to finish. It can be used whenever you want + * to take action based on the first available result. + * + * **Example** (Handling Results of Concurrent Tasks) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Effect.succeed("task1").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Console.log("task1 done")), + * Effect.onInterrupt(() => + * Console.log("task1 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * const task2 = Effect.succeed("task2").pipe( + * Effect.delay("200 millis"), + * Effect.tap(Console.log("task2 done")), + * Effect.onInterrupt(() => + * Console.log("task2 interrupted").pipe(Effect.delay("100 millis")) + * ) + * ) + * + * const program = Effect.raceWith(task1, task2, { + * onSelfDone: (exit) => Console.log(`task1 exited with ${exit}`), + * onOtherDone: (exit) => Console.log(`task2 exited with ${exit}`) + * }) + * + * Effect.runFork(program) + * // Output: + * // task1 done + * // task1 exited with { + * // "_id": "Exit", + * // "_tag": "Success", + * // "value": "task1" + * // } + * // task2 interrupted + * ``` + * + * @since 2.0.0 + * @category Racing + */ + (self: Effect, other: Effect, options: { + readonly onSelfDone: (exit: Exit.Exit, fiber: Fiber.Fiber) => Effect; + readonly onOtherDone: (exit: Exit.Exit, fiber: Fiber.Fiber) => Effect; + }): Effect; +}; +/** + * Summarizes a effect by computing some value before and after execution, and + * then combining the values to produce a summary, together with the result of + * execution. + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const summarized: { + /** + * Summarizes a effect by computing some value before and after execution, and + * then combining the values to produce a summary, together with the result of + * execution. + * + * @since 2.0.0 + * @category Sequencing + */ + (summary: Effect, f: (start: B, end: B) => C): (self: Effect) => Effect<[C, A], E2 | E, R2 | R>; + /** + * Summarizes a effect by computing some value before and after execution, and + * then combining the values to produce a summary, together with the result of + * execution. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, summary: Effect, f: (start: B, end: B) => C): Effect<[C, A], E2 | E, R2 | R>; +}; +/** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const tap: { + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (a: NoInfer) => X): (self: Effect) => [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (a: NoInfer) => Effect, options: { + onlyEffect: true; + }): (self: Effect) => Effect; + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (f: NotFunction): (self: Effect) => [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (f: Effect, options: { + onlyEffect: true; + }): (self: Effect) => Effect; + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: (a: NoInfer) => X): [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: (a: NoInfer) => Effect, options: { + onlyEffect: true; + }): Effect; + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: NotFunction): [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + /** + * Runs a side effect with the result of an effect without changing the original + * value. + * + * **Details** + * + * This function works similarly to `flatMap`, but it ignores the result of the + * function passed to it. The value from the previous effect remains available + * for the next part of the chain. Note that if the side effect fails, the + * entire chain will fail too. + * + * **When to Use** + * + * Use this function when you want to perform a side effect, like logging or + * tracking, without modifying the main value. This is useful when you need to + * observe or record an action but want the original value to be passed to the + * next step. + * + * **Example** (Logging a step in a pipeline) + * + * ```ts + * import { Console, Effect, pipe } from "effect" + * + * // Function to apply a discount safely to a transaction amount + * const applyDiscount = ( + * total: number, + * discountRate: number + * ): Effect.Effect => + * discountRate === 0 + * ? Effect.fail(new Error("Discount rate cannot be zero")) + * : Effect.succeed(total - (total * discountRate) / 100) + * + * // Simulated asynchronous task to fetch a transaction amount from database + * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100)) + * + * const finalAmount = pipe( + * fetchTransactionAmount, + * // Log the fetched transaction amount + * Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)), + * // `amount` is still available! + * Effect.flatMap((amount) => applyDiscount(amount, 5)) + * ) + * + * Effect.runPromise(finalAmount).then(console.log) + * // Output: + * // Apply a discount to: 100 + * // 95 + * ``` + * + * @see {@link flatMap} for a version that allows you to change the value. + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: Effect, options: { + onlyEffect: true; + }): Effect; +}; +/** + * Allows you to inspect both success and failure outcomes of an effect and + * perform side effects for each. + * + * **Details** + * + * This function enables you to handle both success and failure cases + * separately, without modifying the main effect's result. It is particularly + * useful for scenarios where you need to log, monitor, or perform additional + * actions depending on whether the effect succeeded or failed. + * + * When the effect succeeds, the `onSuccess` handler is executed with the + * success value. When the effect fails, the `onFailure` handler is executed + * with the failure value. Both handlers can include side effects such as + * logging or analytics, and neither modifies the original effect's output. + * + * If either the success or failure handler fails, the overall effect will also + * fail. + * + * **Example** + * + * ```ts + * import { Effect, Random, Console } from "effect" + * + * // Simulate a task that might fail + * const task = Effect.filterOrFail( + * Random.nextRange(-1, 1), + * (n) => n >= 0, + * () => "random number is negative" + * ) + * + * // Use tapBoth to log both success and failure outcomes + * const tapping = Effect.tapBoth(task, { + * onFailure: (error) => Console.log(`failure: ${error}`), + * onSuccess: (randomNumber) => + * Console.log(`random number: ${randomNumber}`) + * }) + * + * Effect.runFork(tapping) + * // Example Output: + * // failure: random number is negative + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const tapBoth: { + /** + * Allows you to inspect both success and failure outcomes of an effect and + * perform side effects for each. + * + * **Details** + * + * This function enables you to handle both success and failure cases + * separately, without modifying the main effect's result. It is particularly + * useful for scenarios where you need to log, monitor, or perform additional + * actions depending on whether the effect succeeded or failed. + * + * When the effect succeeds, the `onSuccess` handler is executed with the + * success value. When the effect fails, the `onFailure` handler is executed + * with the failure value. Both handlers can include side effects such as + * logging or analytics, and neither modifies the original effect's output. + * + * If either the success or failure handler fails, the overall effect will also + * fail. + * + * **Example** + * + * ```ts + * import { Effect, Random, Console } from "effect" + * + * // Simulate a task that might fail + * const task = Effect.filterOrFail( + * Random.nextRange(-1, 1), + * (n) => n >= 0, + * () => "random number is negative" + * ) + * + * // Use tapBoth to log both success and failure outcomes + * const tapping = Effect.tapBoth(task, { + * onFailure: (error) => Console.log(`failure: ${error}`), + * onSuccess: (randomNumber) => + * Console.log(`random number: ${randomNumber}`) + * }) + * + * Effect.runFork(tapping) + * // Example Output: + * // failure: random number is negative + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (options: { + readonly onFailure: (e: NoInfer) => Effect; + readonly onSuccess: (a: NoInfer) => Effect; + }): (self: Effect) => Effect; + /** + * Allows you to inspect both success and failure outcomes of an effect and + * perform side effects for each. + * + * **Details** + * + * This function enables you to handle both success and failure cases + * separately, without modifying the main effect's result. It is particularly + * useful for scenarios where you need to log, monitor, or perform additional + * actions depending on whether the effect succeeded or failed. + * + * When the effect succeeds, the `onSuccess` handler is executed with the + * success value. When the effect fails, the `onFailure` handler is executed + * with the failure value. Both handlers can include side effects such as + * logging or analytics, and neither modifies the original effect's output. + * + * If either the success or failure handler fails, the overall effect will also + * fail. + * + * **Example** + * + * ```ts + * import { Effect, Random, Console } from "effect" + * + * // Simulate a task that might fail + * const task = Effect.filterOrFail( + * Random.nextRange(-1, 1), + * (n) => n >= 0, + * () => "random number is negative" + * ) + * + * // Use tapBoth to log both success and failure outcomes + * const tapping = Effect.tapBoth(task, { + * onFailure: (error) => Console.log(`failure: ${error}`), + * onSuccess: (randomNumber) => + * Console.log(`random number: ${randomNumber}`) + * }) + * + * Effect.runFork(tapping) + * // Example Output: + * // failure: random number is negative + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, options: { + readonly onFailure: (e: E) => Effect; + readonly onSuccess: (a: A) => Effect; + }): Effect; +}; +/** + * Inspect severe errors or defects (non-recoverable failures) in an effect. + * + * **Details** + * + * This function is specifically designed to handle and inspect defects, which + * are critical failures in your program, such as unexpected runtime exceptions + * or system-level errors. Unlike normal recoverable errors, defects typically + * indicate serious issues that cannot be addressed through standard error + * handling. + * + * When a defect occurs in an effect, the function you provide to this function + * will be executed, allowing you to log, monitor, or handle the defect in some + * way. Importantly, this does not alter the main result of the effect. If no + * defect occurs, the effect behaves as if this function was not used. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Simulate a task that fails with a recoverable error + * const task1: Effect.Effect = Effect.fail("NetworkError") + * + * // tapDefect won't log anything because NetworkError is not a defect + * const tapping1 = Effect.tapDefect(task1, (cause) => + * Console.log(`defect: ${cause}`) + * ) + * + * Effect.runFork(tapping1) + * // No Output + * + * // Simulate a severe failure in the system + * const task2: Effect.Effect = Effect.dieMessage( + * "Something went wrong" + * ) + * + * // Log the defect using tapDefect + * const tapping2 = Effect.tapDefect(task2, (cause) => + * Console.log(`defect: ${cause}`) + * ) + * + * Effect.runFork(tapping2) + * // Output: + * // defect: RuntimeException: Something went wrong + * // ... stack trace ... + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const tapDefect: { + /** + * Inspect severe errors or defects (non-recoverable failures) in an effect. + * + * **Details** + * + * This function is specifically designed to handle and inspect defects, which + * are critical failures in your program, such as unexpected runtime exceptions + * or system-level errors. Unlike normal recoverable errors, defects typically + * indicate serious issues that cannot be addressed through standard error + * handling. + * + * When a defect occurs in an effect, the function you provide to this function + * will be executed, allowing you to log, monitor, or handle the defect in some + * way. Importantly, this does not alter the main result of the effect. If no + * defect occurs, the effect behaves as if this function was not used. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Simulate a task that fails with a recoverable error + * const task1: Effect.Effect = Effect.fail("NetworkError") + * + * // tapDefect won't log anything because NetworkError is not a defect + * const tapping1 = Effect.tapDefect(task1, (cause) => + * Console.log(`defect: ${cause}`) + * ) + * + * Effect.runFork(tapping1) + * // No Output + * + * // Simulate a severe failure in the system + * const task2: Effect.Effect = Effect.dieMessage( + * "Something went wrong" + * ) + * + * // Log the defect using tapDefect + * const tapping2 = Effect.tapDefect(task2, (cause) => + * Console.log(`defect: ${cause}`) + * ) + * + * Effect.runFork(tapping2) + * // Output: + * // defect: RuntimeException: Something went wrong + * // ... stack trace ... + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (cause: Cause.Cause) => Effect): (self: Effect) => Effect; + /** + * Inspect severe errors or defects (non-recoverable failures) in an effect. + * + * **Details** + * + * This function is specifically designed to handle and inspect defects, which + * are critical failures in your program, such as unexpected runtime exceptions + * or system-level errors. Unlike normal recoverable errors, defects typically + * indicate serious issues that cannot be addressed through standard error + * handling. + * + * When a defect occurs in an effect, the function you provide to this function + * will be executed, allowing you to log, monitor, or handle the defect in some + * way. Importantly, this does not alter the main result of the effect. If no + * defect occurs, the effect behaves as if this function was not used. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Simulate a task that fails with a recoverable error + * const task1: Effect.Effect = Effect.fail("NetworkError") + * + * // tapDefect won't log anything because NetworkError is not a defect + * const tapping1 = Effect.tapDefect(task1, (cause) => + * Console.log(`defect: ${cause}`) + * ) + * + * Effect.runFork(tapping1) + * // No Output + * + * // Simulate a severe failure in the system + * const task2: Effect.Effect = Effect.dieMessage( + * "Something went wrong" + * ) + * + * // Log the defect using tapDefect + * const tapping2 = Effect.tapDefect(task2, (cause) => + * Console.log(`defect: ${cause}`) + * ) + * + * Effect.runFork(tapping2) + * // Output: + * // defect: RuntimeException: Something went wrong + * // ... stack trace ... + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: (cause: Cause.Cause) => Effect): Effect; +}; +/** + * Execute a side effect on failure without modifying the original effect. + * + * **Details** + * + * This function allows you to inspect and react to the failure of an effect by + * executing an additional effect. The failure value is passed to the provided + * function, enabling you to log it, track it, or perform any other operation. + * Importantly, the original failure remains intact and is re-propagated, so the + * effect's behavior is unchanged. + * + * The side effect you provide is only executed when the effect fails. If the + * effect succeeds, the function is ignored, and the success value is propagated + * as usual. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Simulate a task that fails with an error + * const task: Effect.Effect = Effect.fail("NetworkError") + * + * // Use tapError to log the error message when the task fails + * const tapping = Effect.tapError(task, (error) => + * Console.log(`expected error: ${error}`) + * ) + * + * Effect.runFork(tapping) + * // Output: + * // expected error: NetworkError + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const tapError: { + /** + * Execute a side effect on failure without modifying the original effect. + * + * **Details** + * + * This function allows you to inspect and react to the failure of an effect by + * executing an additional effect. The failure value is passed to the provided + * function, enabling you to log it, track it, or perform any other operation. + * Importantly, the original failure remains intact and is re-propagated, so the + * effect's behavior is unchanged. + * + * The side effect you provide is only executed when the effect fails. If the + * effect succeeds, the function is ignored, and the success value is propagated + * as usual. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Simulate a task that fails with an error + * const task: Effect.Effect = Effect.fail("NetworkError") + * + * // Use tapError to log the error message when the task fails + * const tapping = Effect.tapError(task, (error) => + * Console.log(`expected error: ${error}`) + * ) + * + * Effect.runFork(tapping) + * // Output: + * // expected error: NetworkError + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (e: NoInfer) => Effect): (self: Effect) => Effect; + /** + * Execute a side effect on failure without modifying the original effect. + * + * **Details** + * + * This function allows you to inspect and react to the failure of an effect by + * executing an additional effect. The failure value is passed to the provided + * function, enabling you to log it, track it, or perform any other operation. + * Importantly, the original failure remains intact and is re-propagated, so the + * effect's behavior is unchanged. + * + * The side effect you provide is only executed when the effect fails. If the + * effect succeeds, the function is ignored, and the success value is propagated + * as usual. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Simulate a task that fails with an error + * const task: Effect.Effect = Effect.fail("NetworkError") + * + * // Use tapError to log the error message when the task fails + * const tapping = Effect.tapError(task, (error) => + * Console.log(`expected error: ${error}`) + * ) + * + * Effect.runFork(tapping) + * // Output: + * // expected error: NetworkError + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: (e: E) => Effect): Effect; +}; +/** + * Inspect errors matching a specific tag without altering the original effect. + * + * **Details** + * + * This function allows you to inspect and handle specific error types based on + * their `_tag` property. It is particularly useful in applications where errors + * are modeled with tagged types (e.g., union types with discriminating tags). + * By targeting errors with a specific `_tag`, you can log or perform actions on + * them while leaving the error channel and overall effect unchanged. + * + * If the error doesn't match the specified tag, this function does nothing, and + * the effect proceeds as usual. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * class NetworkError { + * readonly _tag = "NetworkError" + * constructor(readonly statusCode: number) {} + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * constructor(readonly field: string) {} + * } + * + * // Create a task that fails with a NetworkError + * const task: Effect.Effect = + * Effect.fail(new NetworkError(504)) + * + * // Use tapErrorTag to inspect only NetworkError types and log the status code + * const tapping = Effect.tapErrorTag(task, "NetworkError", (error) => + * Console.log(`expected error: ${error.statusCode}`) + * ) + * + * Effect.runFork(tapping) + * // Output: + * // expected error: 504 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const tapErrorTag: { + /** + * Inspect errors matching a specific tag without altering the original effect. + * + * **Details** + * + * This function allows you to inspect and handle specific error types based on + * their `_tag` property. It is particularly useful in applications where errors + * are modeled with tagged types (e.g., union types with discriminating tags). + * By targeting errors with a specific `_tag`, you can log or perform actions on + * them while leaving the error channel and overall effect unchanged. + * + * If the error doesn't match the specified tag, this function does nothing, and + * the effect proceeds as usual. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * class NetworkError { + * readonly _tag = "NetworkError" + * constructor(readonly statusCode: number) {} + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * constructor(readonly field: string) {} + * } + * + * // Create a task that fails with a NetworkError + * const task: Effect.Effect = + * Effect.fail(new NetworkError(504)) + * + * // Use tapErrorTag to inspect only NetworkError types and log the status code + * const tapping = Effect.tapErrorTag(task, "NetworkError", (error) => + * Console.log(`expected error: ${error.statusCode}`) + * ) + * + * Effect.runFork(tapping) + * // Output: + * // expected error: 504 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (k: K, f: (e: NoInfer>) => Effect): (self: Effect) => Effect; + /** + * Inspect errors matching a specific tag without altering the original effect. + * + * **Details** + * + * This function allows you to inspect and handle specific error types based on + * their `_tag` property. It is particularly useful in applications where errors + * are modeled with tagged types (e.g., union types with discriminating tags). + * By targeting errors with a specific `_tag`, you can log or perform actions on + * them while leaving the error channel and overall effect unchanged. + * + * If the error doesn't match the specified tag, this function does nothing, and + * the effect proceeds as usual. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * class NetworkError { + * readonly _tag = "NetworkError" + * constructor(readonly statusCode: number) {} + * } + * + * class ValidationError { + * readonly _tag = "ValidationError" + * constructor(readonly field: string) {} + * } + * + * // Create a task that fails with a NetworkError + * const task: Effect.Effect = + * Effect.fail(new NetworkError(504)) + * + * // Use tapErrorTag to inspect only NetworkError types and log the status code + * const tapping = Effect.tapErrorTag(task, "NetworkError", (error) => + * Console.log(`expected error: ${error.statusCode}`) + * ) + * + * Effect.runFork(tapping) + * // Output: + * // expected error: 504 + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, k: K, f: (e: Extract) => Effect): Effect; +}; +/** + * Inspect the complete cause of an error, including failures and defects. + * + * **Details** + * + * This function provides access to the full cause of an error, including both + * recoverable failures and irrecoverable defects. It allows you to handle, log, + * or monitor specific error causes without modifying the result of the effect. + * The full `Cause` object encapsulates the error and its contextual + * information, making it useful for debugging and understanding failure + * scenarios in complex workflows. + * + * The effect itself is not modified, and any errors or defects remain in the + * error channel of the original effect. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Create a task that fails with a NetworkError + * const task1: Effect.Effect = Effect.fail("NetworkError") + * + * const tapping1 = Effect.tapErrorCause(task1, (cause) => + * Console.log(`error cause: ${cause}`) + * ) + * + * Effect.runFork(tapping1) + * // Output: + * // error cause: Error: NetworkError + * + * // Simulate a severe failure in the system + * const task2: Effect.Effect = Effect.dieMessage( + * "Something went wrong" + * ) + * + * const tapping2 = Effect.tapErrorCause(task2, (cause) => + * Console.log(`error cause: ${cause}`) + * ) + * + * Effect.runFork(tapping2) + * // Output: + * // error cause: RuntimeException: Something went wrong + * // ... stack trace ... + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ +export declare const tapErrorCause: { + /** + * Inspect the complete cause of an error, including failures and defects. + * + * **Details** + * + * This function provides access to the full cause of an error, including both + * recoverable failures and irrecoverable defects. It allows you to handle, log, + * or monitor specific error causes without modifying the result of the effect. + * The full `Cause` object encapsulates the error and its contextual + * information, making it useful for debugging and understanding failure + * scenarios in complex workflows. + * + * The effect itself is not modified, and any errors or defects remain in the + * error channel of the original effect. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Create a task that fails with a NetworkError + * const task1: Effect.Effect = Effect.fail("NetworkError") + * + * const tapping1 = Effect.tapErrorCause(task1, (cause) => + * Console.log(`error cause: ${cause}`) + * ) + * + * Effect.runFork(tapping1) + * // Output: + * // error cause: Error: NetworkError + * + * // Simulate a severe failure in the system + * const task2: Effect.Effect = Effect.dieMessage( + * "Something went wrong" + * ) + * + * const tapping2 = Effect.tapErrorCause(task2, (cause) => + * Console.log(`error cause: ${cause}`) + * ) + * + * Effect.runFork(tapping2) + * // Output: + * // error cause: RuntimeException: Something went wrong + * // ... stack trace ... + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (f: (cause: Cause.Cause>) => Effect): (self: Effect) => Effect; + /** + * Inspect the complete cause of an error, including failures and defects. + * + * **Details** + * + * This function provides access to the full cause of an error, including both + * recoverable failures and irrecoverable defects. It allows you to handle, log, + * or monitor specific error causes without modifying the result of the effect. + * The full `Cause` object encapsulates the error and its contextual + * information, making it useful for debugging and understanding failure + * scenarios in complex workflows. + * + * The effect itself is not modified, and any errors or defects remain in the + * error channel of the original effect. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * // Create a task that fails with a NetworkError + * const task1: Effect.Effect = Effect.fail("NetworkError") + * + * const tapping1 = Effect.tapErrorCause(task1, (cause) => + * Console.log(`error cause: ${cause}`) + * ) + * + * Effect.runFork(tapping1) + * // Output: + * // error cause: Error: NetworkError + * + * // Simulate a severe failure in the system + * const task2: Effect.Effect = Effect.dieMessage( + * "Something went wrong" + * ) + * + * const tapping2 = Effect.tapErrorCause(task2, (cause) => + * Console.log(`error cause: ${cause}`) + * ) + * + * Effect.runFork(tapping2) + * // Output: + * // error cause: RuntimeException: Something went wrong + * // ... stack trace ... + * ``` + * + * @since 2.0.0 + * @category Sequencing + */ + (self: Effect, f: (cause: Cause.Cause) => Effect): Effect; +}; +/** + * Repeats an effect indefinitely until an error occurs. + * + * **Details** + * + * This function executes an effect repeatedly in an infinite loop. Each + * iteration is executed sequentially, and the loop continues until the first + * error occurs. If the effect succeeds, it starts over from the beginning. If + * the effect fails, the error is propagated, and the loop stops. + * + * Be cautious when using this function, as it will run indefinitely unless an + * error interrupts it. This makes it suitable for long-running processes or + * continuous polling tasks, but you should ensure proper error handling or + * combine it with other operators like `timeout` or `schedule` to prevent + * unintentional infinite loops. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const forever: (self: Effect) => Effect; +/** + * Repeatedly updates a state through an effectful operation until a condition + * is no longer met. + * + * **Details** + * + * This function provides a way to implement effectful loops, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let result = initial + * + * while (options.while(result)) { + * result = options.body(result) + * } + * + * return result + * ``` + * + * It starts with an initial state, checks a + * condition (`while`), and executes a body operation to update the state if the + * condition evaluates to `true`. The process repeats until the condition + * returns `false`. + * + * The state is passed between iterations, allowing the body operation to modify + * it dynamically. The final state after the loop ends is returned as the result + * of the effect. + * + * **When to Use** + * + * This is particularly useful for scenarios where looping logic involves + * asynchronous or side-effectful operations, such as polling or iterative + * computations that depend on external factors. + * + * **Example** (Effectful Iteration) + * + * ```ts + * import { Effect } from "effect" + * + * const result = Effect.iterate( + * // Initial result + * 1, + * { + * // Condition to continue iterating + * while: (result) => result <= 5, + * // Operation to change the result + * body: (result) => Effect.succeed(result + 1) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: 6 + * ``` + * + * @since 2.0.0 + * @category Looping + */ +export declare const iterate: { + /** + * Repeatedly updates a state through an effectful operation until a condition + * is no longer met. + * + * **Details** + * + * This function provides a way to implement effectful loops, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let result = initial + * + * while (options.while(result)) { + * result = options.body(result) + * } + * + * return result + * ``` + * + * It starts with an initial state, checks a + * condition (`while`), and executes a body operation to update the state if the + * condition evaluates to `true`. The process repeats until the condition + * returns `false`. + * + * The state is passed between iterations, allowing the body operation to modify + * it dynamically. The final state after the loop ends is returned as the result + * of the effect. + * + * **When to Use** + * + * This is particularly useful for scenarios where looping logic involves + * asynchronous or side-effectful operations, such as polling or iterative + * computations that depend on external factors. + * + * **Example** (Effectful Iteration) + * + * ```ts + * import { Effect } from "effect" + * + * const result = Effect.iterate( + * // Initial result + * 1, + * { + * // Condition to continue iterating + * while: (result) => result <= 5, + * // Operation to change the result + * body: (result) => Effect.succeed(result + 1) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: 6 + * ``` + * + * @since 2.0.0 + * @category Looping + */ + (initial: A, options: { + readonly while: Refinement; + readonly body: (b: B) => Effect; + }): Effect; + /** + * Repeatedly updates a state through an effectful operation until a condition + * is no longer met. + * + * **Details** + * + * This function provides a way to implement effectful loops, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let result = initial + * + * while (options.while(result)) { + * result = options.body(result) + * } + * + * return result + * ``` + * + * It starts with an initial state, checks a + * condition (`while`), and executes a body operation to update the state if the + * condition evaluates to `true`. The process repeats until the condition + * returns `false`. + * + * The state is passed between iterations, allowing the body operation to modify + * it dynamically. The final state after the loop ends is returned as the result + * of the effect. + * + * **When to Use** + * + * This is particularly useful for scenarios where looping logic involves + * asynchronous or side-effectful operations, such as polling or iterative + * computations that depend on external factors. + * + * **Example** (Effectful Iteration) + * + * ```ts + * import { Effect } from "effect" + * + * const result = Effect.iterate( + * // Initial result + * 1, + * { + * // Condition to continue iterating + * while: (result) => result <= 5, + * // Operation to change the result + * body: (result) => Effect.succeed(result + 1) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: 6 + * ``` + * + * @since 2.0.0 + * @category Looping + */ + (initial: A, options: { + readonly while: Predicate; + readonly body: (a: A) => Effect; + }): Effect; +}; +/** + * Repeatedly executes a loop with a state, collecting results or discarding + * them based on configuration. + * + * **Details** + * + * This function performs an effectful loop, starting with an initial state and + * iterating as long as the `while` condition evaluates to `true`, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let state = initial + * const result = [] + * + * while (options.while(state)) { + * result.push(options.body(state)) // Perform the effectful operation + * state = options.step(state) // Update the state + * } + * + * return result + * ``` + * + * During each iteration, the `step` function updates the state, and the `body` + * effect is executed. + * + * The results of the body effect can be collected in an array or discarded + * based on the `discard` option. + * + * **Discarding Intermediate Results** + * + * - If `discard` is `false` or not provided, the intermediate results are + * collected into an array and returned as the final result. + * - If `discard` is `true`, the intermediate results are ignored, and the + * effect returns `void`. + * + * **When to Use** + * + * This is useful for implementing loops where you need to perform effectful + * computations repeatedly, such as processing items in a list, generating + * values, or performing iterative updates. + * + * **Example** (Looping with Collected Results) + * + * ```ts + * import { Effect } from "effect" + * + * // A loop that runs 5 times, collecting each iteration's result + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Effect.succeed(state) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: [1, 2, 3, 4, 5] + * ``` + * + * **Example** (Loop with Discarded Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Console.log(`Currently at state ${state}`), + * // Discard intermediate results + * discard: true + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at state 1 + * // Currently at state 2 + * // Currently at state 3 + * // Currently at state 4 + * // Currently at state 5 + * // undefined + * ``` + * + * @since 2.0.0 + * @category Looping + */ +export declare const loop: { + /** + * Repeatedly executes a loop with a state, collecting results or discarding + * them based on configuration. + * + * **Details** + * + * This function performs an effectful loop, starting with an initial state and + * iterating as long as the `while` condition evaluates to `true`, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let state = initial + * const result = [] + * + * while (options.while(state)) { + * result.push(options.body(state)) // Perform the effectful operation + * state = options.step(state) // Update the state + * } + * + * return result + * ``` + * + * During each iteration, the `step` function updates the state, and the `body` + * effect is executed. + * + * The results of the body effect can be collected in an array or discarded + * based on the `discard` option. + * + * **Discarding Intermediate Results** + * + * - If `discard` is `false` or not provided, the intermediate results are + * collected into an array and returned as the final result. + * - If `discard` is `true`, the intermediate results are ignored, and the + * effect returns `void`. + * + * **When to Use** + * + * This is useful for implementing loops where you need to perform effectful + * computations repeatedly, such as processing items in a list, generating + * values, or performing iterative updates. + * + * **Example** (Looping with Collected Results) + * + * ```ts + * import { Effect } from "effect" + * + * // A loop that runs 5 times, collecting each iteration's result + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Effect.succeed(state) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: [1, 2, 3, 4, 5] + * ``` + * + * **Example** (Loop with Discarded Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Console.log(`Currently at state ${state}`), + * // Discard intermediate results + * discard: true + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at state 1 + * // Currently at state 2 + * // Currently at state 3 + * // Currently at state 4 + * // Currently at state 5 + * // undefined + * ``` + * + * @since 2.0.0 + * @category Looping + */ + (initial: A, options: { + readonly while: Refinement; + readonly step: (b: B) => A; + readonly body: (b: B) => Effect; + readonly discard?: false | undefined; + }): Effect, E, R>; + /** + * Repeatedly executes a loop with a state, collecting results or discarding + * them based on configuration. + * + * **Details** + * + * This function performs an effectful loop, starting with an initial state and + * iterating as long as the `while` condition evaluates to `true`, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let state = initial + * const result = [] + * + * while (options.while(state)) { + * result.push(options.body(state)) // Perform the effectful operation + * state = options.step(state) // Update the state + * } + * + * return result + * ``` + * + * During each iteration, the `step` function updates the state, and the `body` + * effect is executed. + * + * The results of the body effect can be collected in an array or discarded + * based on the `discard` option. + * + * **Discarding Intermediate Results** + * + * - If `discard` is `false` or not provided, the intermediate results are + * collected into an array and returned as the final result. + * - If `discard` is `true`, the intermediate results are ignored, and the + * effect returns `void`. + * + * **When to Use** + * + * This is useful for implementing loops where you need to perform effectful + * computations repeatedly, such as processing items in a list, generating + * values, or performing iterative updates. + * + * **Example** (Looping with Collected Results) + * + * ```ts + * import { Effect } from "effect" + * + * // A loop that runs 5 times, collecting each iteration's result + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Effect.succeed(state) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: [1, 2, 3, 4, 5] + * ``` + * + * **Example** (Loop with Discarded Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Console.log(`Currently at state ${state}`), + * // Discard intermediate results + * discard: true + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at state 1 + * // Currently at state 2 + * // Currently at state 3 + * // Currently at state 4 + * // Currently at state 5 + * // undefined + * ``` + * + * @since 2.0.0 + * @category Looping + */ + (initial: A, options: { + readonly while: (a: A) => boolean; + readonly step: (a: A) => A; + readonly body: (a: A) => Effect; + readonly discard?: false | undefined; + }): Effect, E, R>; + /** + * Repeatedly executes a loop with a state, collecting results or discarding + * them based on configuration. + * + * **Details** + * + * This function performs an effectful loop, starting with an initial state and + * iterating as long as the `while` condition evaluates to `true`, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let state = initial + * const result = [] + * + * while (options.while(state)) { + * result.push(options.body(state)) // Perform the effectful operation + * state = options.step(state) // Update the state + * } + * + * return result + * ``` + * + * During each iteration, the `step` function updates the state, and the `body` + * effect is executed. + * + * The results of the body effect can be collected in an array or discarded + * based on the `discard` option. + * + * **Discarding Intermediate Results** + * + * - If `discard` is `false` or not provided, the intermediate results are + * collected into an array and returned as the final result. + * - If `discard` is `true`, the intermediate results are ignored, and the + * effect returns `void`. + * + * **When to Use** + * + * This is useful for implementing loops where you need to perform effectful + * computations repeatedly, such as processing items in a list, generating + * values, or performing iterative updates. + * + * **Example** (Looping with Collected Results) + * + * ```ts + * import { Effect } from "effect" + * + * // A loop that runs 5 times, collecting each iteration's result + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Effect.succeed(state) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: [1, 2, 3, 4, 5] + * ``` + * + * **Example** (Loop with Discarded Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Console.log(`Currently at state ${state}`), + * // Discard intermediate results + * discard: true + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at state 1 + * // Currently at state 2 + * // Currently at state 3 + * // Currently at state 4 + * // Currently at state 5 + * // undefined + * ``` + * + * @since 2.0.0 + * @category Looping + */ + (initial: A, options: { + readonly while: Refinement; + readonly step: (b: B) => A; + readonly body: (b: B) => Effect; + readonly discard: true; + }): Effect; + /** + * Repeatedly executes a loop with a state, collecting results or discarding + * them based on configuration. + * + * **Details** + * + * This function performs an effectful loop, starting with an initial state and + * iterating as long as the `while` condition evaluates to `true`, similar to a + * `while` loop in JavaScript. + * + * ```ts skip-type-checking + * let state = initial + * const result = [] + * + * while (options.while(state)) { + * result.push(options.body(state)) // Perform the effectful operation + * state = options.step(state) // Update the state + * } + * + * return result + * ``` + * + * During each iteration, the `step` function updates the state, and the `body` + * effect is executed. + * + * The results of the body effect can be collected in an array or discarded + * based on the `discard` option. + * + * **Discarding Intermediate Results** + * + * - If `discard` is `false` or not provided, the intermediate results are + * collected into an array and returned as the final result. + * - If `discard` is `true`, the intermediate results are ignored, and the + * effect returns `void`. + * + * **When to Use** + * + * This is useful for implementing loops where you need to perform effectful + * computations repeatedly, such as processing items in a list, generating + * values, or performing iterative updates. + * + * **Example** (Looping with Collected Results) + * + * ```ts + * import { Effect } from "effect" + * + * // A loop that runs 5 times, collecting each iteration's result + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Effect.succeed(state) + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: [1, 2, 3, 4, 5] + * ``` + * + * **Example** (Loop with Discarded Results) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const result = Effect.loop( + * // Initial state + * 1, + * { + * // Condition to continue looping + * while: (state) => state <= 5, + * // State update function + * step: (state) => state + 1, + * // Effect to be performed on each iteration + * body: (state) => Console.log(`Currently at state ${state}`), + * // Discard intermediate results + * discard: true + * } + * ) + * + * Effect.runPromise(result).then(console.log) + * // Output: + * // Currently at state 1 + * // Currently at state 2 + * // Currently at state 3 + * // Currently at state 4 + * // Currently at state 5 + * // undefined + * ``` + * + * @since 2.0.0 + * @category Looping + */ + (initial: A, options: { + readonly while: (a: A) => boolean; + readonly step: (a: A) => A; + readonly body: (a: A) => Effect; + readonly discard: true; + }): Effect; +}; +/** + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare namespace Repeat { + /** + * @since 2.0.0 + * @category Repetition / Recursion + */ + type Return, O>> = Effect<(O extends { + schedule: Schedule.Schedule; + } ? Out : O extends { + until: Refinement; + } ? B : A), E | (O extends { + while: (...args: Array) => Effect; + } ? E : never) | (O extends { + until: (...args: Array) => Effect; + } ? E : never), R | (O extends { + schedule: Schedule.Schedule; + } ? R : never) | (O extends { + while: (...args: Array) => Effect; + } ? R : never) | (O extends { + until: (...args: Array) => Effect; + } ? R : never)> extends infer Z ? Z : never; + /** + * @since 2.0.0 + * @category Repetition / Recursion + */ + interface Options { + while?: ((_: A) => boolean | Effect) | undefined; + until?: ((_: A) => boolean | Effect) | undefined; + times?: number | undefined; + schedule?: Schedule.Schedule | undefined; + } +} +/** + * Repeats an effect based on a specified schedule or until the first failure. + * + * **Details** + * + * This function executes an effect repeatedly according to the given schedule. + * Each repetition occurs after the initial execution of the effect, meaning + * that the schedule determines the number of additional repetitions. For + * example, using `Schedule.once` will result in the effect being executed twice + * (once initially and once as part of the repetition). + * + * If the effect succeeds, it is repeated according to the schedule. If it + * fails, the repetition stops immediately, and the failure is returned. + * + * The schedule can also specify delays between repetitions, making it useful + * for tasks like retrying operations with backoff, periodic execution, or + * performing a series of dependent actions. + * + * You can combine schedules for more advanced repetition logic, such as adding + * delays, limiting recursions, or dynamically adjusting based on the outcome of + * each execution. + * + * **Example** (Success Example) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * const action = Console.log("success") + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * **Example** (Failure Example) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromiseExit(program).then(console.log) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const repeat: { + /** + * Repeats an effect based on a specified schedule or until the first failure. + * + * **Details** + * + * This function executes an effect repeatedly according to the given schedule. + * Each repetition occurs after the initial execution of the effect, meaning + * that the schedule determines the number of additional repetitions. For + * example, using `Schedule.once` will result in the effect being executed twice + * (once initially and once as part of the repetition). + * + * If the effect succeeds, it is repeated according to the schedule. If it + * fails, the repetition stops immediately, and the failure is returned. + * + * The schedule can also specify delays between repetitions, making it useful + * for tasks like retrying operations with backoff, periodic execution, or + * performing a series of dependent actions. + * + * You can combine schedules for more advanced repetition logic, such as adding + * delays, limiting recursions, or dynamically adjusting based on the outcome of + * each execution. + * + * **Example** (Success Example) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * const action = Console.log("success") + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * **Example** (Failure Example) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromiseExit(program).then(console.log) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + , O>, A>(options: O): (self: Effect) => Repeat.Return; + /** + * Repeats an effect based on a specified schedule or until the first failure. + * + * **Details** + * + * This function executes an effect repeatedly according to the given schedule. + * Each repetition occurs after the initial execution of the effect, meaning + * that the schedule determines the number of additional repetitions. For + * example, using `Schedule.once` will result in the effect being executed twice + * (once initially and once as part of the repetition). + * + * If the effect succeeds, it is repeated according to the schedule. If it + * fails, the repetition stops immediately, and the failure is returned. + * + * The schedule can also specify delays between repetitions, making it useful + * for tasks like retrying operations with backoff, periodic execution, or + * performing a series of dependent actions. + * + * You can combine schedules for more advanced repetition logic, such as adding + * delays, limiting recursions, or dynamically adjusting based on the outcome of + * each execution. + * + * **Example** (Success Example) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * const action = Console.log("success") + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * **Example** (Failure Example) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromiseExit(program).then(console.log) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (schedule: Schedule.Schedule): (self: Effect) => Effect; + /** + * Repeats an effect based on a specified schedule or until the first failure. + * + * **Details** + * + * This function executes an effect repeatedly according to the given schedule. + * Each repetition occurs after the initial execution of the effect, meaning + * that the schedule determines the number of additional repetitions. For + * example, using `Schedule.once` will result in the effect being executed twice + * (once initially and once as part of the repetition). + * + * If the effect succeeds, it is repeated according to the schedule. If it + * fails, the repetition stops immediately, and the failure is returned. + * + * The schedule can also specify delays between repetitions, making it useful + * for tasks like retrying operations with backoff, periodic execution, or + * performing a series of dependent actions. + * + * You can combine schedules for more advanced repetition logic, such as adding + * delays, limiting recursions, or dynamically adjusting based on the outcome of + * each execution. + * + * **Example** (Success Example) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * const action = Console.log("success") + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * **Example** (Failure Example) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromiseExit(program).then(console.log) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + , O>>(self: Effect, options: O): Repeat.Return; + /** + * Repeats an effect based on a specified schedule or until the first failure. + * + * **Details** + * + * This function executes an effect repeatedly according to the given schedule. + * Each repetition occurs after the initial execution of the effect, meaning + * that the schedule determines the number of additional repetitions. For + * example, using `Schedule.once` will result in the effect being executed twice + * (once initially and once as part of the repetition). + * + * If the effect succeeds, it is repeated according to the schedule. If it + * fails, the repetition stops immediately, and the failure is returned. + * + * The schedule can also specify delays between repetitions, making it useful + * for tasks like retrying operations with backoff, periodic execution, or + * performing a series of dependent actions. + * + * You can combine schedules for more advanced repetition logic, such as adding + * delays, limiting recursions, or dynamically adjusting based on the outcome of + * each execution. + * + * **Example** (Success Example) + * + * ```ts + * import { Effect, Schedule, Console } from "effect" + * + * const action = Console.log("success") + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * **Example** (Failure Example) + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis") + * const program = Effect.repeat(action, policy) + * + * Effect.runPromiseExit(program).then(console.log) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (self: Effect, schedule: Schedule.Schedule): Effect; +}; +/** + * Repeats an effect a specified number of times or until the first failure. + * + * **Details** + * + * This function executes an effect initially and then repeats it the specified + * number of times, as long as it succeeds. For example, calling + * `repeatN(action, 2)` will execute `action` once initially and then repeat it + * two additional times if there are no failures. + * + * If the effect fails during any repetition, the failure is returned, and no + * further repetitions are attempted. + * + * **When to Use** + * + * This function is useful for tasks that need to be retried a fixed number of + * times or for performing repeated actions without requiring a schedule. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * const action = Console.log("success") + * const program = Effect.repeatN(action, 2) + * + * Effect.runPromise(program) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const repeatN: { + /** + * Repeats an effect a specified number of times or until the first failure. + * + * **Details** + * + * This function executes an effect initially and then repeats it the specified + * number of times, as long as it succeeds. For example, calling + * `repeatN(action, 2)` will execute `action` once initially and then repeat it + * two additional times if there are no failures. + * + * If the effect fails during any repetition, the failure is returned, and no + * further repetitions are attempted. + * + * **When to Use** + * + * This function is useful for tasks that need to be retried a fixed number of + * times or for performing repeated actions without requiring a schedule. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * const action = Console.log("success") + * const program = Effect.repeatN(action, 2) + * + * Effect.runPromise(program) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (n: number): (self: Effect) => Effect; + /** + * Repeats an effect a specified number of times or until the first failure. + * + * **Details** + * + * This function executes an effect initially and then repeats it the specified + * number of times, as long as it succeeds. For example, calling + * `repeatN(action, 2)` will execute `action` once initially and then repeat it + * two additional times if there are no failures. + * + * If the effect fails during any repetition, the failure is returned, and no + * further repetitions are attempted. + * + * **When to Use** + * + * This function is useful for tasks that need to be retried a fixed number of + * times or for performing repeated actions without requiring a schedule. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * const action = Console.log("success") + * const program = Effect.repeatN(action, 2) + * + * Effect.runPromise(program) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (self: Effect, n: number): Effect; +}; +/** + * Repeats an effect with a schedule, handling failures using a custom handler. + * + * **Details** + * + * This function allows you to execute an effect repeatedly based on a specified + * schedule. If the effect fails at any point, a custom failure handler is + * invoked. The handler is provided with both the failure value and the output + * of the schedule at the time of failure. This enables advanced error recovery + * or alternative fallback logic while maintaining flexibility in how + * repetitions are handled. + * + * For example, using a schedule with `recurs(2)` will allow for two additional + * repetitions after the initial execution, provided the effect succeeds. If a + * failure occurs during any iteration, the failure handler is invoked to handle + * the situation. + * + * **Example** + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay( + * Schedule.recurs(2), // Repeat for a maximum of 2 times + * () => "100 millis" // Add a delay of 100 milliseconds between repetitions + * ) + * + * const program = Effect.repeatOrElse(action, policy, () => + * Effect.sync(() => { + * console.log("orElse") + * return count - 1 + * }) + * ) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const repeatOrElse: { + /** + * Repeats an effect with a schedule, handling failures using a custom handler. + * + * **Details** + * + * This function allows you to execute an effect repeatedly based on a specified + * schedule. If the effect fails at any point, a custom failure handler is + * invoked. The handler is provided with both the failure value and the output + * of the schedule at the time of failure. This enables advanced error recovery + * or alternative fallback logic while maintaining flexibility in how + * repetitions are handled. + * + * For example, using a schedule with `recurs(2)` will allow for two additional + * repetitions after the initial execution, provided the effect succeeds. If a + * failure occurs during any iteration, the failure handler is invoked to handle + * the situation. + * + * **Example** + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay( + * Schedule.recurs(2), // Repeat for a maximum of 2 times + * () => "100 millis" // Add a delay of 100 milliseconds between repetitions + * ) + * + * const program = Effect.repeatOrElse(action, policy, () => + * Effect.sync(() => { + * console.log("orElse") + * return count - 1 + * }) + * ) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (schedule: Schedule.Schedule, orElse: (error: E, option: Option.Option) => Effect): (self: Effect) => Effect; + /** + * Repeats an effect with a schedule, handling failures using a custom handler. + * + * **Details** + * + * This function allows you to execute an effect repeatedly based on a specified + * schedule. If the effect fails at any point, a custom failure handler is + * invoked. The handler is provided with both the failure value and the output + * of the schedule at the time of failure. This enables advanced error recovery + * or alternative fallback logic while maintaining flexibility in how + * repetitions are handled. + * + * For example, using a schedule with `recurs(2)` will allow for two additional + * repetitions after the initial execution, provided the effect succeeds. If a + * failure occurs during any iteration, the failure handler is invoked to handle + * the situation. + * + * **Example** + * + * ```ts + * import { Effect, Schedule } from "effect" + * + * let count = 0 + * + * // Define an async effect that simulates an action with possible failures + * const action = Effect.async((resume) => { + * if (count > 1) { + * console.log("failure") + * resume(Effect.fail("Uh oh!")) + * } else { + * count++ + * console.log("success") + * resume(Effect.succeed("yay!")) + * } + * }) + * + * const policy = Schedule.addDelay( + * Schedule.recurs(2), // Repeat for a maximum of 2 times + * () => "100 millis" // Add a delay of 100 milliseconds between repetitions + * ) + * + * const program = Effect.repeatOrElse(action, policy, () => + * Effect.sync(() => { + * console.log("orElse") + * return count - 1 + * }) + * ) + * + * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`)) + * ``` + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (self: Effect, schedule: Schedule.Schedule, orElse: (error: E, option: Option.Option) => Effect): Effect; +}; +/** + * Repeats an effect based on a specified schedule. + * + * **Details** + * + * This function allows you to execute an effect repeatedly according to a given + * schedule. The schedule determines the timing and number of repetitions. Each + * repetition can also depend on the decision of the schedule, providing + * flexibility for complex workflows. This function does not modify the effect's + * success or failure; it only controls its repetition. + * + * For example, you can use a schedule that recurs a specific number of times, + * adds delays between repetitions, or customizes repetition behavior based on + * external inputs. The effect runs initially and is repeated according to the + * schedule. + * + * @see {@link scheduleFrom} for a variant that allows the schedule's decision + * to depend on the result of this effect. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const schedule: { + /** + * Repeats an effect based on a specified schedule. + * + * **Details** + * + * This function allows you to execute an effect repeatedly according to a given + * schedule. The schedule determines the timing and number of repetitions. Each + * repetition can also depend on the decision of the schedule, providing + * flexibility for complex workflows. This function does not modify the effect's + * success or failure; it only controls its repetition. + * + * For example, you can use a schedule that recurs a specific number of times, + * adds delays between repetitions, or customizes repetition behavior based on + * external inputs. The effect runs initially and is repeated according to the + * schedule. + * + * @see {@link scheduleFrom} for a variant that allows the schedule's decision + * to depend on the result of this effect. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (schedule: Schedule.Schedule | undefined, R2>): (self: Effect) => Effect; + /** + * Repeats an effect based on a specified schedule. + * + * **Details** + * + * This function allows you to execute an effect repeatedly according to a given + * schedule. The schedule determines the timing and number of repetitions. Each + * repetition can also depend on the decision of the schedule, providing + * flexibility for complex workflows. This function does not modify the effect's + * success or failure; it only controls its repetition. + * + * For example, you can use a schedule that recurs a specific number of times, + * adds delays between repetitions, or customizes repetition behavior based on + * external inputs. The effect runs initially and is repeated according to the + * schedule. + * + * @see {@link scheduleFrom} for a variant that allows the schedule's decision + * to depend on the result of this effect. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (self: Effect, schedule: Schedule.Schedule): Effect; +}; +/** + * Runs an effect repeatedly on a new fiber according to a given schedule. + * + * **Details** + * + * This function starts the provided effect on a new fiber and runs it + * repeatedly based on the specified schedule. The repetitions are managed by + * the schedule's rules, which define the timing and number of iterations. The + * fiber is attached to the current scope, meaning it is automatically managed + * and cleaned up when the scope is closed. + * + * The function returns a `RuntimeFiber` that allows you to monitor or interact + * with the running fiber. + * + * **When to Use** + * + * This is particularly useful for concurrent execution of scheduled tasks or + * when you want to continue processing without waiting for the repetitions to + * complete. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const scheduleForked: { + /** + * Runs an effect repeatedly on a new fiber according to a given schedule. + * + * **Details** + * + * This function starts the provided effect on a new fiber and runs it + * repeatedly based on the specified schedule. The repetitions are managed by + * the schedule's rules, which define the timing and number of iterations. The + * fiber is attached to the current scope, meaning it is automatically managed + * and cleaned up when the scope is closed. + * + * The function returns a `RuntimeFiber` that allows you to monitor or interact + * with the running fiber. + * + * **When to Use** + * + * This is particularly useful for concurrent execution of scheduled tasks or + * when you want to continue processing without waiting for the repetitions to + * complete. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (schedule: Schedule.Schedule): (self: Effect) => Effect, never, Scope.Scope | R2 | R>; + /** + * Runs an effect repeatedly on a new fiber according to a given schedule. + * + * **Details** + * + * This function starts the provided effect on a new fiber and runs it + * repeatedly based on the specified schedule. The repetitions are managed by + * the schedule's rules, which define the timing and number of iterations. The + * fiber is attached to the current scope, meaning it is automatically managed + * and cleaned up when the scope is closed. + * + * The function returns a `RuntimeFiber` that allows you to monitor or interact + * with the running fiber. + * + * **When to Use** + * + * This is particularly useful for concurrent execution of scheduled tasks or + * when you want to continue processing without waiting for the repetitions to + * complete. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (self: Effect, schedule: Schedule.Schedule): Effect, never, Scope.Scope | R | R2>; +}; +/** + * Runs an effect repeatedly according to a schedule, starting from a specified + * input value. + * + * **Details** + * + * This function allows you to repeatedly execute an effect based on a schedule. + * The schedule starts with the given `initial` input value, which is passed to + * the first execution. Subsequent executions of the effect are controlled by + * the schedule's rules, using the output of the previous iteration as the input + * for the next one. + * + * The returned effect will complete when the schedule ends or the effect fails, + * propagating the error. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const scheduleFrom: { + /** + * Runs an effect repeatedly according to a schedule, starting from a specified + * input value. + * + * **Details** + * + * This function allows you to repeatedly execute an effect based on a schedule. + * The schedule starts with the given `initial` input value, which is passed to + * the first execution. Subsequent executions of the effect are controlled by + * the schedule's rules, using the output of the previous iteration as the input + * for the next one. + * + * The returned effect will complete when the schedule ends or the effect fails, + * propagating the error. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (initial: In, schedule: Schedule.Schedule): (self: Effect) => Effect; + /** + * Runs an effect repeatedly according to a schedule, starting from a specified + * input value. + * + * **Details** + * + * This function allows you to repeatedly execute an effect based on a schedule. + * The schedule starts with the given `initial` input value, which is passed to + * the first execution. Subsequent executions of the effect are controlled by + * the schedule's rules, using the output of the previous iteration as the input + * for the next one. + * + * The returned effect will complete when the schedule ends or the effect fails, + * propagating the error. + * + * @since 2.0.0 + * @category Repetition / Recursion + */ + (self: Effect, initial: In, schedule: Schedule.Schedule): Effect; +}; +/** + * @since 2.0.0 + * @category Repetition / Recursion + */ +export declare const whileLoop: (options: { + readonly while: LazyArg; + readonly body: LazyArg>; + readonly step: (a: A) => void; +}) => Effect; +/** + * Returns a collection of all `FiberRef` values for the fiber running this + * effect. + * + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const getFiberRefs: Effect; +/** + * Inherits values from all `FiberRef` instances into current fiber. + * + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const inheritFiberRefs: (childFiberRefs: FiberRefs.FiberRefs) => Effect; +/** + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const locally: { + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (self: FiberRef.FiberRef, value: A): (use: Effect) => Effect; + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (use: Effect, self: FiberRef.FiberRef, value: A): Effect; +}; +/** + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const locallyWith: { + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (self: FiberRef.FiberRef, f: (a: A) => A): (use: Effect) => Effect; + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (use: Effect, self: FiberRef.FiberRef, f: (a: A) => A): Effect; +}; +/** + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const locallyScoped: { + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (value: A): (self: FiberRef.FiberRef) => Effect; + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (self: FiberRef.FiberRef, value: A): Effect; +}; +/** + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const locallyScopedWith: { + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (f: (a: A) => A): (self: FiberRef.FiberRef) => Effect; + /** + * @since 2.0.0 + * @category Fiber Refs + */ + (self: FiberRef.FiberRef, f: (a: A) => A): Effect; +}; +/** + * Applies the specified changes to the `FiberRef` values for the fiber + * running this workflow. + * + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const patchFiberRefs: (patch: FiberRefsPatch.FiberRefsPatch) => Effect; +/** + * Sets the `FiberRef` values for the fiber running this effect to the values + * in the specified collection of `FiberRef` values. + * + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const setFiberRefs: (fiberRefs: FiberRefs.FiberRefs) => Effect; +/** + * Updates the `FiberRef` values for the fiber running this effect using the + * specified function. + * + * @since 2.0.0 + * @category Fiber Refs + */ +export declare const updateFiberRefs: (f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs) => Effect; +/** + * Checks if an effect has failed. + * + * **Details** + * + * This function evaluates whether an effect has resulted in a failure. It + * returns a boolean value wrapped in an effect, with `true` indicating the + * effect failed and `false` otherwise. + * + * The resulting effect cannot fail (`never` in the error channel) but retains + * the context of the original effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const failure = Effect.fail("Uh oh!") + * + * console.log(Effect.runSync(Effect.isFailure(failure))) + * // Output: true + * + * const defect = Effect.dieMessage("BOOM!") + * + * Effect.runSync(Effect.isFailure(defect)) + * // throws: BOOM! + * ``` + * + * @since 2.0.0 + * @category Condition Checking + */ +export declare const isFailure: (self: Effect) => Effect; +/** + * Checks if an effect has succeeded. + * + * **Details** + * + * This function evaluates whether an effect has resulted in a success. It + * returns a boolean value wrapped in an effect, with `true` indicating the + * effect succeeded and `false` otherwise. + * + * The resulting effect cannot fail (`never` in the error channel) but retains + * the context of the original effect. + * + * @since 2.0.0 + * @category Condition Checking + */ +export declare const isSuccess: (self: Effect) => Effect; +/** + * Handles both success and failure cases of an effect without performing side + * effects. + * + * **Details** + * + * `match` lets you define custom handlers for both success and failure + * scenarios. You provide separate functions to handle each case, allowing you + * to process the result if the effect succeeds, or handle the error if the + * effect fails. + * + * **When to Use** + * + * This is useful for structuring your code to respond differently to success or + * failure without triggering side effects. + * + * **Example** (Handling Both Success and Failure Cases) + * + * ```ts + * import { Effect } from "effect" + * + * const success: Effect.Effect = Effect.succeed(42) + * + * const program1 = Effect.match(success, { + * onFailure: (error) => `failure: ${error.message}`, + * onSuccess: (value) => `success: ${value}` + * }) + * + * // Run and log the result of the successful effect + * Effect.runPromise(program1).then(console.log) + * // Output: "success: 42" + * + * const failure: Effect.Effect = Effect.fail( + * new Error("Uh oh!") + * ) + * + * const program2 = Effect.match(failure, { + * onFailure: (error) => `failure: ${error.message}`, + * onSuccess: (value) => `success: ${value}` + * }) + * + * // Run and log the result of the failed effect + * Effect.runPromise(program2).then(console.log) + * // Output: "failure: Uh oh!" + * ``` + * + * @see {@link matchEffect} if you need to perform side effects in the handlers. + * + * @since 2.0.0 + * @category Matching + */ +export declare const match: { + /** + * Handles both success and failure cases of an effect without performing side + * effects. + * + * **Details** + * + * `match` lets you define custom handlers for both success and failure + * scenarios. You provide separate functions to handle each case, allowing you + * to process the result if the effect succeeds, or handle the error if the + * effect fails. + * + * **When to Use** + * + * This is useful for structuring your code to respond differently to success or + * failure without triggering side effects. + * + * **Example** (Handling Both Success and Failure Cases) + * + * ```ts + * import { Effect } from "effect" + * + * const success: Effect.Effect = Effect.succeed(42) + * + * const program1 = Effect.match(success, { + * onFailure: (error) => `failure: ${error.message}`, + * onSuccess: (value) => `success: ${value}` + * }) + * + * // Run and log the result of the successful effect + * Effect.runPromise(program1).then(console.log) + * // Output: "success: 42" + * + * const failure: Effect.Effect = Effect.fail( + * new Error("Uh oh!") + * ) + * + * const program2 = Effect.match(failure, { + * onFailure: (error) => `failure: ${error.message}`, + * onSuccess: (value) => `success: ${value}` + * }) + * + * // Run and log the result of the failed effect + * Effect.runPromise(program2).then(console.log) + * // Output: "failure: Uh oh!" + * ``` + * + * @see {@link matchEffect} if you need to perform side effects in the handlers. + * + * @since 2.0.0 + * @category Matching + */ + (options: { + readonly onFailure: (error: E) => A2; + readonly onSuccess: (value: A) => A3; + }): (self: Effect) => Effect; + /** + * Handles both success and failure cases of an effect without performing side + * effects. + * + * **Details** + * + * `match` lets you define custom handlers for both success and failure + * scenarios. You provide separate functions to handle each case, allowing you + * to process the result if the effect succeeds, or handle the error if the + * effect fails. + * + * **When to Use** + * + * This is useful for structuring your code to respond differently to success or + * failure without triggering side effects. + * + * **Example** (Handling Both Success and Failure Cases) + * + * ```ts + * import { Effect } from "effect" + * + * const success: Effect.Effect = Effect.succeed(42) + * + * const program1 = Effect.match(success, { + * onFailure: (error) => `failure: ${error.message}`, + * onSuccess: (value) => `success: ${value}` + * }) + * + * // Run and log the result of the successful effect + * Effect.runPromise(program1).then(console.log) + * // Output: "success: 42" + * + * const failure: Effect.Effect = Effect.fail( + * new Error("Uh oh!") + * ) + * + * const program2 = Effect.match(failure, { + * onFailure: (error) => `failure: ${error.message}`, + * onSuccess: (value) => `success: ${value}` + * }) + * + * // Run and log the result of the failed effect + * Effect.runPromise(program2).then(console.log) + * // Output: "failure: Uh oh!" + * ``` + * + * @see {@link matchEffect} if you need to perform side effects in the handlers. + * + * @since 2.0.0 + * @category Matching + */ + (self: Effect, options: { + readonly onFailure: (error: E) => A2; + readonly onSuccess: (value: A) => A3; + }): Effect; +}; +/** + * Handles failures by matching the cause of failure. + * + * **Details** + * + * The `matchCause` function allows you to handle failures with access to the + * full cause of the failure within a fiber. + * + * **When to Use** + * + * This is useful for differentiating between different types of errors, such as + * regular failures, defects, or interruptions. You can provide specific + * handling logic for each failure type based on the cause. + * + * **Example** (Handling Different Failure Causes) + * + * ```ts + * import { Effect } from "effect" + * + * const task: Effect.Effect = Effect.die("Uh oh!") + * + * const program = Effect.matchCause(task, { + * onFailure: (cause) => { + * switch (cause._tag) { + * case "Fail": + * // Handle standard failure + * return `Fail: ${cause.error.message}` + * case "Die": + * // Handle defects (unexpected errors) + * return `Die: ${cause.defect}` + * case "Interrupt": + * // Handle interruption + * return `${cause.fiberId} interrupted!` + * } + * // Fallback for other causes + * return "failed due to other causes" + * }, + * onSuccess: (value) => + * // task completes successfully + * `succeeded with ${value} value` + * }) + * + * Effect.runPromise(program).then(console.log) + * // Output: "Die: Uh oh!" + * ``` + * + * @see {@link matchCauseEffect} if you need to perform side effects in the + * handlers. + * @see {@link match} if you don't need to handle the cause of the failure. + * + * @since 2.0.0 + * @category Matching + */ +export declare const matchCause: { + /** + * Handles failures by matching the cause of failure. + * + * **Details** + * + * The `matchCause` function allows you to handle failures with access to the + * full cause of the failure within a fiber. + * + * **When to Use** + * + * This is useful for differentiating between different types of errors, such as + * regular failures, defects, or interruptions. You can provide specific + * handling logic for each failure type based on the cause. + * + * **Example** (Handling Different Failure Causes) + * + * ```ts + * import { Effect } from "effect" + * + * const task: Effect.Effect = Effect.die("Uh oh!") + * + * const program = Effect.matchCause(task, { + * onFailure: (cause) => { + * switch (cause._tag) { + * case "Fail": + * // Handle standard failure + * return `Fail: ${cause.error.message}` + * case "Die": + * // Handle defects (unexpected errors) + * return `Die: ${cause.defect}` + * case "Interrupt": + * // Handle interruption + * return `${cause.fiberId} interrupted!` + * } + * // Fallback for other causes + * return "failed due to other causes" + * }, + * onSuccess: (value) => + * // task completes successfully + * `succeeded with ${value} value` + * }) + * + * Effect.runPromise(program).then(console.log) + * // Output: "Die: Uh oh!" + * ``` + * + * @see {@link matchCauseEffect} if you need to perform side effects in the + * handlers. + * @see {@link match} if you don't need to handle the cause of the failure. + * + * @since 2.0.0 + * @category Matching + */ + (options: { + readonly onFailure: (cause: Cause.Cause) => A2; + readonly onSuccess: (a: A) => A3; + }): (self: Effect) => Effect; + /** + * Handles failures by matching the cause of failure. + * + * **Details** + * + * The `matchCause` function allows you to handle failures with access to the + * full cause of the failure within a fiber. + * + * **When to Use** + * + * This is useful for differentiating between different types of errors, such as + * regular failures, defects, or interruptions. You can provide specific + * handling logic for each failure type based on the cause. + * + * **Example** (Handling Different Failure Causes) + * + * ```ts + * import { Effect } from "effect" + * + * const task: Effect.Effect = Effect.die("Uh oh!") + * + * const program = Effect.matchCause(task, { + * onFailure: (cause) => { + * switch (cause._tag) { + * case "Fail": + * // Handle standard failure + * return `Fail: ${cause.error.message}` + * case "Die": + * // Handle defects (unexpected errors) + * return `Die: ${cause.defect}` + * case "Interrupt": + * // Handle interruption + * return `${cause.fiberId} interrupted!` + * } + * // Fallback for other causes + * return "failed due to other causes" + * }, + * onSuccess: (value) => + * // task completes successfully + * `succeeded with ${value} value` + * }) + * + * Effect.runPromise(program).then(console.log) + * // Output: "Die: Uh oh!" + * ``` + * + * @see {@link matchCauseEffect} if you need to perform side effects in the + * handlers. + * @see {@link match} if you don't need to handle the cause of the failure. + * + * @since 2.0.0 + * @category Matching + */ + (self: Effect, options: { + readonly onFailure: (cause: Cause.Cause) => A2; + readonly onSuccess: (a: A) => A3; + }): Effect; +}; +/** + * Handles failures with access to the cause and allows performing side effects. + * + * **Details** + * + * The `matchCauseEffect` function works similarly to {@link matchCause}, but it + * also allows you to perform additional side effects based on the failure + * cause. This function provides access to the complete cause of the failure, + * making it possible to differentiate between various failure types, and allows + * you to respond accordingly while performing side effects (like logging or + * other operations). + * + * **Example** (Handling Different Failure Causes with Side Effects) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task: Effect.Effect = Effect.die("Uh oh!") + * + * const program = Effect.matchCauseEffect(task, { + * onFailure: (cause) => { + * switch (cause._tag) { + * case "Fail": + * // Handle standard failure with a logged message + * return Console.log(`Fail: ${cause.error.message}`) + * case "Die": + * // Handle defects (unexpected errors) by logging the defect + * return Console.log(`Die: ${cause.defect}`) + * case "Interrupt": + * // Handle interruption and log the fiberId that was interrupted + * return Console.log(`${cause.fiberId} interrupted!`) + * } + * // Fallback for other causes + * return Console.log("failed due to other causes") + * }, + * onSuccess: (value) => + * // Log success if the task completes successfully + * Console.log(`succeeded with ${value} value`) + * }) + * + * Effect.runPromise(program) + * // Output: "Die: Uh oh!" + * ``` + * + * @see {@link matchCause} if you don't need side effects and only want to handle the result or failure. + * @see {@link matchEffect} if you don't need to handle the cause of the failure. + * + * @since 2.0.0 + * @category Matching + */ +export declare const matchCauseEffect: { + /** + * Handles failures with access to the cause and allows performing side effects. + * + * **Details** + * + * The `matchCauseEffect` function works similarly to {@link matchCause}, but it + * also allows you to perform additional side effects based on the failure + * cause. This function provides access to the complete cause of the failure, + * making it possible to differentiate between various failure types, and allows + * you to respond accordingly while performing side effects (like logging or + * other operations). + * + * **Example** (Handling Different Failure Causes with Side Effects) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task: Effect.Effect = Effect.die("Uh oh!") + * + * const program = Effect.matchCauseEffect(task, { + * onFailure: (cause) => { + * switch (cause._tag) { + * case "Fail": + * // Handle standard failure with a logged message + * return Console.log(`Fail: ${cause.error.message}`) + * case "Die": + * // Handle defects (unexpected errors) by logging the defect + * return Console.log(`Die: ${cause.defect}`) + * case "Interrupt": + * // Handle interruption and log the fiberId that was interrupted + * return Console.log(`${cause.fiberId} interrupted!`) + * } + * // Fallback for other causes + * return Console.log("failed due to other causes") + * }, + * onSuccess: (value) => + * // Log success if the task completes successfully + * Console.log(`succeeded with ${value} value`) + * }) + * + * Effect.runPromise(program) + * // Output: "Die: Uh oh!" + * ``` + * + * @see {@link matchCause} if you don't need side effects and only want to handle the result or failure. + * @see {@link matchEffect} if you don't need to handle the cause of the failure. + * + * @since 2.0.0 + * @category Matching + */ + (options: { + readonly onFailure: (cause: Cause.Cause) => Effect; + readonly onSuccess: (a: A) => Effect; + }): (self: Effect) => Effect; + /** + * Handles failures with access to the cause and allows performing side effects. + * + * **Details** + * + * The `matchCauseEffect` function works similarly to {@link matchCause}, but it + * also allows you to perform additional side effects based on the failure + * cause. This function provides access to the complete cause of the failure, + * making it possible to differentiate between various failure types, and allows + * you to respond accordingly while performing side effects (like logging or + * other operations). + * + * **Example** (Handling Different Failure Causes with Side Effects) + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task: Effect.Effect = Effect.die("Uh oh!") + * + * const program = Effect.matchCauseEffect(task, { + * onFailure: (cause) => { + * switch (cause._tag) { + * case "Fail": + * // Handle standard failure with a logged message + * return Console.log(`Fail: ${cause.error.message}`) + * case "Die": + * // Handle defects (unexpected errors) by logging the defect + * return Console.log(`Die: ${cause.defect}`) + * case "Interrupt": + * // Handle interruption and log the fiberId that was interrupted + * return Console.log(`${cause.fiberId} interrupted!`) + * } + * // Fallback for other causes + * return Console.log("failed due to other causes") + * }, + * onSuccess: (value) => + * // Log success if the task completes successfully + * Console.log(`succeeded with ${value} value`) + * }) + * + * Effect.runPromise(program) + * // Output: "Die: Uh oh!" + * ``` + * + * @see {@link matchCause} if you don't need side effects and only want to handle the result or failure. + * @see {@link matchEffect} if you don't need to handle the cause of the failure. + * + * @since 2.0.0 + * @category Matching + */ + (self: Effect, options: { + readonly onFailure: (cause: Cause.Cause) => Effect; + readonly onSuccess: (a: A) => Effect; + }): Effect; +}; +/** + * Handles both success and failure cases of an effect, allowing for additional + * side effects. + * + * **Details** + * + * The `matchEffect` function is similar to {@link match}, but it enables you to + * perform side effects in the handlers for both success and failure outcomes. + * + * **When to Use** + * + * This is useful when you need to execute additional actions, like logging or + * notifying users, based on whether an effect succeeds or fails. + * + * **Example** (Handling Both Success and Failure Cases with Side Effects) + * + * ```ts + * import { Effect } from "effect" + * + * const success: Effect.Effect = Effect.succeed(42) + * const failure: Effect.Effect = Effect.fail( + * new Error("Uh oh!") + * ) + * + * const program1 = Effect.matchEffect(success, { + * onFailure: (error) => + * Effect.succeed(`failure: ${error.message}`).pipe( + * Effect.tap(Effect.log) + * ), + * onSuccess: (value) => + * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log)) + * }) + * + * console.log(Effect.runSync(program1)) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="success: 42" + * // success: 42 + * + * const program2 = Effect.matchEffect(failure, { + * onFailure: (error) => + * Effect.succeed(`failure: ${error.message}`).pipe( + * Effect.tap(Effect.log) + * ), + * onSuccess: (value) => + * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log)) + * }) + * + * console.log(Effect.runSync(program2)) + * // Output: + * // timestamp=... level=INFO fiber=#1 message="failure: Uh oh!" + * // failure: Uh oh! + * ``` + * + * @see {@link match} if you don't need side effects and only want to handle the + * result or failure. + * + * @since 2.0.0 + * @category Matching + */ +export declare const matchEffect: { + /** + * Handles both success and failure cases of an effect, allowing for additional + * side effects. + * + * **Details** + * + * The `matchEffect` function is similar to {@link match}, but it enables you to + * perform side effects in the handlers for both success and failure outcomes. + * + * **When to Use** + * + * This is useful when you need to execute additional actions, like logging or + * notifying users, based on whether an effect succeeds or fails. + * + * **Example** (Handling Both Success and Failure Cases with Side Effects) + * + * ```ts + * import { Effect } from "effect" + * + * const success: Effect.Effect = Effect.succeed(42) + * const failure: Effect.Effect = Effect.fail( + * new Error("Uh oh!") + * ) + * + * const program1 = Effect.matchEffect(success, { + * onFailure: (error) => + * Effect.succeed(`failure: ${error.message}`).pipe( + * Effect.tap(Effect.log) + * ), + * onSuccess: (value) => + * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log)) + * }) + * + * console.log(Effect.runSync(program1)) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="success: 42" + * // success: 42 + * + * const program2 = Effect.matchEffect(failure, { + * onFailure: (error) => + * Effect.succeed(`failure: ${error.message}`).pipe( + * Effect.tap(Effect.log) + * ), + * onSuccess: (value) => + * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log)) + * }) + * + * console.log(Effect.runSync(program2)) + * // Output: + * // timestamp=... level=INFO fiber=#1 message="failure: Uh oh!" + * // failure: Uh oh! + * ``` + * + * @see {@link match} if you don't need side effects and only want to handle the + * result or failure. + * + * @since 2.0.0 + * @category Matching + */ + (options: { + readonly onFailure: (e: E) => Effect; + readonly onSuccess: (a: A) => Effect; + }): (self: Effect) => Effect; + /** + * Handles both success and failure cases of an effect, allowing for additional + * side effects. + * + * **Details** + * + * The `matchEffect` function is similar to {@link match}, but it enables you to + * perform side effects in the handlers for both success and failure outcomes. + * + * **When to Use** + * + * This is useful when you need to execute additional actions, like logging or + * notifying users, based on whether an effect succeeds or fails. + * + * **Example** (Handling Both Success and Failure Cases with Side Effects) + * + * ```ts + * import { Effect } from "effect" + * + * const success: Effect.Effect = Effect.succeed(42) + * const failure: Effect.Effect = Effect.fail( + * new Error("Uh oh!") + * ) + * + * const program1 = Effect.matchEffect(success, { + * onFailure: (error) => + * Effect.succeed(`failure: ${error.message}`).pipe( + * Effect.tap(Effect.log) + * ), + * onSuccess: (value) => + * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log)) + * }) + * + * console.log(Effect.runSync(program1)) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="success: 42" + * // success: 42 + * + * const program2 = Effect.matchEffect(failure, { + * onFailure: (error) => + * Effect.succeed(`failure: ${error.message}`).pipe( + * Effect.tap(Effect.log) + * ), + * onSuccess: (value) => + * Effect.succeed(`success: ${value}`).pipe(Effect.tap(Effect.log)) + * }) + * + * console.log(Effect.runSync(program2)) + * // Output: + * // timestamp=... level=INFO fiber=#1 message="failure: Uh oh!" + * // failure: Uh oh! + * ``` + * + * @see {@link match} if you don't need side effects and only want to handle the + * result or failure. + * + * @since 2.0.0 + * @category Matching + */ + (self: Effect, options: { + readonly onFailure: (e: E) => Effect; + readonly onSuccess: (a: A) => Effect; + }): Effect; +}; +/** + * Logs one or more messages or error causes at the current log level. + * + * **Details** + * + * This function provides a simple way to log messages or error causes during + * the execution of your effects. By default, logs are recorded at the `INFO` + * level, but this can be adjusted using other logging utilities + * (`Logger.withMinimumLogLevel`). Multiple items, including `Cause` instances, + * can be logged in a single call. When logging `Cause` instances, detailed + * error information is included in the log output. + * + * The log output includes useful metadata like the current timestamp, log + * level, and fiber ID, making it suitable for debugging and tracking purposes. + * This function does not interrupt or alter the effect's execution flow. + * + * **Example** + * + * ```ts + * import { Cause, Effect } from "effect" + * + * const program = Effect.log( + * "message1", + * "message2", + * Cause.die("Oh no!"), + * Cause.die("Oh uh!") + * ) + * + * Effect.runFork(program) + * // Output: + * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 cause="Error: Oh no! + * // Error: Oh uh!" + * ``` + * + * @since 2.0.0 + * @category Logging + */ +export declare const log: (...message: ReadonlyArray) => Effect; +/** + * Logs messages or error causes at a specified log level. + * + * **Details** + * + * This function allows you to log one or more messages or error causes while + * specifying the desired log level (e.g., DEBUG, INFO, ERROR). It provides + * flexibility in categorizing logs based on their importance or severity, + * making it easier to filter logs during debugging or production monitoring. + * + * **Example** + * + * ```ts + * import { Cause, Effect, LogLevel } from "effect" + * + * const program = Effect.logWithLevel( + * LogLevel.Error, + * "Critical error encountered", + * Cause.die("System failure!") + * ) + * + * Effect.runFork(program) + * // Output: + * // timestamp=... level=ERROR fiber=#0 message=Critical error encountered cause="Error: System failure!" + * ``` + * + * @since 2.0.0 + * @category Logging + */ +export declare const logWithLevel: (level: LogLevel.LogLevel, ...message: ReadonlyArray) => Effect; +/** + * Logs messages at the TRACE log level. + * + * **Details** + * + * This function logs the specified messages at the TRACE level. TRACE logs are + * typically used for very detailed diagnostic information. These messages are + * not displayed by default. To view them, you must adjust the logging + * configuration by setting the minimum log level to `LogLevel.Trace` using + * `Logger.withMinimumLogLevel`. + * + * **Example** + * + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.logTrace("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Trace)) + * + * Effect.runFork(program) + * // timestamp=... level=TRACE fiber=#0 message=message1 + * ``` + * + * @since 2.0.0 + * @category Logging + */ +export declare const logTrace: (...message: ReadonlyArray) => Effect; +/** + * Logs messages at the DEBUG log level. + * + * **Details** + * + * This function logs messages at the DEBUG level, which is typically used for + * diagnosing application behavior during development. DEBUG messages provide + * less detailed information than TRACE logs but are still not shown by default. + * To view these logs, adjust the log level using `Logger.withMinimumLogLevel`. + * + * **Example** + * + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug)) + * + * Effect.runFork(program) + * // timestamp=... level=DEBUG fiber=#0 message=message1 + * ``` + * + * @since 2.0.0 + * @category Logging + */ +export declare const logDebug: (...message: ReadonlyArray) => Effect; +/** + * Logs messages at the INFO log level. + * + * **Details** + * + * This function logs messages at the INFO level, suitable for general + * application events or operational messages. INFO logs are shown by default + * and are commonly used for highlighting normal, non-error operations. + * + * @since 2.0.0 + * @category Logging + */ +export declare const logInfo: (...message: ReadonlyArray) => Effect; +/** + * Logs messages at the WARNING log level. + * + * **Details** + * + * This function logs messages at the WARNING level, suitable for highlighting + * potential issues that are not errors but may require attention. These + * messages indicate that something unexpected occurred or might lead to errors + * in the future. + * + * @since 2.0.0 + * @category Logging + */ +export declare const logWarning: (...message: ReadonlyArray) => Effect; +/** + * Logs messages at the ERROR log level. + * + * **Details** + * + * This function logs messages at the ERROR level, suitable for reporting + * application errors or failures. These logs are typically used for unexpected + * issues that need immediate attention. + * + * @since 2.0.0 + * @category Logging + */ +export declare const logError: (...message: ReadonlyArray) => Effect; +/** + * Logs messages at the FATAL log level. + * + * **Details** + * + * This function logs messages at the FATAL level, suitable for reporting + * critical errors that cause the application to terminate or stop functioning. + * These logs are typically used for unrecoverable errors that require immediate + * attention. + * + * @since 2.0.0 + * @category Logging + */ +export declare const logFatal: (...message: ReadonlyArray) => Effect; +/** + * Adds a log span to an effect for tracking and logging its execution duration. + * + * **Details** + * + * This function wraps an effect with a log span, providing performance + * monitoring and debugging capabilities. The log span tracks the duration of + * the wrapped effect and logs it with the specified label. This is particularly + * useful when analyzing time-sensitive operations or understanding the + * execution time of specific tasks in your application. + * + * The logged output will include the label and the total time taken for the + * operation. The span information is included in the log metadata, making it + * easy to trace performance metrics in logs. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.sleep("1 second") + * yield* Effect.log("The job is finished!") + * }).pipe(Effect.withLogSpan("myspan")) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message="The job is finished!" myspan=1011ms + * ``` + * + * @since 2.0.0 + * @category Logging + */ +export declare const withLogSpan: { + /** + * Adds a log span to an effect for tracking and logging its execution duration. + * + * **Details** + * + * This function wraps an effect with a log span, providing performance + * monitoring and debugging capabilities. The log span tracks the duration of + * the wrapped effect and logs it with the specified label. This is particularly + * useful when analyzing time-sensitive operations or understanding the + * execution time of specific tasks in your application. + * + * The logged output will include the label and the total time taken for the + * operation. The span information is included in the log metadata, making it + * easy to trace performance metrics in logs. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.sleep("1 second") + * yield* Effect.log("The job is finished!") + * }).pipe(Effect.withLogSpan("myspan")) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message="The job is finished!" myspan=1011ms + * ``` + * + * @since 2.0.0 + * @category Logging + */ + (label: string): (effect: Effect) => Effect; + /** + * Adds a log span to an effect for tracking and logging its execution duration. + * + * **Details** + * + * This function wraps an effect with a log span, providing performance + * monitoring and debugging capabilities. The log span tracks the duration of + * the wrapped effect and logs it with the specified label. This is particularly + * useful when analyzing time-sensitive operations or understanding the + * execution time of specific tasks in your application. + * + * The logged output will include the label and the total time taken for the + * operation. The span information is included in the log metadata, making it + * easy to trace performance metrics in logs. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.sleep("1 second") + * yield* Effect.log("The job is finished!") + * }).pipe(Effect.withLogSpan("myspan")) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message="The job is finished!" myspan=1011ms + * ``` + * + * @since 2.0.0 + * @category Logging + */ + (effect: Effect, label: string): Effect; +}; +/** + * Adds custom annotations to log entries generated within an effect. + * + * **Details** + * + * This function allows you to enhance log messages by appending additional + * context in the form of key-value pairs. These annotations are included in + * every log message created during the execution of the effect, making the logs + * more informative and easier to trace. + * + * The annotations can be specified as a single key-value pair or as a record of + * multiple key-value pairs. This is particularly useful for tracking + * operations, debugging, or associating specific metadata with logs for better + * observability. + * + * The annotated key-value pairs will appear alongside the log message in the + * output. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.log("message2") + * }).pipe(Effect.annotateLogs("taskId", "1234")) // Annotation as key/value pair + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 taskId=1234 + * // timestamp=... level=INFO fiber=#0 message=message2 taskId=1234 + * ``` + * + * @see {@link annotateLogsScoped} to add log annotations with a limited scope. + * + * @since 2.0.0 + * @category Logging + */ +export declare const annotateLogs: { + /** + * Adds custom annotations to log entries generated within an effect. + * + * **Details** + * + * This function allows you to enhance log messages by appending additional + * context in the form of key-value pairs. These annotations are included in + * every log message created during the execution of the effect, making the logs + * more informative and easier to trace. + * + * The annotations can be specified as a single key-value pair or as a record of + * multiple key-value pairs. This is particularly useful for tracking + * operations, debugging, or associating specific metadata with logs for better + * observability. + * + * The annotated key-value pairs will appear alongside the log message in the + * output. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.log("message2") + * }).pipe(Effect.annotateLogs("taskId", "1234")) // Annotation as key/value pair + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 taskId=1234 + * // timestamp=... level=INFO fiber=#0 message=message2 taskId=1234 + * ``` + * + * @see {@link annotateLogsScoped} to add log annotations with a limited scope. + * + * @since 2.0.0 + * @category Logging + */ + (key: string, value: unknown): (effect: Effect) => Effect; + /** + * Adds custom annotations to log entries generated within an effect. + * + * **Details** + * + * This function allows you to enhance log messages by appending additional + * context in the form of key-value pairs. These annotations are included in + * every log message created during the execution of the effect, making the logs + * more informative and easier to trace. + * + * The annotations can be specified as a single key-value pair or as a record of + * multiple key-value pairs. This is particularly useful for tracking + * operations, debugging, or associating specific metadata with logs for better + * observability. + * + * The annotated key-value pairs will appear alongside the log message in the + * output. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.log("message2") + * }).pipe(Effect.annotateLogs("taskId", "1234")) // Annotation as key/value pair + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 taskId=1234 + * // timestamp=... level=INFO fiber=#0 message=message2 taskId=1234 + * ``` + * + * @see {@link annotateLogsScoped} to add log annotations with a limited scope. + * + * @since 2.0.0 + * @category Logging + */ + (values: Record): (effect: Effect) => Effect; + /** + * Adds custom annotations to log entries generated within an effect. + * + * **Details** + * + * This function allows you to enhance log messages by appending additional + * context in the form of key-value pairs. These annotations are included in + * every log message created during the execution of the effect, making the logs + * more informative and easier to trace. + * + * The annotations can be specified as a single key-value pair or as a record of + * multiple key-value pairs. This is particularly useful for tracking + * operations, debugging, or associating specific metadata with logs for better + * observability. + * + * The annotated key-value pairs will appear alongside the log message in the + * output. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.log("message2") + * }).pipe(Effect.annotateLogs("taskId", "1234")) // Annotation as key/value pair + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 taskId=1234 + * // timestamp=... level=INFO fiber=#0 message=message2 taskId=1234 + * ``` + * + * @see {@link annotateLogsScoped} to add log annotations with a limited scope. + * + * @since 2.0.0 + * @category Logging + */ + (effect: Effect, key: string, value: unknown): Effect; + /** + * Adds custom annotations to log entries generated within an effect. + * + * **Details** + * + * This function allows you to enhance log messages by appending additional + * context in the form of key-value pairs. These annotations are included in + * every log message created during the execution of the effect, making the logs + * more informative and easier to trace. + * + * The annotations can be specified as a single key-value pair or as a record of + * multiple key-value pairs. This is particularly useful for tracking + * operations, debugging, or associating specific metadata with logs for better + * observability. + * + * The annotated key-value pairs will appear alongside the log message in the + * output. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.log("message2") + * }).pipe(Effect.annotateLogs("taskId", "1234")) // Annotation as key/value pair + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 taskId=1234 + * // timestamp=... level=INFO fiber=#0 message=message2 taskId=1234 + * ``` + * + * @see {@link annotateLogsScoped} to add log annotations with a limited scope. + * + * @since 2.0.0 + * @category Logging + */ + (effect: Effect, values: Record): Effect; +}; +/** + * Adds log annotations with a limited scope to enhance contextual logging. + * + * **Details** + * + * This function allows you to apply key-value annotations to log entries + * generated within a specific scope of your effect computations. The + * annotations are restricted to the defined `Scope`, ensuring that they are + * only applied to logs produced during that scope. Once the scope ends, the + * annotations are automatically removed, making it easier to manage + * context-specific logging without affecting other parts of your application. + * + * The annotations can be provided as a single key-value pair or as a record of + * multiple key-value pairs. This flexibility enables fine-grained control over + * the additional metadata included in logs for specific tasks or operations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("no annotations") + * yield* Effect.annotateLogsScoped({ key: "value" }) + * yield* Effect.log("message1") // Annotation is applied to this log + * yield* Effect.log("message2") // Annotation is applied to this log + * }).pipe(Effect.scoped, Effect.andThen(Effect.log("no annotations again"))) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message="no annotations" + * // timestamp=... level=INFO fiber=#0 message=message1 key=value + * // timestamp=... level=INFO fiber=#0 message=message2 key=value + * // timestamp=... level=INFO fiber=#0 message="no annotations again" + * ``` + * + * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect. + * + * @since 3.1.0 + * @category Logging + */ +export declare const annotateLogsScoped: { + /** + * Adds log annotations with a limited scope to enhance contextual logging. + * + * **Details** + * + * This function allows you to apply key-value annotations to log entries + * generated within a specific scope of your effect computations. The + * annotations are restricted to the defined `Scope`, ensuring that they are + * only applied to logs produced during that scope. Once the scope ends, the + * annotations are automatically removed, making it easier to manage + * context-specific logging without affecting other parts of your application. + * + * The annotations can be provided as a single key-value pair or as a record of + * multiple key-value pairs. This flexibility enables fine-grained control over + * the additional metadata included in logs for specific tasks or operations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("no annotations") + * yield* Effect.annotateLogsScoped({ key: "value" }) + * yield* Effect.log("message1") // Annotation is applied to this log + * yield* Effect.log("message2") // Annotation is applied to this log + * }).pipe(Effect.scoped, Effect.andThen(Effect.log("no annotations again"))) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message="no annotations" + * // timestamp=... level=INFO fiber=#0 message=message1 key=value + * // timestamp=... level=INFO fiber=#0 message=message2 key=value + * // timestamp=... level=INFO fiber=#0 message="no annotations again" + * ``` + * + * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect. + * + * @since 3.1.0 + * @category Logging + */ + (key: string, value: unknown): Effect; + /** + * Adds log annotations with a limited scope to enhance contextual logging. + * + * **Details** + * + * This function allows you to apply key-value annotations to log entries + * generated within a specific scope of your effect computations. The + * annotations are restricted to the defined `Scope`, ensuring that they are + * only applied to logs produced during that scope. Once the scope ends, the + * annotations are automatically removed, making it easier to manage + * context-specific logging without affecting other parts of your application. + * + * The annotations can be provided as a single key-value pair or as a record of + * multiple key-value pairs. This flexibility enables fine-grained control over + * the additional metadata included in logs for specific tasks or operations. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("no annotations") + * yield* Effect.annotateLogsScoped({ key: "value" }) + * yield* Effect.log("message1") // Annotation is applied to this log + * yield* Effect.log("message2") // Annotation is applied to this log + * }).pipe(Effect.scoped, Effect.andThen(Effect.log("no annotations again"))) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message="no annotations" + * // timestamp=... level=INFO fiber=#0 message=message1 key=value + * // timestamp=... level=INFO fiber=#0 message=message2 key=value + * // timestamp=... level=INFO fiber=#0 message="no annotations again" + * ``` + * + * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect. + * + * @since 3.1.0 + * @category Logging + */ + (values: Record): Effect; +}; +/** + * Retrieves the current log annotations for the current scope. + * + * **Details** + * + * This function provides access to the log annotations associated with the + * current scope. Log annotations are key-value pairs that provide additional + * context to log entries. They are often used to add metadata such as tags, + * identifiers, or extra debugging information to logs. + * + * By using this function, you can inspect or utilize the annotations applied to + * the current scope, making it easier to trace and debug specific sections of + * your application. + * + * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect. + * @see {@link annotateLogsScoped} to add log annotations with a limited scope. + * + * @since 2.0.0 + * @category Logging + */ +export declare const logAnnotations: Effect>; +/** + * Configures whether child fibers will log unhandled errors and at what log + * level. + * + * **Details** + * + * This function allows you to control whether unhandled errors from child + * fibers are logged and to specify the log level for these errors. By default, + * unhandled errors are reported via the logger. However, using this function, + * you can choose to suppress these logs by passing `Option.none` or adjust the + * log level to a specific severity, such as `Error`, `Warning`, or `Info`. + * + * This configuration is scoped to the effect it is applied to, meaning the + * changes only apply to the child fibers created within that effect's context. + * It is especially useful when you want to reduce noise in logs or prioritize + * certain types of errors. + * + * **Example** + * + * ```ts + * import { Effect, Fiber, LogLevel, Option } from "effect" + * + * const program = Effect.gen(function*() { + * const fiber = yield* Effect.fork(Effect.fail("Unhandled error!")) + * yield* Fiber.join(fiber) + * }) + * + * Effect.runFork(program.pipe(Effect.withUnhandledErrorLogLevel(Option.some(LogLevel.Error)))) + * // Output: + * // timestamp=... level=ERROR fiber=#1 message="Fiber terminated with an unhandled error" cause="Error: Unhandled error!" + * ``` + * + * @since 2.0.0 + * @category Logging + */ +export declare const withUnhandledErrorLogLevel: { + /** + * Configures whether child fibers will log unhandled errors and at what log + * level. + * + * **Details** + * + * This function allows you to control whether unhandled errors from child + * fibers are logged and to specify the log level for these errors. By default, + * unhandled errors are reported via the logger. However, using this function, + * you can choose to suppress these logs by passing `Option.none` or adjust the + * log level to a specific severity, such as `Error`, `Warning`, or `Info`. + * + * This configuration is scoped to the effect it is applied to, meaning the + * changes only apply to the child fibers created within that effect's context. + * It is especially useful when you want to reduce noise in logs or prioritize + * certain types of errors. + * + * **Example** + * + * ```ts + * import { Effect, Fiber, LogLevel, Option } from "effect" + * + * const program = Effect.gen(function*() { + * const fiber = yield* Effect.fork(Effect.fail("Unhandled error!")) + * yield* Fiber.join(fiber) + * }) + * + * Effect.runFork(program.pipe(Effect.withUnhandledErrorLogLevel(Option.some(LogLevel.Error)))) + * // Output: + * // timestamp=... level=ERROR fiber=#1 message="Fiber terminated with an unhandled error" cause="Error: Unhandled error!" + * ``` + * + * @since 2.0.0 + * @category Logging + */ + (level: Option.Option): (self: Effect) => Effect; + /** + * Configures whether child fibers will log unhandled errors and at what log + * level. + * + * **Details** + * + * This function allows you to control whether unhandled errors from child + * fibers are logged and to specify the log level for these errors. By default, + * unhandled errors are reported via the logger. However, using this function, + * you can choose to suppress these logs by passing `Option.none` or adjust the + * log level to a specific severity, such as `Error`, `Warning`, or `Info`. + * + * This configuration is scoped to the effect it is applied to, meaning the + * changes only apply to the child fibers created within that effect's context. + * It is especially useful when you want to reduce noise in logs or prioritize + * certain types of errors. + * + * **Example** + * + * ```ts + * import { Effect, Fiber, LogLevel, Option } from "effect" + * + * const program = Effect.gen(function*() { + * const fiber = yield* Effect.fork(Effect.fail("Unhandled error!")) + * yield* Fiber.join(fiber) + * }) + * + * Effect.runFork(program.pipe(Effect.withUnhandledErrorLogLevel(Option.some(LogLevel.Error)))) + * // Output: + * // timestamp=... level=ERROR fiber=#1 message="Fiber terminated with an unhandled error" cause="Error: Unhandled error!" + * ``` + * + * @since 2.0.0 + * @category Logging + */ + (self: Effect, level: Option.Option): Effect; +}; +/** + * Conditionally executes an effect based on the specified log level and currently enabled log level. + * + * **Details** + * + * This function runs the provided effect only if the specified log level is + * enabled. If the log level is enabled, the effect is executed and its result + * is wrapped in `Some`. If the log level is not enabled, the effect is not + * executed and `None` is returned. + * + * This function is useful for conditionally executing logging-related effects + * or other operations that depend on the current log level configuration. + * + * **Example** + * + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.gen(function* () { + * yield* Effect.whenLogLevel(Effect.logTrace("message1"), LogLevel.Trace); // returns `None` + * yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some` + * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug)); + * + * Effect.runFork(program) + * // timestamp=... level=DEBUG fiber=#0 message=message2 + * ``` + * + * @see {@link FiberRef.currentMinimumLogLevel} to retrieve the current minimum log level. + * + * @since 3.13.0 + * @category Logging + */ +export declare const whenLogLevel: { + /** + * Conditionally executes an effect based on the specified log level and currently enabled log level. + * + * **Details** + * + * This function runs the provided effect only if the specified log level is + * enabled. If the log level is enabled, the effect is executed and its result + * is wrapped in `Some`. If the log level is not enabled, the effect is not + * executed and `None` is returned. + * + * This function is useful for conditionally executing logging-related effects + * or other operations that depend on the current log level configuration. + * + * **Example** + * + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.gen(function* () { + * yield* Effect.whenLogLevel(Effect.logTrace("message1"), LogLevel.Trace); // returns `None` + * yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some` + * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug)); + * + * Effect.runFork(program) + * // timestamp=... level=DEBUG fiber=#0 message=message2 + * ``` + * + * @see {@link FiberRef.currentMinimumLogLevel} to retrieve the current minimum log level. + * + * @since 3.13.0 + * @category Logging + */ + (level: LogLevel.LogLevel | LogLevel.Literal): (self: Effect) => Effect, E, R>; + /** + * Conditionally executes an effect based on the specified log level and currently enabled log level. + * + * **Details** + * + * This function runs the provided effect only if the specified log level is + * enabled. If the log level is enabled, the effect is executed and its result + * is wrapped in `Some`. If the log level is not enabled, the effect is not + * executed and `None` is returned. + * + * This function is useful for conditionally executing logging-related effects + * or other operations that depend on the current log level configuration. + * + * **Example** + * + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.gen(function* () { + * yield* Effect.whenLogLevel(Effect.logTrace("message1"), LogLevel.Trace); // returns `None` + * yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some` + * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug)); + * + * Effect.runFork(program) + * // timestamp=... level=DEBUG fiber=#0 message=message2 + * ``` + * + * @see {@link FiberRef.currentMinimumLogLevel} to retrieve the current minimum log level. + * + * @since 3.13.0 + * @category Logging + */ + (self: Effect, level: LogLevel.LogLevel | LogLevel.Literal): Effect, E, R>; +}; +/** + * Converts an effect's failure into a fiber termination, removing the error + * from the effect's type. + * + * **Details** + * + * The `orDie` function is used when you encounter errors that you do not want + * to handle or recover from. It removes the error type from the effect and + * ensures that any failure will terminate the fiber. This is useful for + * propagating failures as defects, signaling that they should not be handled + * within the effect. + * + * **When to Use* + * + * Use `orDie` when failures should be treated as unrecoverable defects and no + * error handling is required. + * + * **Example** (Propagating an Error as a Defect) + * + * ```ts + * import { Effect } from "effect" + * + * const divide = (a: number, b: number) => + * b === 0 + * ? Effect.fail(new Error("Cannot divide by zero")) + * : Effect.succeed(a / b) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.orDie(divide(1, 0)) + * + * Effect.runPromise(program).catch(console.error) + * // Output: + * // (FiberFailure) Error: Cannot divide by zero + * // ...stack trace... + * ``` + * + * @see {@link orDieWith} if you need to customize the error. + * + * @since 2.0.0 + * @category Converting Failures to Defects + */ +export declare const orDie: (self: Effect) => Effect; +/** + * Converts an effect's failure into a fiber termination with a custom error. + * + * **Details** + * + * The `orDieWith` function behaves like {@link orDie}, but it allows you to provide a mapping + * function to transform the error before terminating the fiber. This is useful for cases where + * you want to include a more detailed or user-friendly error when the failure is propagated + * as a defect. + * + * **When to Use** + * + * Use `orDieWith` when failures should terminate the fiber as defects, and you want to customize + * the error for clarity or debugging purposes. + * + * **Example** (Customizing Defect) + * + * ```ts + * import { Effect } from "effect" + * + * const divide = (a: number, b: number) => + * b === 0 + * ? Effect.fail(new Error("Cannot divide by zero")) + * : Effect.succeed(a / b) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.orDieWith( + * divide(1, 0), + * (error) => new Error(`defect: ${error.message}`) + * ) + * + * Effect.runPromise(program).catch(console.error) + * // Output: + * // (FiberFailure) Error: defect: Cannot divide by zero + * // ...stack trace... + * ``` + * + * @see {@link orDie} if you don't need to customize the error. + * + * @since 2.0.0 + * @category Converting Failures to Defects + */ +export declare const orDieWith: { + /** + * Converts an effect's failure into a fiber termination with a custom error. + * + * **Details** + * + * The `orDieWith` function behaves like {@link orDie}, but it allows you to provide a mapping + * function to transform the error before terminating the fiber. This is useful for cases where + * you want to include a more detailed or user-friendly error when the failure is propagated + * as a defect. + * + * **When to Use** + * + * Use `orDieWith` when failures should terminate the fiber as defects, and you want to customize + * the error for clarity or debugging purposes. + * + * **Example** (Customizing Defect) + * + * ```ts + * import { Effect } from "effect" + * + * const divide = (a: number, b: number) => + * b === 0 + * ? Effect.fail(new Error("Cannot divide by zero")) + * : Effect.succeed(a / b) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.orDieWith( + * divide(1, 0), + * (error) => new Error(`defect: ${error.message}`) + * ) + * + * Effect.runPromise(program).catch(console.error) + * // Output: + * // (FiberFailure) Error: defect: Cannot divide by zero + * // ...stack trace... + * ``` + * + * @see {@link orDie} if you don't need to customize the error. + * + * @since 2.0.0 + * @category Converting Failures to Defects + */ + (f: (error: E) => unknown): (self: Effect) => Effect; + /** + * Converts an effect's failure into a fiber termination with a custom error. + * + * **Details** + * + * The `orDieWith` function behaves like {@link orDie}, but it allows you to provide a mapping + * function to transform the error before terminating the fiber. This is useful for cases where + * you want to include a more detailed or user-friendly error when the failure is propagated + * as a defect. + * + * **When to Use** + * + * Use `orDieWith` when failures should terminate the fiber as defects, and you want to customize + * the error for clarity or debugging purposes. + * + * **Example** (Customizing Defect) + * + * ```ts + * import { Effect } from "effect" + * + * const divide = (a: number, b: number) => + * b === 0 + * ? Effect.fail(new Error("Cannot divide by zero")) + * : Effect.succeed(a / b) + * + * // ┌─── Effect + * // ▼ + * const program = Effect.orDieWith( + * divide(1, 0), + * (error) => new Error(`defect: ${error.message}`) + * ) + * + * Effect.runPromise(program).catch(console.error) + * // Output: + * // (FiberFailure) Error: defect: Cannot divide by zero + * // ...stack trace... + * ``` + * + * @see {@link orDie} if you don't need to customize the error. + * + * @since 2.0.0 + * @category Converting Failures to Defects + */ + (self: Effect, f: (error: E) => unknown): Effect; +}; +/** + * Attempts one effect, and if it fails, falls back to another effect. + * + * **Details** + * + * This function allows you to try executing an effect, and if it fails + * (produces an error), a fallback effect is executed instead. The fallback + * effect is defined as a lazy argument, meaning it will only be evaluated if + * the first effect fails. This provides a way to recover from errors by + * specifying an alternative path of execution. + * + * The error type of the resulting effect will be that of the fallback effect, + * as the first effect's error is replaced when the fallback is executed. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const success = Effect.succeed("success") + * const failure = Effect.fail("failure") + * const fallback = Effect.succeed("fallback") + * + * // Try the success effect first, fallback is not used + * const program1 = Effect.orElse(success, () => fallback) + * console.log(Effect.runSync(program1)) + * // Output: "success" + * + * // Try the failure effect first, fallback is used + * const program2 = Effect.orElse(failure, () => fallback) + * console.log(Effect.runSync(program2)) + * // Output: "fallback" + * ``` + * + * @see {@link catchAll} if you need to access the error in the fallback effect. + * + * @since 2.0.0 + * @category Fallback + */ +export declare const orElse: { + /** + * Attempts one effect, and if it fails, falls back to another effect. + * + * **Details** + * + * This function allows you to try executing an effect, and if it fails + * (produces an error), a fallback effect is executed instead. The fallback + * effect is defined as a lazy argument, meaning it will only be evaluated if + * the first effect fails. This provides a way to recover from errors by + * specifying an alternative path of execution. + * + * The error type of the resulting effect will be that of the fallback effect, + * as the first effect's error is replaced when the fallback is executed. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const success = Effect.succeed("success") + * const failure = Effect.fail("failure") + * const fallback = Effect.succeed("fallback") + * + * // Try the success effect first, fallback is not used + * const program1 = Effect.orElse(success, () => fallback) + * console.log(Effect.runSync(program1)) + * // Output: "success" + * + * // Try the failure effect first, fallback is used + * const program2 = Effect.orElse(failure, () => fallback) + * console.log(Effect.runSync(program2)) + * // Output: "fallback" + * ``` + * + * @see {@link catchAll} if you need to access the error in the fallback effect. + * + * @since 2.0.0 + * @category Fallback + */ + (that: LazyArg>): (self: Effect) => Effect; + /** + * Attempts one effect, and if it fails, falls back to another effect. + * + * **Details** + * + * This function allows you to try executing an effect, and if it fails + * (produces an error), a fallback effect is executed instead. The fallback + * effect is defined as a lazy argument, meaning it will only be evaluated if + * the first effect fails. This provides a way to recover from errors by + * specifying an alternative path of execution. + * + * The error type of the resulting effect will be that of the fallback effect, + * as the first effect's error is replaced when the fallback is executed. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const success = Effect.succeed("success") + * const failure = Effect.fail("failure") + * const fallback = Effect.succeed("fallback") + * + * // Try the success effect first, fallback is not used + * const program1 = Effect.orElse(success, () => fallback) + * console.log(Effect.runSync(program1)) + * // Output: "success" + * + * // Try the failure effect first, fallback is used + * const program2 = Effect.orElse(failure, () => fallback) + * console.log(Effect.runSync(program2)) + * // Output: "fallback" + * ``` + * + * @see {@link catchAll} if you need to access the error in the fallback effect. + * + * @since 2.0.0 + * @category Fallback + */ + (self: Effect, that: LazyArg>): Effect; +}; +/** + * Replaces the failure of an effect with a custom failure value. + * + * **Details** + * + * This function allows you to handle the failure of an effect by replacing it + * with a predefined failure value. If the effect fails, the new failure value + * provided by the `evaluate` function will be returned instead of the original + * failure. If the effect succeeds, the original success value is returned + * unchanged. + * + * **When to Use** + * + * This is particularly useful when you want to standardize error handling or + * provide a consistent failure value for specific operations. It simplifies + * error management by ensuring that all failures are replaced with a controlled + * alternative. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const validate = (age: number): Effect.Effect => { + * if (age < 0) { + * return Effect.fail("NegativeAgeError") + * } else if (age < 18) { + * return Effect.fail("IllegalAgeError") + * } else { + * return Effect.succeed(age) + * } + * } + * + * const program = Effect.orElseFail(validate(-1), () => "invalid age") + * + * console.log(Effect.runSyncExit(program)) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'invalid age' } + * // } + * ``` + * + * @see {@link mapError} if you need to access the error to transform it. + * + * @since 2.0.0 + * @category Fallback + */ +export declare const orElseFail: { + /** + * Replaces the failure of an effect with a custom failure value. + * + * **Details** + * + * This function allows you to handle the failure of an effect by replacing it + * with a predefined failure value. If the effect fails, the new failure value + * provided by the `evaluate` function will be returned instead of the original + * failure. If the effect succeeds, the original success value is returned + * unchanged. + * + * **When to Use** + * + * This is particularly useful when you want to standardize error handling or + * provide a consistent failure value for specific operations. It simplifies + * error management by ensuring that all failures are replaced with a controlled + * alternative. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const validate = (age: number): Effect.Effect => { + * if (age < 0) { + * return Effect.fail("NegativeAgeError") + * } else if (age < 18) { + * return Effect.fail("IllegalAgeError") + * } else { + * return Effect.succeed(age) + * } + * } + * + * const program = Effect.orElseFail(validate(-1), () => "invalid age") + * + * console.log(Effect.runSyncExit(program)) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'invalid age' } + * // } + * ``` + * + * @see {@link mapError} if you need to access the error to transform it. + * + * @since 2.0.0 + * @category Fallback + */ + (evaluate: LazyArg): (self: Effect) => Effect; + /** + * Replaces the failure of an effect with a custom failure value. + * + * **Details** + * + * This function allows you to handle the failure of an effect by replacing it + * with a predefined failure value. If the effect fails, the new failure value + * provided by the `evaluate` function will be returned instead of the original + * failure. If the effect succeeds, the original success value is returned + * unchanged. + * + * **When to Use** + * + * This is particularly useful when you want to standardize error handling or + * provide a consistent failure value for specific operations. It simplifies + * error management by ensuring that all failures are replaced with a controlled + * alternative. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const validate = (age: number): Effect.Effect => { + * if (age < 0) { + * return Effect.fail("NegativeAgeError") + * } else if (age < 18) { + * return Effect.fail("IllegalAgeError") + * } else { + * return Effect.succeed(age) + * } + * } + * + * const program = Effect.orElseFail(validate(-1), () => "invalid age") + * + * console.log(Effect.runSyncExit(program)) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { _id: 'Cause', _tag: 'Fail', failure: 'invalid age' } + * // } + * ``` + * + * @see {@link mapError} if you need to access the error to transform it. + * + * @since 2.0.0 + * @category Fallback + */ + (self: Effect, evaluate: LazyArg): Effect; +}; +/** + * Ensures the effect always succeeds by replacing failures with a default + * success value. + * + * **Details** + * + * This function transforms an effect that may fail into one that cannot fail by + * replacing any failure with a provided success value. If the original effect + * fails, the failure is "swallowed," and the specified success value is + * returned instead. If the original effect succeeds, its value remains + * unchanged. + * + * **When to Use** + * + * This is especially useful for providing default values in case of failure, + * ensuring that an effect always completes successfully. By using this + * function, you can avoid the need for complex error handling and guarantee a + * fallback result. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const validate = (age: number): Effect.Effect => { + * if (age < 0) { + * return Effect.fail("NegativeAgeError") + * } else if (age < 18) { + * return Effect.fail("IllegalAgeError") + * } else { + * return Effect.succeed(age) + * } + * } + * + * const program = Effect.orElseSucceed(validate(-1), () => 18) + * + * console.log(Effect.runSyncExit(program)) + * // Output: + * // { _id: 'Exit', _tag: 'Success', value: 18 } + * ``` + * + * @since 2.0.0 + * @category Fallback + */ +export declare const orElseSucceed: { + /** + * Ensures the effect always succeeds by replacing failures with a default + * success value. + * + * **Details** + * + * This function transforms an effect that may fail into one that cannot fail by + * replacing any failure with a provided success value. If the original effect + * fails, the failure is "swallowed," and the specified success value is + * returned instead. If the original effect succeeds, its value remains + * unchanged. + * + * **When to Use** + * + * This is especially useful for providing default values in case of failure, + * ensuring that an effect always completes successfully. By using this + * function, you can avoid the need for complex error handling and guarantee a + * fallback result. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const validate = (age: number): Effect.Effect => { + * if (age < 0) { + * return Effect.fail("NegativeAgeError") + * } else if (age < 18) { + * return Effect.fail("IllegalAgeError") + * } else { + * return Effect.succeed(age) + * } + * } + * + * const program = Effect.orElseSucceed(validate(-1), () => 18) + * + * console.log(Effect.runSyncExit(program)) + * // Output: + * // { _id: 'Exit', _tag: 'Success', value: 18 } + * ``` + * + * @since 2.0.0 + * @category Fallback + */ + (evaluate: LazyArg): (self: Effect) => Effect; + /** + * Ensures the effect always succeeds by replacing failures with a default + * success value. + * + * **Details** + * + * This function transforms an effect that may fail into one that cannot fail by + * replacing any failure with a provided success value. If the original effect + * fails, the failure is "swallowed," and the specified success value is + * returned instead. If the original effect succeeds, its value remains + * unchanged. + * + * **When to Use** + * + * This is especially useful for providing default values in case of failure, + * ensuring that an effect always completes successfully. By using this + * function, you can avoid the need for complex error handling and guarantee a + * fallback result. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const validate = (age: number): Effect.Effect => { + * if (age < 0) { + * return Effect.fail("NegativeAgeError") + * } else if (age < 18) { + * return Effect.fail("IllegalAgeError") + * } else { + * return Effect.succeed(age) + * } + * } + * + * const program = Effect.orElseSucceed(validate(-1), () => 18) + * + * console.log(Effect.runSyncExit(program)) + * // Output: + * // { _id: 'Exit', _tag: 'Success', value: 18 } + * ``` + * + * @since 2.0.0 + * @category Fallback + */ + (self: Effect, evaluate: LazyArg): Effect; +}; +/** + * Runs a sequence of effects and returns the result of the first successful + * one. + * + * **Details** + * + * This function allows you to execute a collection of effects in sequence, + * stopping at the first success. If an effect succeeds, its result is + * immediately returned, and no further effects in the sequence are executed. + * However, if all the effects fail, the function will return the error of the + * last effect. + * + * The execution is sequential, meaning that effects are evaluated one at a time + * in the order they are provided. This ensures predictable behavior and avoids + * unnecessary computations. + * + * If the collection of effects is empty, an `IllegalArgumentException` is + * thrown, indicating that the operation is invalid without any effects to try. + * + * **When to Use** + * + * This is particularly useful when you have multiple fallback strategies or + * alternative sources to obtain a result, such as attempting multiple APIs, + * retrieving configurations, or accessing resources in a prioritized manner. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * interface Config { + * host: string + * port: number + * apiKey: string + * } + * + * // Create a configuration object with sample values + * const makeConfig = (name: string): Config => ({ + * host: `${name}.example.com`, + * port: 8080, + * apiKey: "12345-abcde" + * }) + * + * // Simulate retrieving configuration from a remote node + * const remoteConfig = (name: string): Effect.Effect => + * Effect.gen(function* () { + * // Simulate node3 being the only one with available config + * if (name === "node3") { + * yield* Console.log(`Config for ${name} found`) + * return makeConfig(name) + * } else { + * yield* Console.log(`Unavailable config for ${name}`) + * return yield* Effect.fail(new Error(`Config not found for ${name}`)) + * } + * }) + * + * // Define the master configuration and potential fallback nodes + * const masterConfig = remoteConfig("master") + * const nodeConfigs = ["node1", "node2", "node3", "node4"].map(remoteConfig) + * + * // Attempt to find a working configuration, + * // starting with the master and then falling back to other nodes + * const config = Effect.firstSuccessOf([masterConfig, ...nodeConfigs]) + * + * // Run the effect to retrieve the configuration + * const result = Effect.runSync(config) + * + * console.log(result) + * // Output: + * // Unavailable config for master + * // Unavailable config for node1 + * // Unavailable config for node2 + * // Config for node3 found + * // { host: 'node3.example.com', port: 8080, apiKey: '12345-abcde' } + * ``` + * + * @since 2.0.0 + * @category Fallback + */ +export declare const firstSuccessOf: >(effects: Iterable) => Effect, Effect.Error, Effect.Context>; +/** + * Retrieves the `Random` service from the context. + * + * @since 2.0.0 + * @category Random + */ +export declare const random: Effect; +/** + * Retrieves the `Random` service from the context and uses it to run the + * specified effect. + * + * @since 2.0.0 + * @category Random + */ +export declare const randomWith: (f: (random: Random.Random) => Effect) => Effect; +/** + * Executes the specified effect with the specified implementation of the + * `Random` service. + * + * @since 2.0.0 + * @category Random + */ +export declare const withRandom: { + /** + * Executes the specified effect with the specified implementation of the + * `Random` service. + * + * @since 2.0.0 + * @category Random + */ + (value: X): (effect: Effect) => Effect; + /** + * Executes the specified effect with the specified implementation of the + * `Random` service. + * + * @since 2.0.0 + * @category Random + */ + (effect: Effect, value: X): Effect; +}; +/** + * Executes the specified effect with a `Random` service that cycles through + * a provided array of values. + * + * @example + * ```ts + * import { Effect, Random } from "effect" + * + * Effect.gen(function*() { + * console.log(yield* Random.next) // 0.2 + * console.log(yield* Random.next) // 0.5 + * console.log(yield* Random.next) // 0.8 + * }).pipe(Effect.withRandomFixed([0.2, 0.5, 0.8])) + * ``` + * + * @since 3.11.0 + * @category Random + */ +export declare const withRandomFixed: { + /** + * Executes the specified effect with a `Random` service that cycles through + * a provided array of values. + * + * @example + * ```ts + * import { Effect, Random } from "effect" + * + * Effect.gen(function*() { + * console.log(yield* Random.next) // 0.2 + * console.log(yield* Random.next) // 0.5 + * console.log(yield* Random.next) // 0.8 + * }).pipe(Effect.withRandomFixed([0.2, 0.5, 0.8])) + * ``` + * + * @since 3.11.0 + * @category Random + */ + >(values: T): (effect: Effect) => Effect; + /** + * Executes the specified effect with a `Random` service that cycles through + * a provided array of values. + * + * @example + * ```ts + * import { Effect, Random } from "effect" + * + * Effect.gen(function*() { + * console.log(yield* Random.next) // 0.2 + * console.log(yield* Random.next) // 0.5 + * console.log(yield* Random.next) // 0.8 + * }).pipe(Effect.withRandomFixed([0.2, 0.5, 0.8])) + * ``` + * + * @since 3.11.0 + * @category Random + */ + , A, E, R>(effect: Effect, values: T): Effect; +}; +/** + * Sets the implementation of the `Random` service to the specified value and + * restores it to its original value when the scope is closed. + * + * @since 2.0.0 + * @category Random + */ +export declare const withRandomScoped: (value: A) => Effect; +/** + * Returns an effect that accesses the runtime, which can be used to (unsafely) + * execute tasks. + * + * **When to Use** + * + * This is useful for integration with legacy code that must call back into + * Effect code. + * + * @since 2.0.0 + * @category Runtime + */ +export declare const runtime: () => Effect, never, R>; +/** + * Retrieves an effect that succeeds with the current runtime flags, which + * govern behavior and features of the runtime system. + * + * @since 2.0.0 + * @category Runtime + */ +export declare const getRuntimeFlags: Effect; +/** + * @since 2.0.0 + * @category Runtime + */ +export declare const patchRuntimeFlags: (patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect; +/** + * @since 2.0.0 + * @category Runtime + */ +export declare const withRuntimeFlagsPatch: { + /** + * @since 2.0.0 + * @category Runtime + */ + (update: RuntimeFlagsPatch.RuntimeFlagsPatch): (self: Effect) => Effect; + /** + * @since 2.0.0 + * @category Runtime + */ + (self: Effect, update: RuntimeFlagsPatch.RuntimeFlagsPatch): Effect; +}; +/** + * @since 2.0.0 + * @category Runtime + */ +export declare const withRuntimeFlagsPatchScoped: (update: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect; +/** + * Tags each metric in an effect with specific key-value pairs. + * + * **Details** + * + * This function allows you to tag all metrics in an effect with a set of + * key-value pairs or a single key-value pair. Tags help you add metadata to + * metrics, making it easier to filter and categorize them in monitoring + * systems. The provided tags will apply to all metrics generated within the + * effect's scope. + * + * @since 2.0.0 + * @category Metrics + */ +export declare const tagMetrics: { + /** + * Tags each metric in an effect with specific key-value pairs. + * + * **Details** + * + * This function allows you to tag all metrics in an effect with a set of + * key-value pairs or a single key-value pair. Tags help you add metadata to + * metrics, making it easier to filter and categorize them in monitoring + * systems. The provided tags will apply to all metrics generated within the + * effect's scope. + * + * @since 2.0.0 + * @category Metrics + */ + (key: string, value: string): (effect: Effect) => Effect; + /** + * Tags each metric in an effect with specific key-value pairs. + * + * **Details** + * + * This function allows you to tag all metrics in an effect with a set of + * key-value pairs or a single key-value pair. Tags help you add metadata to + * metrics, making it easier to filter and categorize them in monitoring + * systems. The provided tags will apply to all metrics generated within the + * effect's scope. + * + * @since 2.0.0 + * @category Metrics + */ + (values: Record): (effect: Effect) => Effect; + /** + * Tags each metric in an effect with specific key-value pairs. + * + * **Details** + * + * This function allows you to tag all metrics in an effect with a set of + * key-value pairs or a single key-value pair. Tags help you add metadata to + * metrics, making it easier to filter and categorize them in monitoring + * systems. The provided tags will apply to all metrics generated within the + * effect's scope. + * + * @since 2.0.0 + * @category Metrics + */ + (effect: Effect, key: string, value: string): Effect; + /** + * Tags each metric in an effect with specific key-value pairs. + * + * **Details** + * + * This function allows you to tag all metrics in an effect with a set of + * key-value pairs or a single key-value pair. Tags help you add metadata to + * metrics, making it easier to filter and categorize them in monitoring + * systems. The provided tags will apply to all metrics generated within the + * effect's scope. + * + * @since 2.0.0 + * @category Metrics + */ + (effect: Effect, values: Record): Effect; +}; +/** + * Adds labels to metrics within an effect using `MetricLabel` objects. + * + * **Details** + * + * This function allows you to label metrics using `MetricLabel` objects. Labels + * help add structured metadata to metrics for categorization and filtering in + * monitoring systems. The provided labels will apply to all metrics within the + * effect's execution. + * + * @since 2.0.0 + * @category Metrics + */ +export declare const labelMetrics: { + /** + * Adds labels to metrics within an effect using `MetricLabel` objects. + * + * **Details** + * + * This function allows you to label metrics using `MetricLabel` objects. Labels + * help add structured metadata to metrics for categorization and filtering in + * monitoring systems. The provided labels will apply to all metrics within the + * effect's execution. + * + * @since 2.0.0 + * @category Metrics + */ + (labels: Iterable): (self: Effect) => Effect; + /** + * Adds labels to metrics within an effect using `MetricLabel` objects. + * + * **Details** + * + * This function allows you to label metrics using `MetricLabel` objects. Labels + * help add structured metadata to metrics for categorization and filtering in + * monitoring systems. The provided labels will apply to all metrics within the + * effect's execution. + * + * @since 2.0.0 + * @category Metrics + */ + (self: Effect, labels: Iterable): Effect; +}; +/** + * Tags metrics within a scope with a specific key-value pair. + * + * **Details** + * + * This function tags all metrics within a scope with the provided key-value + * pair. Once the scope is closed, the tag is automatically removed. This is + * useful for applying temporary context-specific tags to metrics during scoped + * operations. + * + * @since 2.0.0 + * @category Metrics + */ +export declare const tagMetricsScoped: (key: string, value: string) => Effect; +/** + * Adds labels to metrics within a scope using `MetricLabel` objects. + * + * **Details** + * + * This function allows you to apply labels to all metrics generated within a + * specific scope using an array of `MetricLabel` objects. These labels provide + * additional metadata to metrics, which can be used for categorization, + * filtering, or monitoring purposes. The labels are scoped and will be removed + * automatically once the scope is closed, ensuring they are only applied + * temporarily within the defined context. + * + * @since 2.0.0 + * @category Metrics + */ +export declare const labelMetricsScoped: (labels: ReadonlyArray) => Effect; +/** + * Retrieves the metric labels associated with the current scope. + * + * @since 2.0.0 + * @category Metrics + */ +export declare const metricLabels: Effect>; +/** + * Associates a metric with the current effect, updating it as the effect progresses. + * + * @since 2.0.0 + * @category Metrics + */ +export declare const withMetric: { + /** + * Associates a metric with the current effect, updating it as the effect progresses. + * + * @since 2.0.0 + * @category Metrics + */ + (metric: Metric.Metric): (self: Effect) => Effect; + /** + * Associates a metric with the current effect, updating it as the effect progresses. + * + * @since 2.0.0 + * @category Metrics + */ + (self: Effect, metric: Metric.Metric): Effect; +}; +/** + * @category Semaphore + * @since 2.0.0 + */ +export interface Permit { + readonly index: number; +} +/** + * A semaphore is a synchronization mechanism used to manage access to a shared + * resource. In Effect, semaphores help control resource access or coordinate + * tasks within asynchronous, concurrent operations. + * + * A semaphore acts as a generalized mutex, allowing a set number of permits to + * be held and released concurrently. Permits act like tickets, giving tasks or + * fibers controlled access to a shared resource. When no permits are available, + * tasks trying to acquire one will wait until a permit is released. + * + * @category Semaphore + * @since 2.0.0 + */ +export interface Semaphore { + /** + * Adjusts the number of permits available in the semaphore. + */ + resize(permits: number): Effect; + /** + * Runs an effect with the given number of permits and releases the permits + * when the effect completes. + * + * **Details** + * + * This function acquires the specified number of permits before executing + * the provided effect. Once the effect finishes, the permits are released. + * If insufficient permits are available, the function will wait until they + * are released by other tasks. + */ + withPermits(permits: number): (self: Effect) => Effect; + /** + * Runs an effect only if the specified number of permits are immediately + * available. + * + * **Details** + * + * This function attempts to acquire the specified number of permits. If they + * are available, it runs the effect and releases the permits after the effect + * completes. If permits are not available, the effect does not execute, and + * the result is `Option.none`. + */ + withPermitsIfAvailable(permits: number): (self: Effect) => Effect, E, R>; + /** + * Acquires the specified number of permits and returns the resulting + * available permits, suspending the task if they are not yet available. + * Concurrent pending `take` calls are processed in a first-in, first-out manner. + */ + take(permits: number): Effect; + /** + * Releases the specified number of permits and returns the resulting + * available permits. + */ + release(permits: number): Effect; + /** + * Releases all permits held by this semaphore and returns the resulting available permits. + */ + releaseAll: Effect; +} +/** + * Unsafely creates a new Semaphore. + * + * @since 2.0.0 + * @category Semaphore + */ +export declare const unsafeMakeSemaphore: (permits: number) => Semaphore; +/** + * Creates a new semaphore with the specified number of permits. + * + * **Details** + * + * This function initializes a semaphore that controls concurrent access to a + * shared resource. The number of permits determines how many tasks can access + * the resource concurrently. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // Create a semaphore with 3 permits + * const mutex = Effect.makeSemaphore(3) + * ``` + * + * @since 2.0.0 + * @category Semaphore + */ +export declare const makeSemaphore: (permits: number) => Effect; +/** + * A `Latch` is a synchronization primitive that allows you to control the + * execution of fibers based on an open or closed state. It acts as a gate, + * where fibers can wait for the latch to open before proceeding. + * + * **Details** + * + * A `Latch` can be in one of two states: open or closed. Fibers can: + * - Wait for the latch to open using `await`. + * - Proceed only when the latch is open using `whenOpen`. + * - Open the latch to release all waiting fibers using `open`. + * - Close the latch to block fibers using `close`. + * + * Additionally, fibers can be released without changing the state of the latch + * using `release`. + * + * @category Latch + * @since 3.8.0 + */ +export interface Latch extends Effect { + /** + * Opens the latch, releasing all fibers waiting on it. + * + * **Details** + * + * Once the latch is opened, it remains open. Any fibers waiting on `await` + * will be released and can continue execution. + */ + readonly open: Effect; + /** + * Opens the latch, releasing all fibers waiting on it. + * + * **Details** + * + * Once the latch is opened, it remains open. Any fibers waiting on `await` + * will be released and can continue execution. + */ + readonly unsafeOpen: () => void; + /** + * Releases all fibers waiting on the latch without opening it. + * + * **Details** + * + * This function lets waiting fibers proceed without permanently changing the + * state of the latch. + */ + readonly release: Effect; + /** + * Waits for the latch to be opened. + * + * **Details** + * + * If the latch is already open, this effect completes immediately. Otherwise, + * it suspends the fiber until the latch is opened. + */ + readonly await: Effect; + /** + * Closes the latch, blocking fibers from proceeding. + * + * **Details** + * + * This operation puts the latch into a closed state, requiring it to be + * reopened before waiting fibers can proceed. + */ + readonly close: Effect; + /** + * Unsafely closes the latch, blocking fibers without effect guarantees. + * + * **Details** + * + * Use this operation cautiously, as it does not run within an effect context + * and bypasses runtime guarantees. + */ + readonly unsafeClose: () => void; + /** + * Runs the given effect only when the latch is open. + * + * **Details** + * + * This function ensures that the provided effect executes only if the latch + * is open. If the latch is closed, the fiber will wait until it opens. + */ + readonly whenOpen: (self: Effect) => Effect; + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: LatchUnify; + readonly [Unify.ignoreSymbol]?: LatchUnifyIgnore; +} +/** + * @category Models + * @since 3.8.0 + */ +export interface LatchUnify extends EffectUnify { + Latch?: () => Latch; +} +/** + * @category Models + * @since 3.8.0 + */ +export interface LatchUnifyIgnore extends EffectUnifyIgnore { + Effect?: true; +} +/** + * @category Latch + * @since 3.8.0 + */ +export declare const unsafeMakeLatch: (open?: boolean | undefined) => Latch; +/** + * Creates a new `Latch`, starting in the specified state. + * + * **Details** + * + * This function initializes a `Latch` safely, ensuring proper runtime + * guarantees. By default, the latch starts in the closed state. + * + * **Example** + * + * ```ts + * import { Console, Effect } from "effect" + * + * const program = Effect.gen(function*() { + * // Create a latch, starting in the closed state + * const latch = yield* Effect.makeLatch(false) + * + * // Fork a fiber that logs "open sesame" when the latch is opened + * const fiber = yield* Console.log("open sesame").pipe( + * latch.whenOpen, + * Effect.fork + * ) + * + * yield* Effect.sleep("1 second") + * + * // Open the latch + * yield* latch.open + * yield* fiber.await + * }) + * + * Effect.runFork(program) + * // Output: open sesame (after 1 second) + * ``` + * + * @category Latch + * @since 3.8.0 + */ +export declare const makeLatch: (open?: boolean | undefined) => Effect; +/** + * Runs an effect in the background, returning a fiber that can be observed or + * interrupted. + * + * Unless you specifically need a `Promise` or synchronous operation, `runFork` + * is a good default choice. + * + * **Details** + * + * This function is the foundational way to execute an effect in the background. + * It creates a "fiber," a lightweight, cooperative thread of execution that can + * be observed (to access its result), interrupted, or joined. Fibers are useful + * for concurrent programming and allow effects to run independently of the main + * program flow. + * + * Once the effect is running in a fiber, you can monitor its progress, cancel + * it if necessary, or retrieve its result when it completes. If the effect + * fails, the fiber will propagate the failure, which you can observe and + * handle. + * + * **When to Use** + * + * Use this function when you need to run an effect in the background, + * especially if the effect is long-running or performs periodic tasks. It's + * suitable for tasks that need to run independently but might still need + * observation or management, like logging, monitoring, or scheduled tasks. + * + * This function is ideal if you don't need the result immediately or if the + * effect is part of a larger concurrent workflow. + * + * **Example** (Running an Effect in the Background) + * + * ```ts + * import { Effect, Console, Schedule, Fiber } from "effect" + * + * // ┌─── Effect + * // ▼ + * const program = Effect.repeat( + * Console.log("running..."), + * Schedule.spaced("200 millis") + * ) + * + * // ┌─── RuntimeFiber + * // ▼ + * const fiber = Effect.runFork(program) + * + * setTimeout(() => { + * Effect.runFork(Fiber.interrupt(fiber)) + * }, 500) + * ``` + * + * @since 2.0.0 + * @category Running Effects + */ +export declare const runFork: (effect: Effect, options?: Runtime.RunForkOptions) => Fiber.RuntimeFiber; +/** + * Executes an effect asynchronously and handles the result using a callback. + * + * **Details** + * + * This function runs an effect asynchronously and passes the result (`Exit`) to + * a specified callback. The callback is invoked with the outcome of the effect: + * - On success, the callback receives the successful result. + * - On failure, the callback receives the failure information. + * + * **When to Use** + * + * This function is effectful and should only be invoked at the edges of your + * program. + * + * @since 2.0.0 + * @category Running Effects + */ +export declare const runCallback: (effect: Effect, options?: Runtime.RunCallbackOptions | undefined) => Runtime.Cancel; +/** + * Executes an effect and returns the result as a `Promise`. + * + * **Details** + * + * This function runs an effect and converts its result into a `Promise`. If the + * effect succeeds, the `Promise` will resolve with the successful result. If + * the effect fails, the `Promise` will reject with an error, which includes the + * failure details of the effect. + * + * The optional `options` parameter allows you to pass an `AbortSignal` for + * cancellation, enabling more fine-grained control over asynchronous tasks. + * + * **When to Use** + * + * Use this function when you need to execute an effect and work with its result + * in a promise-based system, such as when integrating with third-party + * libraries that expect `Promise` results. + * + * **Example** (Running a Successful Effect as a Promise) + * + * ```ts + * import { Effect } from "effect" + * + * Effect.runPromise(Effect.succeed(1)).then(console.log) + * // Output: 1 + * ``` + * + * **Example** (Handling a Failing Effect as a Rejected Promise) + * + * ```ts + * import { Effect } from "effect" + * + * Effect.runPromise(Effect.fail("my error")).catch(console.error) + * // Output: + * // (FiberFailure) Error: my error + * ``` + * + * @see {@link runPromiseExit} for a version that returns an `Exit` type instead + * of rejecting. + * + * @since 2.0.0 + * @category Running Effects + */ +export declare const runPromise: (effect: Effect, options?: { + readonly signal?: AbortSignal | undefined; +} | undefined) => Promise; +/** + * Runs an effect and returns a `Promise` that resolves to an `Exit`, + * representing the outcome. + * + * **Details** + * + * This function executes an effect and resolves to an `Exit` object. The `Exit` + * type provides detailed information about the result of the effect: + * - If the effect succeeds, the `Exit` will be of type `Success` and include + * the value produced by the effect. + * - If the effect fails, the `Exit` will be of type `Failure` and contain a + * `Cause` object, detailing the failure. + * + * Using this function allows you to examine both successful results and failure + * cases in a unified way, while still leveraging `Promise` for handling the + * asynchronous behavior of the effect. + * + * **When to Use** + * + * Use this function when you need to understand the outcome of an effect, + * whether it succeeded or failed, and want to work with this result using + * `Promise` syntax. This is particularly useful when integrating with systems + * that rely on promises but need more detailed error handling than a simple + * rejection. + * + * **Example** (Handling Results as Exit) + * + * ```ts + * import { Effect } from "effect" + * + * // Execute a successful effect and get the Exit result as a Promise + * Effect.runPromiseExit(Effect.succeed(1)).then(console.log) + * // Output: + * // { + * // _id: "Exit", + * // _tag: "Success", + * // value: 1 + * // } + * + * // Execute a failing effect and get the Exit result as a Promise + * Effect.runPromiseExit(Effect.fail("my error")).then(console.log) + * // Output: + * // { + * // _id: "Exit", + * // _tag: "Failure", + * // cause: { + * // _id: "Cause", + * // _tag: "Fail", + * // failure: "my error" + * // } + * // } + * ``` + * + * @since 2.0.0 + * @category Running Effects + */ +export declare const runPromiseExit: (effect: Effect, options?: { + readonly signal?: AbortSignal; +} | undefined) => Promise>; +/** + * Executes an effect synchronously, running it immediately and returning the + * result. + * + * **Details** + * + * This function evaluates the provided effect synchronously, returning its + * result directly. It is ideal for effects that do not fail or include + * asynchronous operations. If the effect does fail or involves async tasks, it + * will throw an error. Execution stops at the point of failure or asynchronous + * operation, making it unsuitable for effects that require asynchronous + * handling. + * + * **Important**: Attempting to run effects that involve asynchronous operations + * or failures will result in exceptions being thrown, so use this function with + * care for purely synchronous and error-free effects. + * + * **When to Use** + * + * Use this function when: + * - You are sure that the effect will not fail or involve asynchronous + * operations. + * - You need a direct, synchronous result from the effect. + * - You are working within a context where asynchronous effects are not + * allowed. + * + * Avoid using this function for effects that can fail or require asynchronous + * handling. For such cases, consider using {@link runPromise} or + * {@link runSyncExit}. + * + * **Example** (Synchronous Logging) + * + * ```ts + * import { Effect } from "effect" + * + * const program = Effect.sync(() => { + * console.log("Hello, World!") + * return 1 + * }) + * + * const result = Effect.runSync(program) + * // Output: Hello, World! + * + * console.log(result) + * // Output: 1 + * ``` + * + * **Example** (Incorrect Usage with Failing or Async Effects) + * + * ```ts + * import { Effect } from "effect" + * + * try { + * // Attempt to run an effect that fails + * Effect.runSync(Effect.fail("my error")) + * } catch (e) { + * console.error(e) + * } + * // Output: + * // (FiberFailure) Error: my error + * + * try { + * // Attempt to run an effect that involves async work + * Effect.runSync(Effect.promise(() => Promise.resolve(1))) + * } catch (e) { + * console.error(e) + * } + * // Output: + * // (FiberFailure) AsyncFiberException: Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work + * ``` + * + * @see {@link runSyncExit} for a version that returns an `Exit` type instead of + * throwing an error. + * + * @since 2.0.0 + * @category Running Effects + */ +export declare const runSync: (effect: Effect) => A; +/** + * Runs an effect synchronously and returns the result as an `Exit` type. + * + * **Details** + * + * This function executes the provided effect synchronously and returns an `Exit` + * type that encapsulates the outcome of the effect: + * - If the effect succeeds, the result is wrapped in a `Success`. + * - If the effect fails, it returns a `Failure` containing a `Cause` that explains + * the failure. + * + * If the effect involves asynchronous operations, this function will return a `Failure` + * with a `Die` cause, indicating that it cannot resolve the effect synchronously. + * This makes the function suitable for use only with effects that are synchronous + * in nature. + * + * **When to Use** + * + * Use this function when: + * - You want to handle both success and failure outcomes in a structured way using the `Exit` type. + * - You are working with effects that are purely synchronous and do not involve asynchronous operations. + * - You need to debug or inspect failures, including their causes, in a detailed manner. + * + * Avoid using this function for effects that involve asynchronous operations, as it will fail with a `Die` cause. + * + * **Example** (Handling Results as Exit) + * + * ```ts + * import { Effect } from "effect" + * + * console.log(Effect.runSyncExit(Effect.succeed(1))) + * // Output: + * // { + * // _id: "Exit", + * // _tag: "Success", + * // value: 1 + * // } + * + * console.log(Effect.runSyncExit(Effect.fail("my error"))) + * // Output: + * // { + * // _id: "Exit", + * // _tag: "Failure", + * // cause: { + * // _id: "Cause", + * // _tag: "Fail", + * // failure: "my error" + * // } + * // } + * ``` + * + * **Example** (Asynchronous Operation Resulting in Die) + * + * ```ts + * import { Effect } from "effect" + * + * console.log(Effect.runSyncExit(Effect.promise(() => Promise.resolve(1)))) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Die', + * // defect: [Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work] { + * // fiber: [FiberRuntime], + * // _tag: 'AsyncFiberException', + * // name: 'AsyncFiberException' + * // } + * // } + * // } + * ``` + * + * @since 2.0.0 + * @category Running Effects + */ +export declare const runSyncExit: (effect: Effect) => Exit.Exit; +/** + * Combines multiple effects and accumulates both successes and failures. + * + * **Details** + * + * This function allows you to combine multiple effects, continuing through all + * effects even if some of them fail. Unlike other functions that stop execution + * upon encountering an error, this function collects all errors into a `Cause`. + * The final result includes all successes and the accumulated failures. + * + * By default, effects are executed sequentially, but you can control + * concurrency and batching behavior using the `options` parameter. This + * provides flexibility in scenarios where you want to maximize performance or + * ensure specific ordering. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Console.log("task1").pipe(Effect.as(1)) + * const task2 = Effect.fail("Oh uh!").pipe(Effect.as(2)) + * const task3 = Console.log("task2").pipe(Effect.as(3)) + * const task4 = Effect.fail("Oh no!").pipe(Effect.as(4)) + * + * const program = task1.pipe( + * Effect.validate(task2), + * Effect.validate(task3), + * Effect.validate(task4) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 + * // task2 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Sequential', + * // left: { _id: 'Cause', _tag: 'Fail', failure: 'Oh uh!' }, + * // right: { _id: 'Cause', _tag: 'Fail', failure: 'Oh no!' } + * // } + * // } + * ``` + * + * @see {@link zip} for a version that stops at the first error. + * + * @since 2.0.0 + * @category Error Accumulation + */ +export declare const validate: { + /** + * Combines multiple effects and accumulates both successes and failures. + * + * **Details** + * + * This function allows you to combine multiple effects, continuing through all + * effects even if some of them fail. Unlike other functions that stop execution + * upon encountering an error, this function collects all errors into a `Cause`. + * The final result includes all successes and the accumulated failures. + * + * By default, effects are executed sequentially, but you can control + * concurrency and batching behavior using the `options` parameter. This + * provides flexibility in scenarios where you want to maximize performance or + * ensure specific ordering. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Console.log("task1").pipe(Effect.as(1)) + * const task2 = Effect.fail("Oh uh!").pipe(Effect.as(2)) + * const task3 = Console.log("task2").pipe(Effect.as(3)) + * const task4 = Effect.fail("Oh no!").pipe(Effect.as(4)) + * + * const program = task1.pipe( + * Effect.validate(task2), + * Effect.validate(task3), + * Effect.validate(task4) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 + * // task2 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Sequential', + * // left: { _id: 'Cause', _tag: 'Fail', failure: 'Oh uh!' }, + * // right: { _id: 'Cause', _tag: 'Fail', failure: 'Oh no!' } + * // } + * // } + * ``` + * + * @see {@link zip} for a version that stops at the first error. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (self: Effect) => Effect<[A, B], E1 | E, R1 | R>; + /** + * Combines multiple effects and accumulates both successes and failures. + * + * **Details** + * + * This function allows you to combine multiple effects, continuing through all + * effects even if some of them fail. Unlike other functions that stop execution + * upon encountering an error, this function collects all errors into a `Cause`. + * The final result includes all successes and the accumulated failures. + * + * By default, effects are executed sequentially, but you can control + * concurrency and batching behavior using the `options` parameter. This + * provides flexibility in scenarios where you want to maximize performance or + * ensure specific ordering. + * + * **Example** + * + * ```ts + * import { Effect, Console } from "effect" + * + * const task1 = Console.log("task1").pipe(Effect.as(1)) + * const task2 = Effect.fail("Oh uh!").pipe(Effect.as(2)) + * const task3 = Console.log("task2").pipe(Effect.as(3)) + * const task4 = Effect.fail("Oh no!").pipe(Effect.as(4)) + * + * const program = task1.pipe( + * Effect.validate(task2), + * Effect.validate(task3), + * Effect.validate(task4) + * ) + * + * Effect.runPromiseExit(program).then(console.log) + * // Output: + * // task1 + * // task2 + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Sequential', + * // left: { _id: 'Cause', _tag: 'Fail', failure: 'Oh uh!' }, + * // right: { _id: 'Cause', _tag: 'Fail', failure: 'Oh no!' } + * // } + * // } + * ``` + * + * @see {@link zip} for a version that stops at the first error. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (self: Effect, that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect<[A, B], E | E1, R | R1>; +}; +/** + * Sequentially combines two effects using a specified combiner function while + * accumulating errors. + * + * **Details** + * + * This function combines two effects, `self` and `that`, into a single effect + * by applying the provided combiner function to their results. If both effects + * succeed, the combiner function is applied to their results to produce the + * final value. If either effect fails, the failures are accumulated into a + * combined `Cause`. + * + * By default, effects are executed sequentially. However, the execution mode + * can be controlled using the `options` parameter to enable concurrency, + * batching, or customized finalizer behavior. + * + * @since 2.0.0 + * @category Error Accumulation + */ +export declare const validateWith: { + /** + * Sequentially combines two effects using a specified combiner function while + * accumulating errors. + * + * **Details** + * + * This function combines two effects, `self` and `that`, into a single effect + * by applying the provided combiner function to their results. If both effects + * succeed, the combiner function is applied to their results to produce the + * final value. If either effect fails, the failures are accumulated into a + * combined `Cause`. + * + * By default, effects are executed sequentially. However, the execution mode + * can be controlled using the `options` parameter to enable concurrency, + * batching, or customized finalizer behavior. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (that: Effect, f: (a: A, b: B) => C, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (self: Effect) => Effect; + /** + * Sequentially combines two effects using a specified combiner function while + * accumulating errors. + * + * **Details** + * + * This function combines two effects, `self` and `that`, into a single effect + * by applying the provided combiner function to their results. If both effects + * succeed, the combiner function is applied to their results to produce the + * final value. If either effect fails, the failures are accumulated into a + * combined `Cause`. + * + * By default, effects are executed sequentially. However, the execution mode + * can be controlled using the `options` parameter to enable concurrency, + * batching, or customized finalizer behavior. + * + * @since 2.0.0 + * @category Error Accumulation + */ + (self: Effect, that: Effect, f: (a: A, b: B) => C, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect; +}; +/** + * Combines two effects into a single effect, producing a tuple of their + * results. + * + * **Details** + * + * This function combines two effects, `self` and `that`, into one. It executes + * the first effect (`self`) and then the second effect (`that`), collecting + * their results into a tuple. Both effects must succeed for the resulting + * effect to succeed. If either effect fails, the entire operation fails. + * + * By default, the effects are executed sequentially. If the `concurrent` option + * is set to `true`, the effects will run concurrently, potentially improving + * performance for independent operations. + * + * **Example** (Combining Two Effects Sequentially) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * // Combine the two effects together + * // + * // ┌─── Effect<[number, string], never, never> + * // ▼ + * const program = Effect.zip(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // [ 1, 'hello' ] + * ``` + * + * **Example** (Combining Two Effects Concurrently) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * // Run both effects concurrently using the concurrent option + * const program = Effect.zip(task1, task2, { concurrent: true }) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // [ 1, 'hello' ] + * ``` + * + * @see {@link zipWith} for a version that combines the results with a custom + * function. + * @see {@link validate} for a version that accumulates errors. + * + * @since 2.0.0 + * @category Zipping + */ +export declare const zip: { + /** + * Combines two effects into a single effect, producing a tuple of their + * results. + * + * **Details** + * + * This function combines two effects, `self` and `that`, into one. It executes + * the first effect (`self`) and then the second effect (`that`), collecting + * their results into a tuple. Both effects must succeed for the resulting + * effect to succeed. If either effect fails, the entire operation fails. + * + * By default, the effects are executed sequentially. If the `concurrent` option + * is set to `true`, the effects will run concurrently, potentially improving + * performance for independent operations. + * + * **Example** (Combining Two Effects Sequentially) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * // Combine the two effects together + * // + * // ┌─── Effect<[number, string], never, never> + * // ▼ + * const program = Effect.zip(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // [ 1, 'hello' ] + * ``` + * + * **Example** (Combining Two Effects Concurrently) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * // Run both effects concurrently using the concurrent option + * const program = Effect.zip(task1, task2, { concurrent: true }) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // [ 1, 'hello' ] + * ``` + * + * @see {@link zipWith} for a version that combines the results with a custom + * function. + * @see {@link validate} for a version that accumulates errors. + * + * @since 2.0.0 + * @category Zipping + */ + (that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (self: Effect) => Effect<[A, A2], E2 | E, R2 | R>; + /** + * Combines two effects into a single effect, producing a tuple of their + * results. + * + * **Details** + * + * This function combines two effects, `self` and `that`, into one. It executes + * the first effect (`self`) and then the second effect (`that`), collecting + * their results into a tuple. Both effects must succeed for the resulting + * effect to succeed. If either effect fails, the entire operation fails. + * + * By default, the effects are executed sequentially. If the `concurrent` option + * is set to `true`, the effects will run concurrently, potentially improving + * performance for independent operations. + * + * **Example** (Combining Two Effects Sequentially) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * // Combine the two effects together + * // + * // ┌─── Effect<[number, string], never, never> + * // ▼ + * const program = Effect.zip(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // [ 1, 'hello' ] + * ``` + * + * **Example** (Combining Two Effects Concurrently) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * // Run both effects concurrently using the concurrent option + * const program = Effect.zip(task1, task2, { concurrent: true }) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // [ 1, 'hello' ] + * ``` + * + * @see {@link zipWith} for a version that combines the results with a custom + * function. + * @see {@link validate} for a version that accumulates errors. + * + * @since 2.0.0 + * @category Zipping + */ + (self: Effect, that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect<[A, A2], E | E2, R | R2>; +}; +/** + * Executes two effects sequentially, returning the result of the first effect + * and ignoring the result of the second. + * + * **Details** + * + * This function allows you to run two effects in sequence, where the result of + * the first effect is preserved, and the result of the second effect is + * discarded. By default, the two effects are executed sequentially. If you need + * them to run concurrently, you can pass the `{ concurrent: true }` option. + * + * The second effect will always be executed, even though its result is ignored. + * This makes it useful for cases where you want to execute an effect for its + * side effects while keeping the result of another effect. + * + * **When to Use** + * + * Use this function when you are only interested in the result of the first + * effect but still need to run the second effect for its side effects, such as + * logging or performing a cleanup action. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const program = Effect.zipLeft(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // 1 + * ``` + * + * @see {@link zipRight} for a version that returns the result of the second + * effect. + * + * @since 2.0.0 + * @category Zipping + */ +export declare const zipLeft: { + /** + * Executes two effects sequentially, returning the result of the first effect + * and ignoring the result of the second. + * + * **Details** + * + * This function allows you to run two effects in sequence, where the result of + * the first effect is preserved, and the result of the second effect is + * discarded. By default, the two effects are executed sequentially. If you need + * them to run concurrently, you can pass the `{ concurrent: true }` option. + * + * The second effect will always be executed, even though its result is ignored. + * This makes it useful for cases where you want to execute an effect for its + * side effects while keeping the result of another effect. + * + * **When to Use** + * + * Use this function when you are only interested in the result of the first + * effect but still need to run the second effect for its side effects, such as + * logging or performing a cleanup action. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const program = Effect.zipLeft(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // 1 + * ``` + * + * @see {@link zipRight} for a version that returns the result of the second + * effect. + * + * @since 2.0.0 + * @category Zipping + */ + (that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): (self: Effect) => Effect; + /** + * Executes two effects sequentially, returning the result of the first effect + * and ignoring the result of the second. + * + * **Details** + * + * This function allows you to run two effects in sequence, where the result of + * the first effect is preserved, and the result of the second effect is + * discarded. By default, the two effects are executed sequentially. If you need + * them to run concurrently, you can pass the `{ concurrent: true }` option. + * + * The second effect will always be executed, even though its result is ignored. + * This makes it useful for cases where you want to execute an effect for its + * side effects while keeping the result of another effect. + * + * **When to Use** + * + * Use this function when you are only interested in the result of the first + * effect but still need to run the second effect for its side effects, such as + * logging or performing a cleanup action. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const program = Effect.zipLeft(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // 1 + * ``` + * + * @see {@link zipRight} for a version that returns the result of the second + * effect. + * + * @since 2.0.0 + * @category Zipping + */ + (self: Effect, that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + } | undefined): Effect; +}; +/** + * Executes two effects sequentially, returning the result of the second effect + * while ignoring the result of the first. + * + * **Details** + * + * This function allows you to run two effects in sequence, keeping the result + * of the second effect and discarding the result of the first. By default, the + * two effects are executed sequentially. If you need them to run concurrently, + * you can pass the `{ concurrent: true }` option. + * + * The first effect will always be executed, even though its result is ignored. + * This makes it useful for scenarios where the first effect is needed for its + * side effects, but only the result of the second effect is important. + * + * **When to Use** + * + * Use this function when you are only interested in the result of the second + * effect but still need to run the first effect for its side effects, such as + * initialization or setup tasks. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const program = Effect.zipRight(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // hello + * ``` + * + * @see {@link zipLeft} for a version that returns the result of the first + * effect. + * + * @since 2.0.0 + * @category Zipping + */ +export declare const zipRight: { + /** + * Executes two effects sequentially, returning the result of the second effect + * while ignoring the result of the first. + * + * **Details** + * + * This function allows you to run two effects in sequence, keeping the result + * of the second effect and discarding the result of the first. By default, the + * two effects are executed sequentially. If you need them to run concurrently, + * you can pass the `{ concurrent: true }` option. + * + * The first effect will always be executed, even though its result is ignored. + * This makes it useful for scenarios where the first effect is needed for its + * side effects, but only the result of the second effect is important. + * + * **When to Use** + * + * Use this function when you are only interested in the result of the second + * effect but still need to run the first effect for its side effects, such as + * initialization or setup tasks. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const program = Effect.zipRight(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // hello + * ``` + * + * @see {@link zipLeft} for a version that returns the result of the first + * effect. + * + * @since 2.0.0 + * @category Zipping + */ + (that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }): (self: Effect) => Effect; + /** + * Executes two effects sequentially, returning the result of the second effect + * while ignoring the result of the first. + * + * **Details** + * + * This function allows you to run two effects in sequence, keeping the result + * of the second effect and discarding the result of the first. By default, the + * two effects are executed sequentially. If you need them to run concurrently, + * you can pass the `{ concurrent: true }` option. + * + * The first effect will always be executed, even though its result is ignored. + * This makes it useful for scenarios where the first effect is needed for its + * side effects, but only the result of the second effect is important. + * + * **When to Use** + * + * Use this function when you are only interested in the result of the second + * effect but still need to run the first effect for its side effects, such as + * initialization or setup tasks. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const program = Effect.zipRight(task1, task2) + * + * Effect.runPromise(program).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#0 message="task1 done" + * // timestamp=... level=INFO fiber=#0 message="task2 done" + * // hello + * ``` + * + * @see {@link zipLeft} for a version that returns the result of the first + * effect. + * + * @since 2.0.0 + * @category Zipping + */ + (self: Effect, that: Effect, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }): Effect; +}; +/** + * Combines two effects sequentially and applies a function to their results to + * produce a single value. + * + * **Details** + * + * This function runs two effects in sequence (or concurrently, if the `{ + * concurrent: true }` option is provided) and combines their results using a + * provided function. Unlike {@link zip}, which returns a tuple of the results, + * this function processes the results with a custom function to produce a + * single output. + * + * **Example** (Combining Effects with a Custom Function) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const task3 = Effect.zipWith( + * task1, + * task2, + * // Combines results into a single value + * (number, string) => number + string.length + * ) + * + * Effect.runPromise(task3).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#3 message="task1 done" + * // timestamp=... level=INFO fiber=#2 message="task2 done" + * // 6 + * ``` + * + * @since 2.0.0 + * @category Zipping + */ +export declare const zipWith: { + /** + * Combines two effects sequentially and applies a function to their results to + * produce a single value. + * + * **Details** + * + * This function runs two effects in sequence (or concurrently, if the `{ + * concurrent: true }` option is provided) and combines their results using a + * provided function. Unlike {@link zip}, which returns a tuple of the results, + * this function processes the results with a custom function to produce a + * single output. + * + * **Example** (Combining Effects with a Custom Function) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const task3 = Effect.zipWith( + * task1, + * task2, + * // Combines results into a single value + * (number, string) => number + string.length + * ) + * + * Effect.runPromise(task3).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#3 message="task1 done" + * // timestamp=... level=INFO fiber=#2 message="task2 done" + * // 6 + * ``` + * + * @since 2.0.0 + * @category Zipping + */ + (that: Effect, f: (a: A, b: A2) => B, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }): (self: Effect) => Effect; + /** + * Combines two effects sequentially and applies a function to their results to + * produce a single value. + * + * **Details** + * + * This function runs two effects in sequence (or concurrently, if the `{ + * concurrent: true }` option is provided) and combines their results using a + * provided function. Unlike {@link zip}, which returns a tuple of the results, + * this function processes the results with a custom function to produce a + * single output. + * + * **Example** (Combining Effects with a Custom Function) + * + * ```ts + * import { Effect } from "effect" + * + * const task1 = Effect.succeed(1).pipe( + * Effect.delay("200 millis"), + * Effect.tap(Effect.log("task1 done")) + * ) + * const task2 = Effect.succeed("hello").pipe( + * Effect.delay("100 millis"), + * Effect.tap(Effect.log("task2 done")) + * ) + * + * const task3 = Effect.zipWith( + * task1, + * task2, + * // Combines results into a single value + * (number, string) => number + string.length + * ) + * + * Effect.runPromise(task3).then(console.log) + * // Output: + * // timestamp=... level=INFO fiber=#3 message="task1 done" + * // timestamp=... level=INFO fiber=#2 message="task2 done" + * // 6 + * ``` + * + * @since 2.0.0 + * @category Zipping + */ + (self: Effect, that: Effect, f: (a: A, b: A2) => B, options?: { + readonly concurrent?: boolean | undefined; + readonly batching?: boolean | "inherit" | undefined; + readonly concurrentFinalizers?: boolean | undefined; + }): Effect; +}; +/** + * Applies the function produced by one effect to the value produced by another effect. + * + * **Details** + * + * This function combines two effects: + * - The first effect produces a function of type `(a: A) => B`. + * - The second effect produces a value of type `A`. + * + * Once both effects complete successfully, the function is applied to the value, resulting in an effect that produces a value of type `B`. + * + * @since 2.0.0 + */ +export declare const ap: { + /** + * Applies the function produced by one effect to the value produced by another effect. + * + * **Details** + * + * This function combines two effects: + * - The first effect produces a function of type `(a: A) => B`. + * - The second effect produces a value of type `A`. + * + * Once both effects complete successfully, the function is applied to the value, resulting in an effect that produces a value of type `B`. + * + * @since 2.0.0 + */ + (that: Effect): (self: Effect<(a: A) => B, E, R>) => Effect; + /** + * Applies the function produced by one effect to the value produced by another effect. + * + * **Details** + * + * This function combines two effects: + * - The first effect produces a function of type `(a: A) => B`. + * - The second effect produces a value of type `A`. + * + * Once both effects complete successfully, the function is applied to the value, resulting in an effect that produces a value of type `B`. + * + * @since 2.0.0 + */ + (self: Effect<(a: A) => B, E, R>, that: Effect): Effect; +}; +/** + * @category Requests & Batching + * @since 2.0.0 + */ +export declare const blocked: (blockedRequests: RequestBlock, _continue: Effect) => Blocked; +/** + * @category Requests & Batching + * @since 2.0.0 + */ +export declare const runRequestBlock: (blockedRequests: RequestBlock) => Effect; +/** + * @category Requests & Batching + * @since 2.0.0 + */ +export declare const step: (self: Effect) => Effect | Blocked, never, R>; +/** + * @since 2.0.0 + * @category Requests & Batching + */ +export declare const request: { + /** + * @since 2.0.0 + * @category Requests & Batching + */ + , Ds extends RequestResolver | Effect, any, any>>(dataSource: Ds): (self: A) => Effect, Request.Request.Error, [ + Ds + ] extends [Effect] ? Effect.Context : never>; + /** + * @since 2.0.0 + * @category Requests & Batching + */ + | Effect, any, any>, A extends Request.Request>(self: A, dataSource: Ds): Effect, Request.Request.Error, [ + Ds + ] extends [Effect] ? Effect.Context : never>; +}; +/** + * @since 2.0.0 + * @category Requests & Batching + */ +export declare const cacheRequestResult: >(request: A, result: Request.Request.Result) => Effect; +/** + * @since 2.0.0 + * @category Requests & Batching + */ +export declare const withRequestBatching: { + /** + * @since 2.0.0 + * @category Requests & Batching + */ + (requestBatching: boolean): (self: Effect) => Effect; + /** + * @since 2.0.0 + * @category Requests & Batching + */ + (self: Effect, requestBatching: boolean): Effect; +}; +/** + * @since 2.0.0 + * @category Requests & Batching + */ +export declare const withRequestCaching: { + /** + * @since 2.0.0 + * @category Requests & Batching + */ + (strategy: boolean): (self: Effect) => Effect; + /** + * @since 2.0.0 + * @category Requests & Batching + */ + (self: Effect, strategy: boolean): Effect; +}; +/** + * @since 2.0.0 + * @category Requests & Batching + */ +export declare const withRequestCache: { + /** + * @since 2.0.0 + * @category Requests & Batching + */ + (cache: Request.Cache): (self: Effect) => Effect; + /** + * @since 2.0.0 + * @category Requests & Batching + */ + (self: Effect, cache: Request.Cache): Effect; +}; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const tracer: Effect; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const tracerWith: (f: (tracer: Tracer.Tracer) => Effect) => Effect; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const withTracer: { + /** + * @since 2.0.0 + * @category Tracing + */ + (value: Tracer.Tracer): (effect: Effect) => Effect; + /** + * @since 2.0.0 + * @category Tracing + */ + (effect: Effect, value: Tracer.Tracer): Effect; +}; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const withTracerScoped: (value: Tracer.Tracer) => Effect; +/** + * Disable the tracer for the given Effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * Effect.succeed(42).pipe( + * Effect.withSpan("my-span"), + * // the span will not be registered with the tracer + * Effect.withTracerEnabled(false) + * ) + * ``` + * + * @since 2.0.0 + * @category Tracing + */ +export declare const withTracerEnabled: { + /** + * Disable the tracer for the given Effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * Effect.succeed(42).pipe( + * Effect.withSpan("my-span"), + * // the span will not be registered with the tracer + * Effect.withTracerEnabled(false) + * ) + * ``` + * + * @since 2.0.0 + * @category Tracing + */ + (enabled: boolean): (effect: Effect) => Effect; + /** + * Disable the tracer for the given Effect. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * Effect.succeed(42).pipe( + * Effect.withSpan("my-span"), + * // the span will not be registered with the tracer + * Effect.withTracerEnabled(false) + * ) + * ``` + * + * @since 2.0.0 + * @category Tracing + */ + (effect: Effect, enabled: boolean): Effect; +}; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const withTracerTiming: { + /** + * @since 2.0.0 + * @category Tracing + */ + (enabled: boolean): (effect: Effect) => Effect; + /** + * @since 2.0.0 + * @category Tracing + */ + (effect: Effect, enabled: boolean): Effect; +}; +/** + * Adds annotations to each span in the effect for enhanced traceability. + * + * **Details** + * + * This function lets you attach key-value annotations to all spans generated + * during the execution of an effect. Annotations provide additional context, + * such as metadata or labels, which can help you understand and debug + * asynchronous workflows more effectively. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the spans. These annotations can then be visualized in tracing tools + * that support span annotations. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const annotateSpans: { + /** + * Adds annotations to each span in the effect for enhanced traceability. + * + * **Details** + * + * This function lets you attach key-value annotations to all spans generated + * during the execution of an effect. Annotations provide additional context, + * such as metadata or labels, which can help you understand and debug + * asynchronous workflows more effectively. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the spans. These annotations can then be visualized in tracing tools + * that support span annotations. + * + * @since 2.0.0 + * @category Tracing + */ + (key: string, value: unknown): (effect: Effect) => Effect; + /** + * Adds annotations to each span in the effect for enhanced traceability. + * + * **Details** + * + * This function lets you attach key-value annotations to all spans generated + * during the execution of an effect. Annotations provide additional context, + * such as metadata or labels, which can help you understand and debug + * asynchronous workflows more effectively. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the spans. These annotations can then be visualized in tracing tools + * that support span annotations. + * + * @since 2.0.0 + * @category Tracing + */ + (values: Record): (effect: Effect) => Effect; + /** + * Adds annotations to each span in the effect for enhanced traceability. + * + * **Details** + * + * This function lets you attach key-value annotations to all spans generated + * during the execution of an effect. Annotations provide additional context, + * such as metadata or labels, which can help you understand and debug + * asynchronous workflows more effectively. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the spans. These annotations can then be visualized in tracing tools + * that support span annotations. + * + * @since 2.0.0 + * @category Tracing + */ + (effect: Effect, key: string, value: unknown): Effect; + /** + * Adds annotations to each span in the effect for enhanced traceability. + * + * **Details** + * + * This function lets you attach key-value annotations to all spans generated + * during the execution of an effect. Annotations provide additional context, + * such as metadata or labels, which can help you understand and debug + * asynchronous workflows more effectively. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the spans. These annotations can then be visualized in tracing tools + * that support span annotations. + * + * @since 2.0.0 + * @category Tracing + */ + (effect: Effect, values: Record): Effect; +}; +/** + * Adds annotations to the currently active span for traceability. + * + * **Details** + * + * This function adds key-value annotations to the currently active span in the + * effect's trace. These annotations help provide more context about the + * operation being executed at a specific point in time. Unlike + * {@link annotateSpans}, which applies to all spans in an effect, this function + * focuses solely on the active span. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the span. These annotations are useful for adding metadata to + * operations, especially in systems with detailed observability requirements. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const annotateCurrentSpan: { + /** + * Adds annotations to the currently active span for traceability. + * + * **Details** + * + * This function adds key-value annotations to the currently active span in the + * effect's trace. These annotations help provide more context about the + * operation being executed at a specific point in time. Unlike + * {@link annotateSpans}, which applies to all spans in an effect, this function + * focuses solely on the active span. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the span. These annotations are useful for adding metadata to + * operations, especially in systems with detailed observability requirements. + * + * @since 2.0.0 + * @category Tracing + */ + (key: string, value: unknown): Effect; + /** + * Adds annotations to the currently active span for traceability. + * + * **Details** + * + * This function adds key-value annotations to the currently active span in the + * effect's trace. These annotations help provide more context about the + * operation being executed at a specific point in time. Unlike + * {@link annotateSpans}, which applies to all spans in an effect, this function + * focuses solely on the active span. + * + * You can either pass a single key-value pair or a record of key-value pairs to + * annotate the span. These annotations are useful for adding metadata to + * operations, especially in systems with detailed observability requirements. + * + * @since 2.0.0 + * @category Tracing + */ + (values: Record): Effect; +}; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const currentSpan: Effect; +/** + * @since 3.20.0 + * @category Tracing + */ +export declare const currentPropagatedSpan: Effect; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const currentParentSpan: Effect; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const spanAnnotations: Effect>; +/** + * @since 2.0.0 + * @category Tracing + */ +export declare const spanLinks: Effect>; +/** + * For all spans in this effect, add a link with the provided span. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const linkSpans: { + /** + * For all spans in this effect, add a link with the provided span. + * + * @since 2.0.0 + * @category Tracing + */ + (span: Tracer.AnySpan, attributes?: Record): (self: Effect) => Effect; + /** + * For all spans in this effect, add a link with the provided span. + * + * @since 2.0.0 + * @category Tracing + */ + (self: Effect, span: Tracer.AnySpan, attributes?: Record): Effect; +}; +/** + * Add span links to the current span. + * + * @since 3.14.0 + * @category Tracing + */ +export declare const linkSpanCurrent: { + /** + * Add span links to the current span. + * + * @since 3.14.0 + * @category Tracing + */ + (span: Tracer.AnySpan, attributes?: Readonly> | undefined): Effect; + /** + * Add span links to the current span. + * + * @since 3.14.0 + * @category Tracing + */ + (links: ReadonlyArray): Effect; +}; +/** + * Create a new span for tracing. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const makeSpan: (name: string, options?: Tracer.SpanOptions) => Effect; +/** + * Create a new span for tracing, and automatically close it when the Scope + * finalizes. + * + * The span is not added to the current span stack, so no child spans will be + * created for it. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const makeSpanScoped: (name: string, options?: Tracer.SpanOptions | undefined) => Effect; +/** + * Create a new span for tracing, and automatically close it when the effect + * completes. + * + * The span is not added to the current span stack, so no child spans will be + * created for it. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const useSpan: { + /** + * Create a new span for tracing, and automatically close it when the effect + * completes. + * + * The span is not added to the current span stack, so no child spans will be + * created for it. + * + * @since 2.0.0 + * @category Tracing + */ + (name: string, evaluate: (span: Tracer.Span) => Effect): Effect; + /** + * Create a new span for tracing, and automatically close it when the effect + * completes. + * + * The span is not added to the current span stack, so no child spans will be + * created for it. + * + * @since 2.0.0 + * @category Tracing + */ + (name: string, options: Tracer.SpanOptions, evaluate: (span: Tracer.Span) => Effect): Effect; +}; +/** + * Wraps the effect with a new span for tracing. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const withSpan: { + /** + * Wraps the effect with a new span for tracing. + * + * @since 2.0.0 + * @category Tracing + */ + (name: string, options?: Tracer.SpanOptions | undefined): (self: Effect) => Effect>; + /** + * Wraps the effect with a new span for tracing. + * + * @since 2.0.0 + * @category Tracing + */ + (self: Effect, name: string, options?: Tracer.SpanOptions | undefined): Effect>; +}; +/** + * Wraps a function that returns an effect with a new span for tracing. + * + * @since 3.2.0 + * @category Models + */ +export interface FunctionWithSpanOptions { + readonly name: string; + readonly attributes?: Record | undefined; + readonly links?: ReadonlyArray | undefined; + readonly parent?: Tracer.AnySpan | undefined; + readonly root?: boolean | undefined; + readonly context?: Context.Context | undefined; + readonly kind?: Tracer.SpanKind | undefined; +} +/** + * Wraps a function that returns an effect with a new span for tracing. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * const getTodo = Effect.functionWithSpan({ + * body: (id: number) => Effect.succeed(`Got todo ${id}!`), + * options: (id) => ({ + * name: `getTodo-${id}`, + * attributes: { id } + * }) + * }) + * ``` + * + * @since 3.2.0 + * @category Tracing + */ +export declare const functionWithSpan: , Ret extends Effect>(options: { + readonly body: (...args: Args) => Ret; + readonly options: FunctionWithSpanOptions | ((...args: Args) => FunctionWithSpanOptions); + readonly captureStackTrace?: boolean | undefined; +}) => (...args: Args) => Unify.Unify; +/** + * Wraps the effect with a new span for tracing. + * + * The span is ended when the Scope is finalized. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const withSpanScoped: { + /** + * Wraps the effect with a new span for tracing. + * + * The span is ended when the Scope is finalized. + * + * @since 2.0.0 + * @category Tracing + */ + (name: string, options?: Tracer.SpanOptions): (self: Effect) => Effect | Scope.Scope>; + /** + * Wraps the effect with a new span for tracing. + * + * The span is ended when the Scope is finalized. + * + * @since 2.0.0 + * @category Tracing + */ + (self: Effect, name: string, options?: Tracer.SpanOptions): Effect | Scope.Scope>; +}; +/** + * Adds the provided span to the current span stack. + * + * @since 2.0.0 + * @category Tracing + */ +export declare const withParentSpan: { + /** + * Adds the provided span to the current span stack. + * + * @since 2.0.0 + * @category Tracing + */ + (span: Tracer.AnySpan): (self: Effect) => Effect>; + /** + * Adds the provided span to the current span stack. + * + * @since 2.0.0 + * @category Tracing + */ + (self: Effect, span: Tracer.AnySpan): Effect>; +}; +/** + * Safely handles nullable values by creating an effect that fails for `null` or + * `undefined`. + * + * **Details** + * + * This function ensures that an input value is non-null and non-undefined + * before processing it. If the value is valid, the effect succeeds with the + * value. If the value is `null` or `undefined`, the effect fails with a + * `NoSuchElementException`. This is particularly useful for avoiding + * null-related errors by clearly separating valid values from invalid ones in + * effectful computations. + * + * The failure with `NoSuchElementException` allows you to explicitly handle + * cases where a value is expected but not provided, leading to safer and more + * predictable code. + * + * **When to Use** + * + * Use this function when working with values that may be `null` or `undefined` + * and you want to ensure that only non-null values are processed. It helps + * enforce null-safety and makes error handling more explicit. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const maybe1 = Effect.fromNullable(1) + * + * Effect.runPromiseExit(maybe1).then(console.log) + * // Output: + * // { _id: 'Exit', _tag: 'Success', value: 1 } + * + * // ┌─── Effect + * // ▼ + * const maybe2 = Effect.fromNullable(null as number | null) + * + * Effect.runPromiseExit(maybe2).then(console.log) + * // Output: + * // { + * // _id: 'Exit', + * // _tag: 'Failure', + * // cause: { + * // _id: 'Cause', + * // _tag: 'Fail', + * // failure: { _tag: 'NoSuchElementException' } + * // } + * // } + * ``` + * + * @since 2.0.0 + * @category Optional Wrapping & Unwrapping + */ +export declare const fromNullable: (value: A) => Effect, Cause.NoSuchElementException>; +/** + * Converts an effect that may fail with a `NoSuchElementException` into an + * effect that succeeds with an `Option`. + * + * **Details** + * + * This function transforms an effect that might fail with + * `Cause.NoSuchElementException` into an effect that succeeds with an `Option` + * type. If the original effect succeeds, its value is wrapped in `Option.some`. + * If it fails specifically due to a `NoSuchElementException`, the failure is + * mapped to `Option.none`. Other types of failures remain unchanged and are + * passed through as they are. + * + * This is useful when working with effects where you want to gracefully handle + * the absence of a value while preserving other potential failures. + * + * **When to Use** + * + * Use this function when you need to handle missing values as `Option.none` + * rather than throwing or propagating errors like `NoSuchElementException`. + * It’s ideal for scenarios where you want to explicitly represent optionality + * in a type-safe way while retaining other failure information. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * // ┌─── Effect + * // ▼ + * const maybe1 = Effect.fromNullable(1) + * + * // ┌─── Effect, never, never> + * // ▼ + * const option1 = Effect.optionFromOptional(maybe1) + * + * Effect.runPromise(option1).then(console.log) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * // ┌─── Effect + * // ▼ + * const maybe2 = Effect.fromNullable(null as number | null) + * + * // ┌─── Effect, never, never> + * // ▼ + * const option2 = Effect.optionFromOptional(maybe2) + * + * Effect.runPromise(option2).then(console.log) + * // Output: { _tag: 'None' } + * ``` + * + * @since 2.0.0 + * @category Optional Wrapping & Unwrapping + */ +export declare const optionFromOptional: (self: Effect) => Effect, Exclude, R>; +/** + * Converts an `Option` of an `Effect` into an `Effect` of an `Option`. + * + * **Details** + * + * This function transforms an `Option>` into an + * `Effect, E, R>`. If the `Option` is `None`, the resulting `Effect` + * will immediately succeed with a `None` value. If the `Option` is `Some`, the + * inner `Effect` will be executed, and its result wrapped in a `Some`. + * + * **Example** + * + * ```ts + * import { Effect, Option } from "effect" + * + * // ┌─── Option> + * // ▼ + * const maybe = Option.some(Effect.succeed(42)) + * + * // ┌─── Effect, never, never> + * // ▼ + * const result = Effect.transposeOption(maybe) + * + * console.log(Effect.runSync(result)) + * // Output: { _id: 'Option', _tag: 'Some', value: 42 } + * ``` + * + * @since 3.13.0 + * @category Optional Wrapping & Unwrapping + */ +export declare const transposeOption: (self: Option.Option>) => Effect, E, R>; +/** + * Applies an `Effect` on an `Option` and transposes the result. + * + * **Details** + * + * If the `Option` is `None`, the resulting `Effect` will immediately succeed with a `None` value. + * If the `Option` is `Some`, the effectful operation will be executed on the inner value, and its result wrapped in a `Some`. + * + * @example + * ```ts + * import { Effect, Option, pipe } from "effect" + * + * // ┌─── Effect, never, never>> + * // ▼ + * const noneResult = pipe( + * Option.none(), + * Effect.transposeMapOption(() => Effect.succeed(42)) // will not be executed + * ) + * console.log(Effect.runSync(noneResult)) + * // Output: { _id: 'Option', _tag: 'None' } + * + * // ┌─── Effect, never, never>> + * // ▼ + * const someSuccessResult = pipe( + * Option.some(42), + * Effect.transposeMapOption((value) => Effect.succeed(value * 2)) + * ) + * console.log(Effect.runSync(someSuccessResult)) + * // Output: { _id: 'Option', _tag: 'Some', value: 84 } + * ``` + * + * @since 3.14.0 + * @category Optional Wrapping & Unwrapping + */ +export declare const transposeMapOption: ((f: (self: A) => Effect) => (self: Option.Option) => Effect, E, R>) & ((self: Option.Option, f: (self: A) => Effect) => Effect, E, R>); +/** + * @since 2.0.0 + * @category Models + */ +export declare namespace Tag { + /** + * @since 2.0.0 + * @category Models + */ + interface ProhibitedType { + Service?: `property "Service" is forbidden`; + Identifier?: `property "Identifier" is forbidden`; + _op?: `property "_op" is forbidden`; + of?: `property "of" is forbidden`; + context?: `property "context" is forbidden`; + key?: `property "key" is forbidden`; + stack?: `property "stack" is forbidden`; + name?: `property "name" is forbidden`; + pipe?: `property "pipe" is forbidden`; + use?: `property "use" is forbidden`; + } + /** + * @since 2.0.0 + * @category Models + */ + type AllowedType = (Record & ProhibitedType) | string | number | symbol; + /** + * @since 3.9.0 + * @category Models + */ + type Proxy = { + [k in keyof Type as Type[k] extends ((...args: infer Args extends ReadonlyArray) => infer Ret) ? ((...args: Readonly) => Ret) extends Type[k] ? k : never : k]: Type[k] extends (...args: infer Args extends ReadonlyArray) => Effect ? (...args: Readonly) => Effect : Type[k] extends (...args: infer Args extends ReadonlyArray) => Promise ? (...args: Readonly) => Effect : Type[k] extends (...args: infer Args extends ReadonlyArray) => infer A ? (...args: Readonly) => Effect : Type[k] extends Effect ? Effect : Effect; + }; +} +/** + * Creates a unique tag for a dependency, embedding the service's methods as + * static properties. + * + * **Details** + * + * This function allows you to define a `Tag` for a service or dependency in + * your application. The `Tag` not only acts as an identifier but also provides + * direct access to the service's methods via static properties. This makes it + * easier to access and use the service in your code without manually managing + * contexts. + * + * In the example below, the fields of the service (in this case, the `notify` + * method) are turned into static properties of the Notifications class, making + * it easier to access them. + * + * **Example** + * + * ```ts + * import { Effect } from "effect" + * + * class Notifications extends Effect.Tag("Notifications")< + * Notifications, + * { readonly notify: (message: string) => Effect.Effect } + * >() {} + * + * // Create an effect that depends on the Notifications service + * const action = Notifications.notify("Hello, world!") + * ``` + * + * @since 2.0.0 + * @category Context + */ +export declare const Tag: (id: Id) => () => Context.TagClass & (Type extends Record ? Tag.Proxy : {}) & { + use: (body: (_: Type) => X) => [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; +}; +type MissingSelfGeneric = `Missing \`Self\` generic - use \`class Self extends Effect.Service()...\``; +/** + * Simplifies the creation and management of services in Effect by defining both + * a `Tag` and a `Layer`. + * + * **Details** + * + * This function allows you to streamline the creation of services by combining + * the definition of a `Context.Tag` and a `Layer` in a single step. It supports + * various ways of providing the service implementation: + * - Using an `effect` to define the service dynamically. + * - Using `sync` or `succeed` to define the service statically. + * - Using `scoped` to create services with lifecycle management. + * + * It also allows you to specify dependencies for the service, which will be + * provided automatically when the service is used. Accessors can be optionally + * generated for the service, making it more convenient to use. + * + * **Example** + * + * ```ts + * import { Effect } from 'effect'; + * + * class Prefix extends Effect.Service()("Prefix", { + * sync: () => ({ prefix: "PRE" }) + * }) {} + * + * class Logger extends Effect.Service()("Logger", { + * accessors: true, + * effect: Effect.gen(function* () { + * const { prefix } = yield* Prefix + * return { + * info: (message: string) => + * Effect.sync(() => { + * console.log(`[${prefix}][${message}]`) + * }) + * } + * }), + * dependencies: [Prefix.Default] + * }) {} + * ``` + * + * @since 3.9.0 + * @category Context + * @experimental might be up for breaking changes + */ +export declare const Service: () => [Self] extends [never] ? MissingSelfGeneric : { + , any, any> | ((...args: any) => Effect, any, any>); + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + /** @deprecated */ + readonly ಠ_ಠ: never; + } | { + readonly effect: Effect, any, any> | ((...args: any) => Effect, any, any>); + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + /** @deprecated */ + readonly ಠ_ಠ: never; + } | { + readonly sync: LazyArg>; + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + /** @deprecated */ + readonly ಠ_ಠ: never; + } | { + readonly succeed: Service.AllowedType; + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + /** @deprecated */ + readonly ಠ_ಠ: never; + }>(key: Key, make: Make): Service.Class; + , any, any> | ((...args: any) => Effect, any, any>); + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + }, Make>>(key: Key, make: Make): Service.Class; + , any, any> | ((...args: any) => Effect, any, any>); + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + }, Make>>(key: Key, make: Make): Service.Class; + >; + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + }, Make>>(key: Key, make: Make): Service.Class; + ; + readonly dependencies?: ReadonlyArray; + readonly accessors?: boolean; + }, Make>>(key: Key, make: Make): Service.Class; +}; +/** + * @since 3.9.0 + * @category Context + */ +export declare namespace Service { + /** + * @since 3.9.0 + */ + interface ProhibitedType { + Service?: `property "Service" is forbidden`; + Identifier?: `property "Identifier" is forbidden`; + Default?: `property "Default" is forbidden`; + DefaultWithoutDependencies?: `property "DefaultWithoutDependencies" is forbidden`; + _op_layer?: `property "_op_layer" is forbidden`; + _op?: `property "_op" is forbidden`; + of?: `property "of" is forbidden`; + make?: `property "make" is forbidden`; + context?: `property "context" is forbidden`; + key?: `property "key" is forbidden`; + stack?: `property "stack" is forbidden`; + name?: `property "name" is forbidden`; + pipe?: `property "pipe" is forbidden`; + use?: `property "use" is forbidden`; + _tag?: `property "_tag" is forbidden`; + } + /** + * @since 3.9.0 + */ + type AllowedType = MakeAccessors extends true ? Record & { + readonly [K in Extract, keyof ProhibitedType>]: K extends "_tag" ? Key : ProhibitedType[K]; + } : Record & { + readonly _tag?: Key; + }; + /** + * @since 3.9.0 + */ + type Class = { + new (_: MakeService): MakeService & { + readonly _tag: Key; + }; + readonly use: (body: (_: Self) => X) => [X] extends [Effect] ? Effect : [X] extends [PromiseLike] ? Effect : Effect; + readonly make: (_: MakeService) => Self; + } & Context.Tag & { + key: Key; + } & (MakeAccessors extends true ? Tag.Proxy> : {}) & (MakeDeps extends never ? { + readonly Default: HasArguments extends true ? (...args: MakeArguments) => Layer.Layer, MakeContext> : Layer.Layer, MakeContext>; + } : { + readonly DefaultWithoutDependencies: HasArguments extends true ? (...args: MakeArguments) => Layer.Layer, MakeContext> : Layer.Layer, MakeContext>; + readonly Default: HasArguments extends true ? (...args: MakeArguments) => Layer.Layer | MakeDepsE, Exclude, MakeDepsOut> | MakeDepsIn> : Layer.Layer | MakeDepsE, Exclude, MakeDepsOut> | MakeDepsIn>; + }); + /** + * @since 3.9.0 + */ + type MakeService = Make extends { + readonly effect: Effect; + } ? _A : Make extends { + readonly scoped: Effect; + } ? _A : Make extends { + readonly effect: (...args: infer _Args) => Effect; + } ? _A : Make extends { + readonly scoped: (...args: infer _Args) => Effect; + } ? _A : Make extends { + readonly sync: LazyArg; + } ? A : Make extends { + readonly succeed: infer A; + } ? A : never; + /** + * @since 3.9.0 + */ + type MakeError = Make extends { + readonly effect: Effect; + } ? _E : Make extends { + readonly scoped: Effect; + } ? _E : Make extends { + readonly effect: (...args: infer _Args) => Effect; + } ? _E : Make extends { + readonly scoped: (...args: infer _Args) => Effect; + } ? _E : never; + /** + * @since 3.9.0 + */ + type MakeContext = Make extends { + readonly effect: Effect; + } ? _R : Make extends { + readonly scoped: Effect; + } ? Exclude<_R, Scope.Scope> : Make extends { + readonly effect: (...args: infer _Args) => Effect; + } ? _R : Make extends { + readonly scoped: (...args: infer _Args) => Effect; + } ? Exclude<_R, Scope.Scope> : never; + /** + * @since 3.9.0 + */ + type MakeDeps = Make extends { + readonly dependencies: ReadonlyArray; + } ? Make["dependencies"][number] : never; + /** + * @since 3.9.0 + */ + type MakeDepsOut = Contravariant.Type[Layer.LayerTypeId]["_ROut"]>; + /** + * @since 3.9.0 + */ + type MakeDepsE = Covariant.Type[Layer.LayerTypeId]["_E"]>; + /** + * @since 3.9.0 + */ + type MakeDepsIn = Covariant.Type[Layer.LayerTypeId]["_RIn"]>; + /** + * @since 3.9.0 + */ + type MakeAccessors = Make extends { + readonly accessors: true; + } ? true : false; + /** + * @since 3.16.0 + */ + type MakeArguments = Make extends { + readonly effect: (...args: infer Args) => Effect; + } ? Args : Make extends { + readonly scoped: (...args: infer Args) => Effect; + } ? Args : never; + /** + * @since 3.16.0 + */ + type HasArguments = Make extends { + readonly scoped: (...args: ReadonlyArray) => Effect; + } ? true : Make extends { + readonly effect: (...args: ReadonlyArray) => Effect; + } ? true : false; +} +/** + * @since 3.11.0 + * @category Models + */ +export declare namespace fn { + /** + * @since 3.19.0 + * @category Models + */ + type Return = Generator>, A, any>; + /** + * @since 3.11.0 + * @category Models + */ + type Gen = { + >, AEff, Args extends Array>(body: (...args: Args) => Generator): (...args: Args) => Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>; + >, AEff, Args extends Array, A extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B, C extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B, C, D extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B, C, D, E extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B, C, D, E, F extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B, C, D, E, F, G extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F, g: (_: F, ...args: NoInfer) => G): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B, C, D, E, F, G, H extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F, g: (_: F, ...args: NoInfer) => G, h: (_: G, ...args: NoInfer) => H): (...args: Args) => Effect.AsEffect; + >, AEff, Args extends Array, A, B, C, D, E, F, G, H, I extends Effect>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F, g: (_: F, ...args: NoInfer) => G, h: (_: G, ...args: NoInfer) => H, i: (_: H, ...args: NoInfer) => I): (...args: Args) => Effect.AsEffect; + }; + /** + * @since 3.11.0 + * @category Models + */ + type NonGen = { + , Args extends Array>(body: (...args: Args) => Eff): (...args: Args) => Effect.AsEffect; + , A, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, C, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => C, c: (_: C, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, C, D, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => C, c: (_: C, ...args: NoInfer) => D, d: (_: D, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, C, D, E, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => C, c: (_: C, ...args: NoInfer) => D, d: (_: D, ...args: NoInfer) => E, e: (_: E, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, C, D, E, F, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => C, c: (_: C, ...args: NoInfer) => D, d: (_: D, ...args: NoInfer) => E, e: (_: E, ...args: NoInfer) => F, f: (_: F, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, C, D, E, F, G, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => C, c: (_: C, ...args: NoInfer) => D, d: (_: D, ...args: NoInfer) => E, e: (_: E, ...args: NoInfer) => F, f: (_: F, ...args: NoInfer) => G, g: (_: G, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, C, D, E, F, G, H, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => C, c: (_: C, ...args: NoInfer) => D, d: (_: D, ...args: NoInfer) => E, e: (_: E, ...args: NoInfer) => F, f: (_: F, ...args: NoInfer) => G, g: (_: G, ...args: NoInfer) => H, h: (_: H, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + , A, B, C, D, E, F, G, H, I, Args extends Array>(body: (...args: Args) => A, a: (_: A, ...args: NoInfer) => B, b: (_: B, ...args: NoInfer) => C, c: (_: C, ...args: NoInfer) => D, d: (_: D, ...args: NoInfer) => E, e: (_: E, ...args: NoInfer) => F, f: (_: F, ...args: NoInfer) => G, g: (_: G, ...args: NoInfer) => H, h: (_: H, ...args: NoInfer) => I, i: (_: H, ...args: NoInfer) => Eff): (...args: Args) => Effect.AsEffect; + }; + /** + * @since 3.11.0 + * @category Models + */ + type Untraced = { + >, AEff, Args extends Array>(body: (...args: Args) => Generator): (...args: Args) => Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>; + >, AEff, Args extends Array, A>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A): (...args: Args) => A; + >, AEff, Args extends Array, A, B>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B): (...args: Args) => B; + >, AEff, Args extends Array, A, B, C>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C): (...args: Args) => C; + >, AEff, Args extends Array, A, B, C, D>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D): (...args: Args) => D; + >, AEff, Args extends Array, A, B, C, D, E>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E): (...args: Args) => E; + >, AEff, Args extends Array, A, B, C, D, E, F>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F): (...args: Args) => F; + >, AEff, Args extends Array, A, B, C, D, E, F, G>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F, g: (_: F, ...args: NoInfer) => G): (...args: Args) => G; + >, AEff, Args extends Array, A, B, C, D, E, F, G, H>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F, g: (_: F, ...args: NoInfer) => G, h: (_: G, ...args: NoInfer) => H): (...args: Args) => H; + >, AEff, Args extends Array, A, B, C, D, E, F, G, H, I>(body: (...args: Args) => Generator, a: (_: Effect>] ? E : never, [ + Eff + ] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>, ...args: NoInfer) => A, b: (_: A, ...args: NoInfer) => B, c: (_: B, ...args: NoInfer) => C, d: (_: C, ...args: NoInfer) => D, e: (_: D, ...args: NoInfer) => E, f: (_: E, ...args: NoInfer) => F, g: (_: F, ...args: NoInfer) => G, h: (_: G, ...args: NoInfer) => H, i: (_: H, ...args: NoInfer) => I): (...args: Args) => I; + }; +} +/** + * The `Effect.fn` function allows you to create traced functions that return an + * effect. It provides two key features: + * + * - **Stack traces with location details** if an error occurs. + * - **Automatic span creation** for tracing when a span name is provided. + * + * If a span name is passed as the first argument, the function's execution is + * tracked using that name. If no name is provided, stack tracing still works, + * but spans are not created. + * + * A function can be defined using either: + * + * - A generator function, allowing the use of `yield*` for effect composition. + * - A regular function that returns an `Effect`. + * + * **Example** (Creating a Traced Function with a Span Name) + * + * ```ts + * import { Effect } from "effect" + * + * const myfunc = Effect.fn("myspan")(function* (n: N) { + * yield* Effect.annotateCurrentSpan("n", n) // Attach metadata to the span + * console.log(`got: ${n}`) + * yield* Effect.fail(new Error("Boom!")) // Simulate failure + * }) + * + * Effect.runFork(myfunc(100).pipe(Effect.catchAllCause(Effect.logError))) + * // Output: + * // got: 100 + * // timestamp=... level=ERROR fiber=#0 cause="Error: Boom! + * // at (/.../index.ts:6:22) <= Raise location + * // at myspan (/.../index.ts:3:23) <= Definition location + * // at myspan (/.../index.ts:9:16)" <= Call location + * ``` + * + * `Effect.fn` automatically creates spans. The spans capture information about + * the function execution, including metadata and error details. + * + * **Example** (Exporting Spans to the Console) + * + * ```ts skip-type-checking + * import { Effect } from "effect" + * import { NodeSdk } from "@effect/opentelemetry" + * import { + * ConsoleSpanExporter, + * BatchSpanProcessor + * } from "@opentelemetry/sdk-trace-base" + * + * const myfunc = Effect.fn("myspan")(function* (n: N) { + * yield* Effect.annotateCurrentSpan("n", n) + * console.log(`got: ${n}`) + * yield* Effect.fail(new Error("Boom!")) + * }) + * + * const program = myfunc(100) + * + * const NodeSdkLive = NodeSdk.layer(() => ({ + * resource: { serviceName: "example" }, + * // Export span data to the console + * spanProcessor: new BatchSpanProcessor(new ConsoleSpanExporter()) + * })) + * + * Effect.runFork(program.pipe(Effect.provide(NodeSdkLive))) + * // Output: + * // got: 100 + * // { + * // resource: { + * // attributes: { + * // 'service.name': 'example', + * // 'telemetry.sdk.language': 'nodejs', + * // 'telemetry.sdk.name': '@effect/opentelemetry', + * // 'telemetry.sdk.version': '1.30.1' + * // } + * // }, + * // instrumentationScope: { name: 'example', version: undefined, schemaUrl: undefined }, + * // traceId: '22801570119e57a6e2aacda3dec9665b', + * // parentId: undefined, + * // traceState: undefined, + * // name: 'myspan', + * // id: '7af530c1e01bc0cb', + * // kind: 0, + * // timestamp: 1741182277518402.2, + * // duration: 4300.416, + * // attributes: { + * // n: 100, + * // 'code.stacktrace': 'at (/.../index.ts:8:23)\n' + + * // 'at (/.../index.ts:14:17)' + * // }, + * // status: { code: 2, message: 'Boom!' }, + * // events: [ + * // { + * // name: 'exception', + * // attributes: { + * // 'exception.type': 'Error', + * // 'exception.message': 'Boom!', + * // 'exception.stacktrace': 'Error: Boom!\n' + + * // ' at (/.../index.ts:11:22)\n' + + * // ' at myspan (/.../index.ts:8:23)\n' + + * // ' at myspan (/.../index.ts:14:17)' + * // }, + * // time: [ 1741182277, 522702583 ], + * // droppedAttributesCount: 0 + * // } + * // ], + * // links: [] + * // } + * ``` + * + * `Effect.fn` also acts as a pipe function, allowing you to create a pipeline + * after the function definition using the effect returned by the generator + * function as the starting value of the pipeline. + * + * **Example** (Creating a Traced Function with a Delay) + * + * ```ts + * import { Effect } from "effect" + * + * const myfunc = Effect.fn( + * function* (n: number) { + * console.log(`got: ${n}`) + * yield* Effect.fail(new Error("Boom!")) + * }, + * // You can access both the created effect and the original arguments + * (effect, n) => Effect.delay(effect, `${n / 100} seconds`) + * ) + * + * Effect.runFork(myfunc(100).pipe(Effect.catchAllCause(Effect.logError))) + * // Output: + * // got: 100 + * // timestamp=... level=ERROR fiber=#0 cause="Error: Boom! (<= after 1 second) + * ``` + * + * @see {@link fnUntraced} for a version of this function that doesn't add a span. + * + * @since 3.11.0 + * @category Tracing + */ +export declare const fn: fn.Gen & fn.NonGen & ((name: string, options?: Tracer.SpanOptions) => fn.Gen & fn.NonGen); +/** + * Same as {@link fn}, but allows you to create a function that is not traced, for when performance is critical. + * + * @see {@link fn} for a version that includes tracing. + * + * @since 3.12.0 + * @category Tracing + */ +export declare const fnUntraced: fn.Untraced; +/** + * A no-op type constraint that enforces the success channel of an Effect conforms to + * the specified success type `A`. + * + * @example + * import { Effect } from "effect" + * + * // Ensure that the program does not expose any unhandled errors. + * const program = Effect.succeed(42).pipe(Effect.ensureSuccessType()) + * + * @since 3.17.0 + * @category Type constraints + */ +export declare const ensureSuccessType: () => (effect: Effect) => Effect; +/** + * A no-op type constraint that enforces the error channel of an Effect conforms to + * the specified error type `E`. + * + * @example + * import { Effect } from "effect" + * + * // Ensure that the program does not expose any unhandled errors. + * const program = Effect.succeed(42).pipe(Effect.ensureErrorType()) + * + * @since 3.17.0 + * @category Type constraints + */ +export declare const ensureErrorType: () => (effect: Effect) => Effect; +/** + * A no-op type constraint that enforces the requirements channel of an Effect conforms to + * the specified requirements type `R`. + * + * @example + * import { Effect } from "effect" + * + * // Ensure that the program does not have any requirements. + * const program = Effect.succeed(42).pipe(Effect.ensureRequirementsType()) + * + * @since 3.17.0 + * @category Type constraints + */ +export declare const ensureRequirementsType: () => (effect: Effect) => Effect; +//# sourceMappingURL=Effect.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Effect.d.ts.map b/backend/node_modules/effect/dist/dts/Effect.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..1206a3a5fa6ad0ac409675f5d3126579a7cfb744 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Effect.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Effect.d.ts","sourceRoot":"","sources":["../../src/Effect.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Effectable.d.ts.map b/backend/node_modules/effect/dist/dts/Effectable.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..674c459b72e105cccccbec1986c13aa810600aa8 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Effectable.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Effectable.d.ts","sourceRoot":"","sources":["../../src/Effectable.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAE1C,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAA;AACtC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAE1C;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAoC,CAAA;AAEtE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,CAAA;AAE9C;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAoC,CAAA;AAEtE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,CAAA;AAE9C;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,UAAgC,CAAA;AAE9D;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAA;AAExC;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,aAAsC,CAAA;AAE1E;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAA;AAEjD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACvD;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAA4B,CAAA;AAE7E;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAA4B,CAAA;AAE7E;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAsC,CAAA;AAEjG,QAAA,MAAM,IAAI,EAAE,eAA+B,CAAA;AAC3C,QAAA,MAAM,cAAc,EAAE,eAAyC,CAAA;AAE/D;;;GAGG;AACH,8BAAsB,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAAE,SAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACxE;;OAEG;IACH,QAAQ,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CAC1C;AAED;;;GAGG;AACH,8BAAsB,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAAE,SAAQ,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC5F;;OAEG;IACH,QAAQ,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CAC1C"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Either.d.ts b/backend/node_modules/effect/dist/dts/Either.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a73b1717a4548e33e1cc29556b3b0a3a6bfec878 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Either.d.ts @@ -0,0 +1,1431 @@ +/** + * @since 2.0.0 + */ +import * as Equivalence from "./Equivalence.js"; +import type { LazyArg } from "./Function.js"; +import type { TypeLambda } from "./HKT.js"; +import type { Inspectable } from "./Inspectable.js"; +import type { Option } from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import type { Covariant, NoInfer, NotFunction } from "./Types.js"; +import type * as Unify from "./Unify.js"; +import * as Gen from "./Utils.js"; +/** + * @category models + * @since 2.0.0 + */ +export type Either = Left | Right; +/** + * @category symbols + * @since 2.0.0 + */ +export declare const TypeId: unique symbol; +/** + * @category symbols + * @since 2.0.0 + */ +export type TypeId = typeof TypeId; +/** + * @category models + * @since 2.0.0 + */ +export interface Left extends Pipeable, Inspectable { + readonly _tag: "Left"; + readonly _op: "Left"; + readonly left: E; + readonly [TypeId]: { + readonly _R: Covariant; + readonly _L: Covariant; + }; + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: EitherUnify; + [Unify.ignoreSymbol]?: EitherUnifyIgnore; +} +/** + * @category models + * @since 2.0.0 + */ +export interface Right extends Pipeable, Inspectable { + readonly _tag: "Right"; + readonly _op: "Right"; + readonly right: A; + readonly [TypeId]: { + readonly _R: Covariant; + readonly _L: Covariant; + }; + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: EitherUnify; + [Unify.ignoreSymbol]?: EitherUnifyIgnore; +} +/** + * @category models + * @since 2.0.0 + */ +export interface EitherUnify { + Either?: () => A[Unify.typeSymbol] extends Either | infer _ ? Either : never; +} +/** + * @category models + * @since 2.0.0 + */ +export interface EitherUnifyIgnore { +} +/** + * @category type lambdas + * @since 2.0.0 + */ +export interface EitherTypeLambda extends TypeLambda { + readonly type: Either; +} +/** + * @since 2.0.0 + */ +export declare namespace Either { + /** + * @since 2.0.0 + * @category type-level + */ + type Left> = [T] extends [Either] ? _E : never; + /** + * @since 2.0.0 + * @category type-level + */ + type Right> = [T] extends [Either] ? _A : never; +} +/** + * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias + * of this structure. + * + * @category constructors + * @since 2.0.0 + */ +export declare const right: (a: A) => Either; +declare const void_: Either; +export { +/** + * @category constructors + * @since 3.13.0 + */ +void_ as void }; +/** + * Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this + * structure. + * + * @category constructors + * @since 2.0.0 + */ +export declare const left: (e: E) => Either; +/** + * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use + * the provided default as a `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1)) + * assert.deepStrictEqual(Either.fromNullable(null, () => 'fallback'), Either.left('fallback')) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const fromNullable: { + /** + * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use + * the provided default as a `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1)) + * assert.deepStrictEqual(Either.fromNullable(null, () => 'fallback'), Either.left('fallback')) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (onNullable: (right: A) => E): (self: A) => Either, E>; + /** + * Takes a lazy default and a nullable value, if the value is not nully (`null` or `undefined`), turn it into a `Right`, if the value is nully use + * the provided default as a `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1)) + * assert.deepStrictEqual(Either.fromNullable(null, () => 'fallback'), Either.left('fallback')) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (self: A, onNullable: (right: A) => E): Either, E>; +}; +/** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, Option } from "effect" + * + * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1)) + * assert.deepStrictEqual(Either.fromOption(Option.none(), () => 'error'), Either.left('error')) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const fromOption: { + /** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, Option } from "effect" + * + * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1)) + * assert.deepStrictEqual(Either.fromOption(Option.none(), () => 'error'), Either.left('error')) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (onNone: () => E): (self: Option) => Either; + /** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, Option } from "effect" + * + * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1)) + * assert.deepStrictEqual(Either.fromOption(Option.none(), () => 'error'), Either.left('error')) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (self: Option, onNone: () => E): Either; +}; +declare const try_: { + (options: { + readonly try: LazyArg; + readonly catch: (error: unknown) => E; + }): Either; + (evaluate: LazyArg): Either; +}; +export { +/** + * Imports a synchronous side-effect into a pure `Either` value, translating any + * thrown exceptions into typed failed eithers creating with `Either.left`. + * + * @category constructors + * @since 2.0.0 + */ +try_ as try }; +/** + * Tests if a value is a `Either`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.isEither(Either.right(1)), true) + * assert.deepStrictEqual(Either.isEither(Either.left("a")), true) + * assert.deepStrictEqual(Either.isEither({ right: 1 }), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isEither: (input: unknown) => input is Either; +/** + * Determine if a `Either` is a `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.isLeft(Either.right(1)), false) + * assert.deepStrictEqual(Either.isLeft(Either.left("a")), true) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isLeft: (self: Either) => self is Left; +/** + * Determine if a `Either` is a `Right`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.isRight(Either.right(1)), true) + * assert.deepStrictEqual(Either.isRight(Either.left("a")), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isRight: (self: Either) => self is Right; +/** + * Converts a `Either` to an `Option` discarding the `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, Option } from "effect" + * + * assert.deepStrictEqual(Either.getRight(Either.right('ok')), Option.some('ok')) + * assert.deepStrictEqual(Either.getRight(Either.left('err')), Option.none()) + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const getRight: (self: Either) => Option; +/** + * Converts a `Either` to an `Option` discarding the value. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, Option } from "effect" + * + * assert.deepStrictEqual(Either.getLeft(Either.right('ok')), Option.none()) + * assert.deepStrictEqual(Either.getLeft(Either.left('err')), Option.some('err')) + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const getLeft: (self: Either) => Option; +/** + * @category equivalence + * @since 2.0.0 + */ +export declare const getEquivalence: ({ left, right }: { + right: Equivalence.Equivalence; + left: Equivalence.Equivalence; +}) => Equivalence.Equivalence>; +/** + * @category mapping + * @since 2.0.0 + */ +export declare const mapBoth: { + /** + * @category mapping + * @since 2.0.0 + */ + (options: { + readonly onLeft: (left: E) => E2; + readonly onRight: (right: A) => A2; + }): (self: Either) => Either; + /** + * @category mapping + * @since 2.0.0 + */ + (self: Either, options: { + readonly onLeft: (left: E) => E2; + readonly onRight: (right: A) => A2; + }): Either; +}; +/** + * Maps the `Left` side of an `Either` value to a new `Either` value. + * + * @category mapping + * @since 2.0.0 + */ +export declare const mapLeft: { + /** + * Maps the `Left` side of an `Either` value to a new `Either` value. + * + * @category mapping + * @since 2.0.0 + */ + (f: (left: E) => E2): (self: Either) => Either; + /** + * Maps the `Left` side of an `Either` value to a new `Either` value. + * + * @category mapping + * @since 2.0.0 + */ + (self: Either, f: (left: E) => E2): Either; +}; +/** + * Maps the `Right` side of an `Either` value to a new `Either` value. + * + * @category mapping + * @since 2.0.0 + */ +export declare const map: { + /** + * Maps the `Right` side of an `Either` value to a new `Either` value. + * + * @category mapping + * @since 2.0.0 + */ + (f: (right: A) => A2): (self: Either) => Either; + /** + * Maps the `Right` side of an `Either` value to a new `Either` value. + * + * @category mapping + * @since 2.0.0 + */ + (self: Either, f: (right: A) => A2): Either; +}; +/** + * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function, + * if the value is a `Right` the inner value is applied to the `onRight` function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const onLeft = (strings: ReadonlyArray): string => `strings: ${strings.join(', ')}` + * + * const onRight = (value: number): string => `Ok: ${value}` + * + * assert.deepStrictEqual(pipe(Either.right(1), Either.match({ onLeft, onRight })), 'Ok: 1') + * assert.deepStrictEqual( + * pipe(Either.left(['string 1', 'string 2']), Either.match({ onLeft, onRight })), + * 'strings: string 1, string 2' + * ) + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ +export declare const match: { + /** + * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function, + * if the value is a `Right` the inner value is applied to the `onRight` function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const onLeft = (strings: ReadonlyArray): string => `strings: ${strings.join(', ')}` + * + * const onRight = (value: number): string => `Ok: ${value}` + * + * assert.deepStrictEqual(pipe(Either.right(1), Either.match({ onLeft, onRight })), 'Ok: 1') + * assert.deepStrictEqual( + * pipe(Either.left(['string 1', 'string 2']), Either.match({ onLeft, onRight })), + * 'strings: string 1, string 2' + * ) + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (options: { + readonly onLeft: (left: E) => B; + readonly onRight: (right: A) => C; + }): (self: Either) => B | C; + /** + * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the `onLeft function, + * if the value is a `Right` the inner value is applied to the `onRight` function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const onLeft = (strings: ReadonlyArray): string => `strings: ${strings.join(', ')}` + * + * const onRight = (value: number): string => `Ok: ${value}` + * + * assert.deepStrictEqual(pipe(Either.right(1), Either.match({ onLeft, onRight })), 'Ok: 1') + * assert.deepStrictEqual( + * pipe(Either.left(['string 1', 'string 2']), Either.match({ onLeft, onRight })), + * 'strings: string 1, string 2' + * ) + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (self: Either, options: { + readonly onLeft: (left: E) => B; + readonly onRight: (right: A) => C; + }): B | C; +}; +/** + * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true` + * or `Left` of the result of the provided function if the predicate returns false + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * const isPositiveEither = Either.liftPredicate(isPositive, n => `${n} is not positive`) + * + * assert.deepStrictEqual( + * isPositiveEither(1), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * isPositiveEither(0), + * Either.left("0 is not positive") + * ) + * ``` + * + * @category lifting + * @since 3.4.0 + */ +export declare const liftPredicate: { + /** + * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true` + * or `Left` of the result of the provided function if the predicate returns false + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * const isPositiveEither = Either.liftPredicate(isPositive, n => `${n} is not positive`) + * + * assert.deepStrictEqual( + * isPositiveEither(1), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * isPositiveEither(0), + * Either.left("0 is not positive") + * ) + * ``` + * + * @category lifting + * @since 3.4.0 + */ + (refinement: Refinement, orLeftWith: (a: A) => E): (a: A) => Either; + /** + * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true` + * or `Left` of the result of the provided function if the predicate returns false + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * const isPositiveEither = Either.liftPredicate(isPositive, n => `${n} is not positive`) + * + * assert.deepStrictEqual( + * isPositiveEither(1), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * isPositiveEither(0), + * Either.left("0 is not positive") + * ) + * ``` + * + * @category lifting + * @since 3.4.0 + */ + (predicate: Predicate, orLeftWith: (a: A) => E): (a: B) => Either; + /** + * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true` + * or `Left` of the result of the provided function if the predicate returns false + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * const isPositiveEither = Either.liftPredicate(isPositive, n => `${n} is not positive`) + * + * assert.deepStrictEqual( + * isPositiveEither(1), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * isPositiveEither(0), + * Either.left("0 is not positive") + * ) + * ``` + * + * @category lifting + * @since 3.4.0 + */ + (self: A, refinement: Refinement, orLeftWith: (a: A) => E): Either; + /** + * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true` + * or `Left` of the result of the provided function if the predicate returns false + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * const isPositiveEither = Either.liftPredicate(isPositive, n => `${n} is not positive`) + * + * assert.deepStrictEqual( + * isPositiveEither(1), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * isPositiveEither(0), + * Either.left("0 is not positive") + * ) + * ``` + * + * @category lifting + * @since 3.4.0 + */ + (self: B, predicate: Predicate, orLeftWith: (a: A) => E): Either; +}; +/** + * Filter the right value with the provided function. + * If the predicate fails, set the left value with the result of the provided function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * assert.deepStrictEqual( + * pipe( + * Either.right(1), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * pipe( + * Either.right(0), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.left("0 is not positive") + * ) + * ``` + * + * @since 2.0.0 + * @category filtering & conditionals + */ +export declare const filterOrLeft: { + /** + * Filter the right value with the provided function. + * If the predicate fails, set the left value with the result of the provided function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * assert.deepStrictEqual( + * pipe( + * Either.right(1), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * pipe( + * Either.right(0), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.left("0 is not positive") + * ) + * ``` + * + * @since 2.0.0 + * @category filtering & conditionals + */ + (refinement: Refinement, B>, orLeftWith: (right: NoInfer) => E2): (self: Either) => Either; + /** + * Filter the right value with the provided function. + * If the predicate fails, set the left value with the result of the provided function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * assert.deepStrictEqual( + * pipe( + * Either.right(1), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * pipe( + * Either.right(0), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.left("0 is not positive") + * ) + * ``` + * + * @since 2.0.0 + * @category filtering & conditionals + */ + (predicate: Predicate>, orLeftWith: (right: NoInfer) => E2): (self: Either) => Either; + /** + * Filter the right value with the provided function. + * If the predicate fails, set the left value with the result of the provided function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * assert.deepStrictEqual( + * pipe( + * Either.right(1), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * pipe( + * Either.right(0), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.left("0 is not positive") + * ) + * ``` + * + * @since 2.0.0 + * @category filtering & conditionals + */ + (self: Either, refinement: Refinement, orLeftWith: (right: A) => E2): Either; + /** + * Filter the right value with the provided function. + * If the predicate fails, set the left value with the result of the provided function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { pipe, Either } from "effect" + * + * const isPositive = (n: number): boolean => n > 0 + * + * assert.deepStrictEqual( + * pipe( + * Either.right(1), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.right(1) + * ) + * assert.deepStrictEqual( + * pipe( + * Either.right(0), + * Either.filterOrLeft(isPositive, n => `${n} is not positive`) + * ), + * Either.left("0 is not positive") + * ) + * ``` + * + * @since 2.0.0 + * @category filtering & conditionals + */ + (self: Either, predicate: Predicate, orLeftWith: (right: A) => E2): Either; +}; +/** + * @category getters + * @since 2.0.0 + */ +export declare const merge: (self: Either) => E | A; +/** + * Returns the wrapped value if it's a `Right` or a default value if is a `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1) + * assert.deepStrictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!") + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const getOrElse: { + /** + * Returns the wrapped value if it's a `Right` or a default value if is a `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1) + * assert.deepStrictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!") + * ``` + * + * @category getters + * @since 2.0.0 + */ + (onLeft: (left: E) => A2): (self: Either) => A2 | A; + /** + * Returns the wrapped value if it's a `Right` or a default value if is a `Left`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1) + * assert.deepStrictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!") + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Either, onLeft: (left: E) => A2): A | A2; +}; +/** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.getOrNull(Either.right(1)), 1) + * assert.deepStrictEqual(Either.getOrNull(Either.left("a")), null) + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const getOrNull: (self: Either) => A | null; +/** + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.getOrUndefined(Either.right(1)), 1) + * assert.deepStrictEqual(Either.getOrUndefined(Either.left("a")), undefined) + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const getOrUndefined: (self: Either) => A | undefined; +/** + * Extracts the value of an `Either` or throws if the `Either` is `Left`. + * + * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual( + * Either.getOrThrowWith(Either.right(1), () => new Error('Unexpected Left')), + * 1 + * ) + * assert.throws(() => Either.getOrThrowWith(Either.left("error"), () => new Error('Unexpected Left'))) + * ``` + * + * @category getters + * @since 2.0.0 + */ +export declare const getOrThrowWith: { + /** + * Extracts the value of an `Either` or throws if the `Either` is `Left`. + * + * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual( + * Either.getOrThrowWith(Either.right(1), () => new Error('Unexpected Left')), + * 1 + * ) + * assert.throws(() => Either.getOrThrowWith(Either.left("error"), () => new Error('Unexpected Left'))) + * ``` + * + * @category getters + * @since 2.0.0 + */ + (onLeft: (left: E) => unknown): (self: Either) => A; + /** + * Extracts the value of an `Either` or throws if the `Either` is `Left`. + * + * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual( + * Either.getOrThrowWith(Either.right(1), () => new Error('Unexpected Left')), + * 1 + * ) + * assert.throws(() => Either.getOrThrowWith(Either.left("error"), () => new Error('Unexpected Left'))) + * ``` + * + * @category getters + * @since 2.0.0 + */ + (self: Either, onLeft: (left: E) => unknown): A; +}; +/** + * Extracts the value of an `Either` or throws if the `Either` is `Left`. + * + * The thrown error is a default error. To configure the error thrown, see {@link getOrThrowWith}. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.getOrThrow(Either.right(1)), 1) + * assert.throws(() => Either.getOrThrow(Either.left("error"))) + * ``` + * + * @throws `Error("getOrThrow called on a Left")` + * + * @category getters + * @since 2.0.0 + */ +export declare const getOrThrow: (self: Either) => A; +/** + * Returns `self` if it is a `Right` or `that` otherwise. + * + * @category error handling + * @since 2.0.0 + */ +export declare const orElse: { + /** + * Returns `self` if it is a `Right` or `that` otherwise. + * + * @category error handling + * @since 2.0.0 + */ + (that: (left: E) => Either): (self: Either) => Either; + /** + * Returns `self` if it is a `Right` or `that` otherwise. + * + * @category error handling + * @since 2.0.0 + */ + (self: Either, that: (left: E) => Either): Either; +}; +/** + * @category sequencing + * @since 2.0.0 + */ +export declare const flatMap: { + /** + * @category sequencing + * @since 2.0.0 + */ + (f: (right: A) => Either): (self: Either) => Either; + /** + * @category sequencing + * @since 2.0.0 + */ + (self: Either, f: (right: A) => Either): Either; +}; +/** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ +export declare const andThen: { + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (f: (right: A) => Either): (self: Either) => Either; + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (f: Either): (self: Either) => Either; + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (f: (right: A) => A2): (self: Either) => Either; + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (right: NotFunction): (self: Either) => Either; + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (self: Either, f: (right: A) => Either): Either; + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (self: Either, f: Either): Either; + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (self: Either, f: (right: A) => A2): Either; + /** + * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`. + * + * @category sequencing + * @since 2.0.0 + */ + (self: Either, f: NotFunction): Either; +}; +/** + * @category zipping + * @since 2.0.0 + */ +export declare const zipWith: { + /** + * @category zipping + * @since 2.0.0 + */ + (that: Either, f: (right: A, right2: A2) => B): (self: Either) => Either; + /** + * @category zipping + * @since 2.0.0 + */ + (self: Either, that: Either, f: (right: A, right2: A2) => B): Either; +}; +/** + * @category combining + * @since 2.0.0 + */ +export declare const ap: { + /** + * @category combining + * @since 2.0.0 + */ + (that: Either): (self: Either<(right: A) => A2, E>) => Either; + /** + * @category combining + * @since 2.0.0 + */ + (self: Either<(right: A) => A2, E>, that: Either): Either; +}; +/** + * Takes a structure of `Either`s and returns an `Either` of values with the same structure. + * + * - If a tuple is supplied, then the returned `Either` will contain a tuple with the same length. + * - If a struct is supplied, then the returned `Either` will contain a struct with the same keys. + * - If an iterable is supplied, then the returned `Either` will contain an array. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either } from "effect" + * + * assert.deepStrictEqual(Either.all([Either.right(1), Either.right(2)]), Either.right([1, 2])) + * assert.deepStrictEqual(Either.all({ right: Either.right(1), b: Either.right("hello") }), Either.right({ right: 1, b: "hello" })) + * assert.deepStrictEqual(Either.all({ right: Either.right(1), b: Either.left("error") }), Either.left("error")) + * ``` + * + * @category combining + * @since 2.0.0 + */ +export declare const all: > | Record>>(input: I) => [I] extends [ReadonlyArray>] ? Either<{ + -readonly [K in keyof I]: [I[K]] extends [Either] ? A : never; +}, I[number] extends never ? never : [I[number]] extends [Either] ? E : never> : [I] extends [Iterable>] ? Either, E> : Either<{ + -readonly [K in keyof I]: [I[K]] extends [Either] ? A : never; +}, I[keyof I] extends never ? never : [I[keyof I]] extends [Either] ? E : never>; +/** + * Returns an `Either` that swaps the error/success cases. This allows you to + * use all methods on the error channel, possibly before flipping back. + * + * @since 2.0.0 + * @category mapping + */ +export declare const flip: (self: Either) => Either; +/** + * @category generators + * @since 2.0.0 + */ +export declare const gen: Gen.Gen>; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link bind} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category do notation + * @since 2.0.0 + */ +export declare const Do: Either<{}>; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category do notation + * @since 2.0.0 + */ +export declare const bind: { + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category do notation + * @since 2.0.0 + */ + (name: Exclude, f: (a: NoInfer) => Either): (self: Either) => Either<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E | E2>; + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category do notation + * @since 2.0.0 + */ + (self: Either, name: Exclude, f: (a: NoInfer) => Either): Either<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E | E2>; +}; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category do notation + * @since 2.0.0 + */ +export declare const bindTo: { + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category do notation + * @since 2.0.0 + */ + (name: N): (self: Either) => Either<{ + [K in N]: A; + }, E>; + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category do notation + * @since 2.0.0 + */ + (self: Either, name: N): Either<{ + [K in N]: A; + }, E>; +}; +declare const let_: { + (name: Exclude, f: (r: NoInfer) => B): (self: Either) => Either<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E>; + (self: Either, name: Exclude, f: (r: NoInfer) => B): Either<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }, E>; +}; +export { +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Either` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, pipe } from "effect" + * + * const result = pipe( + * Either.Do, + * Either.bind("x", () => Either.right(2)), + * Either.bind("y", () => Either.right(3)), + * Either.let("sum", ({ x, y }) => x + y) + * ) + * assert.deepStrictEqual(result, Either.right({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link bind} + * + * @category do notation + * @since 2.0.0 + */ +let_ as let }; +/** + * Converts an `Option` of an `Either` into an `Either` of an `Option`. + * + * **Details** + * + * This function transforms an `Option>` into an + * `Either, E>`. If the `Option` is `None`, the resulting `Either` + * will be a `Right` with a `None` value. If the `Option` is `Some`, the + * inner `Either` will be executed, and its result wrapped in a `Some`. + * + * @example + * ```ts + * import { Effect, Either, Option } from "effect" + * + * // ┌─── Option> + * // ▼ + * const maybe = Option.some(Either.right(42)) + * + * // ┌─── Either, never, never> + * // ▼ + * const result = Either.transposeOption(maybe) + * + * console.log(Effect.runSync(result)) + * // Output: { _id: 'Option', _tag: 'Some', value: 42 } + * ``` + * + * @since 3.14.0 + * @category Optional Wrapping & Unwrapping + */ +export declare const transposeOption: (self: Option>) => Either, 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, 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, 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 declare const transposeMapOption: ((f: (self: A) => Either) => (self: Option) => Either, E>) & ((self: Option, f: (self: A) => Either) => Either, E>); +//# sourceMappingURL=Either.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Encoding.d.ts b/backend/node_modules/effect/dist/dts/Encoding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb5477e97400ba4bb17c7072c5441d56b0592bb4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Encoding.d.ts @@ -0,0 +1,160 @@ +/** + * This module provides encoding & decoding functionality for: + * + * - base64 (RFC4648) + * - base64 (URL) + * - hex + * + * @since 2.0.0 + */ +import * as Either from "./Either.js"; +/** + * Encodes the given value into a base64 (RFC4648) `string`. + * + * @category encoding + * @since 2.0.0 + */ +export declare const encodeBase64: (input: Uint8Array | string) => string; +/** + * Decodes a base64 (RFC4648) encoded `string` into a `Uint8Array`. + * + * @category decoding + * @since 2.0.0 + */ +export declare const decodeBase64: (str: string) => Either.Either; +/** + * Decodes a base64 (RFC4648) encoded `string` into a UTF-8 `string`. + * + * @category decoding + * @since 2.0.0 + */ +export declare const decodeBase64String: (str: string) => Either.Either; +/** + * Encodes the given value into a base64 (URL) `string`. + * + * @category encoding + * @since 2.0.0 + */ +export declare const encodeBase64Url: (input: Uint8Array | string) => string; +/** + * Decodes a base64 (URL) encoded `string` into a `Uint8Array`. + * + * @category decoding + * @since 2.0.0 + */ +export declare const decodeBase64Url: (str: string) => Either.Either; +/** + * Decodes a base64 (URL) encoded `string` into a UTF-8 `string`. + * + * @category decoding + * @since 2.0.0 + */ +export declare const decodeBase64UrlString: (str: string) => Either.Either; +/** + * Encodes the given value into a hex `string`. + * + * @category encoding + * @since 2.0.0 + */ +export declare const encodeHex: (input: Uint8Array | string) => string; +/** + * Decodes a hex encoded `string` into a `Uint8Array`. + * + * @category decoding + * @since 2.0.0 + */ +export declare const decodeHex: (str: string) => Either.Either; +/** + * Decodes a hex encoded `string` into a UTF-8 `string`. + * + * @category decoding + * @since 2.0.0 + */ +export declare const decodeHexString: (str: string) => Either.Either; +/** + * Encodes a UTF-8 `string` into a URI component `string`. + * + * @category encoding + * @since 3.12.0 + */ +export declare const encodeUriComponent: (str: string) => Either.Either; +/** + * Decodes a URI component `string` into a UTF-8 `string`. + * + * @category decoding + * @since 3.12.0 + */ +export declare const decodeUriComponent: (str: string) => Either.Either; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const DecodeExceptionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type DecodeExceptionTypeId = typeof DecodeExceptionTypeId; +/** + * Represents a checked exception which occurs when decoding fails. + * + * @since 2.0.0 + * @category models + */ +export interface DecodeException { + readonly _tag: "DecodeException"; + readonly [DecodeExceptionTypeId]: DecodeExceptionTypeId; + readonly input: string; + readonly message?: string; +} +/** + * Creates a checked exception which occurs when decoding fails. + * + * @since 2.0.0 + * @category errors + */ +export declare const DecodeException: (input: string, message?: string) => DecodeException; +/** + * Returns `true` if the specified value is an `DecodeException`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isDecodeException: (u: unknown) => u is DecodeException; +/** + * @since 3.12.0 + * @category symbols + */ +export declare const EncodeExceptionTypeId: unique symbol; +/** + * @since 3.12.0 + * @category symbols + */ +export type EncodeExceptionTypeId = typeof EncodeExceptionTypeId; +/** + * Represents a checked exception which occurs when encoding fails. + * + * @since 3.12.0 + * @category models + */ +export interface EncodeException { + readonly _tag: "EncodeException"; + readonly [EncodeExceptionTypeId]: EncodeExceptionTypeId; + readonly input: string; + readonly message?: string; +} +/** + * Creates a checked exception which occurs when encoding fails. + * + * @since 3.12.0 + * @category errors + */ +export declare const EncodeException: (input: string, message?: string) => EncodeException; +/** + * Returns `true` if the specified value is an `EncodeException`, `false` otherwise. + * + * @since 3.12.0 + * @category refinements + */ +export declare const isEncodeException: (u: unknown) => u is EncodeException; +//# sourceMappingURL=Encoding.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Equal.d.ts.map b/backend/node_modules/effect/dist/dts/Equal.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..c26192eb1b56073f8e340ae618ae2cedb7e19c5b --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Equal.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Equal.d.ts","sourceRoot":"","sources":["../../src/Equal.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAIjC;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,MAAmC,CAAA;AAE/D;;;GAGG;AACH,MAAM,WAAW,KAAM,SAAQ,IAAI,CAAC,IAAI;IACtC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,CAAA;CAC/B;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;AAC3D,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAA;AA+DvD;;;GAGG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,KAA+B,CAAA;AAEzE;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,WAAW,CAAC,CAAC,CAAgB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Equivalence.d.ts b/backend/node_modules/effect/dist/dts/Equivalence.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2cabeb8b4d027816b8c5aa5a277c191d13dc36b1 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Equivalence.d.ts @@ -0,0 +1,158 @@ +import type { TypeLambda } from "./HKT.js"; +/** + * @category type class + * @since 2.0.0 + */ +export interface Equivalence { + (self: A, that: A): boolean; +} +/** + * @category type lambdas + * @since 2.0.0 + */ +export interface EquivalenceTypeLambda extends TypeLambda { + readonly type: Equivalence; +} +/** + * @category constructors + * @since 2.0.0 + */ +export declare const make: (isEquivalent: (self: A, that: A) => boolean) => Equivalence; +/** + * Return an `Equivalence` that uses strict equality (===) to compare values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const strict: () => Equivalence; +/** + * @category instances + * @since 2.0.0 + */ +export declare const string: Equivalence; +/** + * @category instances + * @since 2.0.0 + */ +export declare const number: Equivalence; +/** + * @category instances + * @since 2.0.0 + */ +export declare const boolean: Equivalence; +/** + * @category instances + * @since 2.0.0 + */ +export declare const bigint: Equivalence; +/** + * @category instances + * @since 2.0.0 + */ +export declare const symbol: Equivalence; +/** + * @category combining + * @since 2.0.0 + */ +export declare const combine: { + /** + * @category combining + * @since 2.0.0 + */ + (that: Equivalence): (self: Equivalence) => Equivalence; + /** + * @category combining + * @since 2.0.0 + */ + (self: Equivalence, that: Equivalence): Equivalence; +}; +/** + * @category combining + * @since 2.0.0 + */ +export declare const combineMany: { + /** + * @category combining + * @since 2.0.0 + */ + (collection: Iterable>): (self: Equivalence) => Equivalence; + /** + * @category combining + * @since 2.0.0 + */ + (self: Equivalence, collection: Iterable>): Equivalence; +}; +/** + * @category combining + * @since 2.0.0 + */ +export declare const combineAll: (collection: Iterable>) => Equivalence; +/** + * @category mapping + * @since 2.0.0 + */ +export declare const mapInput: { + /** + * @category mapping + * @since 2.0.0 + */ + (f: (b: B) => A): (self: Equivalence) => Equivalence; + /** + * @category mapping + * @since 2.0.0 + */ + (self: Equivalence, f: (b: B) => A): Equivalence; +}; +/** + * @category instances + * @since 2.0.0 + */ +export declare const Date: Equivalence; +/** + * @category combining + * @since 2.0.0 + */ +export declare const product: { + (that: Equivalence): (self: Equivalence) => Equivalence; + (self: Equivalence, that: Equivalence): Equivalence; +}; +/** + * @category combining + * @since 2.0.0 + */ +export declare const all: (collection: Iterable>) => Equivalence>; +/** + * @category combining + * @since 2.0.0 + */ +export declare const productMany: (self: Equivalence, collection: Iterable>) => Equivalence]>; +/** + * Similar to `Promise.all` but operates on `Equivalence`s. + * + * ```ts skip-type-checking + * [Equivalence, Equivalence, ...] -> Equivalence<[A, B, ...]> + * ``` + * + * Given a tuple of `Equivalence`s returns a new `Equivalence` that compares values of a tuple + * by applying each `Equivalence` to the corresponding element of the tuple. + * + * @category combinators + * @since 2.0.0 + */ +export declare const tuple: >>(...elements: T) => Equivalence] ? A : never; }>>; +/** + * Creates a new `Equivalence` for an array of values based on a given `Equivalence` for the elements of the array. + * + * @category combinators + * @since 2.0.0 + */ +export declare const array: (item: Equivalence) => Equivalence>; +/** + * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct + * by applying each `Equivalence` to the corresponding property of the struct. + * + * @category combinators + * @since 2.0.0 + */ +export declare const struct: >>(fields: R) => Equivalence<{ readonly [K in keyof R]: [R[K]] extends [Equivalence] ? A : never; }>; +//# sourceMappingURL=Equivalence.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Equivalence.d.ts.map b/backend/node_modules/effect/dist/dts/Equivalence.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e105bc0d4f88da4b9ebf0cf14b1a8ae52815135c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Equivalence.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Equivalence.d.ts","sourceRoot":"","sources":["../../src/Equivalence.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ExecutionPlan.d.ts b/backend/node_modules/effect/dist/dts/ExecutionPlan.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6af4cce74455d928a16132ca8093c21b570e7876 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ExecutionPlan.d.ts @@ -0,0 +1,210 @@ +/** + * @since 3.16.0 + * @experimental + */ +import type { NonEmptyReadonlyArray } from "./Array.js"; +import type * as Context from "./Context.js"; +import * as Effect from "./Effect.js"; +import * as Layer from "./Layer.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Schedule from "./Schedule.js"; +/** + * @since 3.16.0 + * @category Symbols + * @experimental + */ +export declare const TypeId: unique symbol; +/** + * @since 3.16.0 + * @category Symbols + * @experimental + */ +export type TypeId = typeof TypeId; +/** + * @since 3.16.0 + * @category Guards + * @experimental + */ +export declare const isExecutionPlan: (u: unknown) => u is ExecutionPlan; +/** + * A `ExecutionPlan` can be used with `Effect.withExecutionPlan` or `Stream.withExecutionPlan`, allowing you to provide different resources for each step of execution until the effect succeeds or the plan is exhausted. + * + * ```ts + * import type { LanguageModel } from "@effect/ai" + * import type { Layer } from "effect" + * import { Effect, ExecutionPlan, Schedule } from "effect" + * + * declare const layerBad: Layer.Layer + * declare const layerGood: Layer.Layer + * + * const ThePlan = ExecutionPlan.make( + * { + * // First try with the bad layer 2 times with a 3 second delay between attempts + * provide: layerBad, + * attempts: 2, + * schedule: Schedule.spaced(3000) + * }, + * // Then try with the bad layer 3 times with a 1 second delay between attempts + * { + * provide: layerBad, + * attempts: 3, + * schedule: Schedule.spaced(1000) + * }, + * // Finally try with the good layer. + * // + * // If `attempts` is omitted, the plan will only attempt once, unless a schedule is provided. + * { + * provide: layerGood + * } + * ) + * + * declare const effect: Effect.Effect< + * void, + * never, + * LanguageModel.LanguageModel + * > + * const withPlan: Effect.Effect = Effect.withExecutionPlan(effect, ThePlan) + * ``` + * + * @since 3.16.0 + * @category Models + * @experimental + */ +export interface ExecutionPlan extends Pipeable { + readonly [TypeId]: TypeId; + readonly steps: NonEmptyReadonlyArray<{ + readonly provide: Context.Context | Layer.Layer; + readonly attempts?: number | undefined; + readonly while?: ((input: Types["input"]) => Effect.Effect) | undefined; + readonly schedule?: Schedule.Schedule | undefined; + }>; + /** + * Returns an equivalent `ExecutionPlan` with the requirements satisfied, + * using the current context. + */ + readonly withRequirements: Effect.Effect, never, Types["requirements"]>; +} +/** + * @since 3.16.0 + * @experimental + */ +export type TypesBase = { + provides: any; + input: any; + error: any; + requirements: any; +}; +/** + * Create an `ExecutionPlan`, which can be used with `Effect.withExecutionPlan` or `Stream.withExecutionPlan`, allowing you to provide different resources for each step of execution until the effect succeeds or the plan is exhausted. + * + * ```ts + * import type { LanguageModel } from "@effect/ai" + * import type { Layer } from "effect" + * import { Effect, ExecutionPlan, Schedule } from "effect" + * + * declare const layerBad: Layer.Layer + * declare const layerGood: Layer.Layer + * + * const ThePlan = ExecutionPlan.make( + * { + * // First try with the bad layer 2 times with a 3 second delay between attempts + * provide: layerBad, + * attempts: 2, + * schedule: Schedule.spaced(3000) + * }, + * // Then try with the bad layer 3 times with a 1 second delay between attempts + * { + * provide: layerBad, + * attempts: 3, + * schedule: Schedule.spaced(1000) + * }, + * // Finally try with the good layer. + * // + * // If `attempts` is omitted, the plan will only attempt once, unless a schedule is provided. + * { + * provide: layerGood + * } + * ) + * + * declare const effect: Effect.Effect< + * void, + * never, + * LanguageModel.LanguageModel + * > + * const withPlan: Effect.Effect = Effect.withExecutionPlan(effect, ThePlan) + * ``` + * + * @since 3.16.0 + * @category Constructors + * @experimental + */ +export declare const make: >(...steps: Steps & { [K in keyof Steps]: make.Step; }) => ExecutionPlan<{ + provides: make.StepProvides; + input: make.StepInput; + error: (Steps[number]["provide"] extends Context.Context | Layer.Layer ? E : never) | (Steps[number]["while"] extends (input: infer _I) => Effect.Effect ? _E : never); + requirements: (Steps[number]["provide"] extends Layer.Layer ? R : never) | (Steps[number]["while"] extends (input: infer _I) => Effect.Effect ? R_1 : never) | (Steps[number]["schedule"] extends Schedule.Schedule ? R_2 : never); +}>; +/** + * @since 3.16.0 + * @experimental + */ +export declare namespace make { + /** + * @since 3.16.0 + * @experimental + */ + type Step = { + readonly provide: Context.Context | Context.Context | Layer.Layer.Any; + readonly attempts?: number | undefined; + readonly while?: ((input: any) => boolean | Effect.Effect) | undefined; + readonly schedule?: Schedule.Schedule | undefined; + }; + /** + * @since 3.16.1 + * @experimental + */ + type StepProvides, Out = unknown> = Steps extends readonly [infer Step, ...infer Rest] ? StepProvides | Layer.Layer; + } ? P : unknown))> : Out; + /** + * @since 3.16.1 + * @experimental + */ + type PlanProvides, Out = unknown> = Plans extends readonly [infer Plan, ...infer Rest] ? PlanProvides ? T["provides"] : unknown)> : Out; + /** + * @since 3.16.0 + * @experimental + */ + type StepInput, Out = unknown> = Steps extends readonly [infer Step, ...infer Rest] ? StepInput infer _; + } ? I : unknown) & (Step extends { + readonly schedule: Schedule.Schedule; + } ? I : unknown))> : Out; + /** + * @since 3.16.0 + * @experimental + */ + type PlanInput, Out = unknown> = Plans extends readonly [infer Plan, ...infer Rest] ? PlanInput ? T["input"] : unknown)> : Out; +} +/** + * @since 3.16.0 + * @category Combining + * @experimental + */ +export declare const merge: >>(...plans: Plans) => ExecutionPlan<{ + provides: make.PlanProvides; + input: make.PlanInput; + error: Plans[number] extends ExecutionPlan ? T["error"] : never; + requirements: Plans[number] extends ExecutionPlan ? T["requirements"] : never; +}>; +//# sourceMappingURL=ExecutionPlan.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ExecutionStrategy.d.ts b/backend/node_modules/effect/dist/dts/ExecutionStrategy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d5c183937518a7cc633ea7fa844947b2261c0210 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ExecutionStrategy.d.ts @@ -0,0 +1,122 @@ +/** + * @since 2.0.0 + */ +import type { LazyArg } from "./Function.js"; +/** + * Describes a strategy for evaluating multiple effects, potentially in + * parallel. + * + * There are 3 possible execution strategies: `Sequential`, `Parallel`, + * `ParallelN`. + * + * @since 2.0.0 + * @category models + */ +export type ExecutionStrategy = Sequential | Parallel | ParallelN; +/** + * Execute effects sequentially. + * + * @since 2.0.0 + * @category models + */ +export interface Sequential { + readonly _tag: "Sequential"; +} +/** + * Execute effects in parallel. + * + * @since 2.0.0 + * @category models + */ +export interface Parallel { + readonly _tag: "Parallel"; +} +/** + * Execute effects in parallel, up to the specified number of concurrent fibers. + * + * @since 2.0.0 + * @category models + */ +export interface ParallelN { + readonly _tag: "ParallelN"; + readonly parallelism: number; +} +/** + * Execute effects sequentially. + * + * @since 2.0.0 + * @category constructors + */ +export declare const sequential: ExecutionStrategy; +/** + * Execute effects in parallel. + * + * @since 2.0.0 + * @category constructors + */ +export declare const parallel: ExecutionStrategy; +/** + * Execute effects in parallel, up to the specified number of concurrent fibers. + * + * @since 2.0.0 + * @category constructors + */ +export declare const parallelN: (parallelism: number) => ExecutionStrategy; +/** + * Returns `true` if the specified `ExecutionStrategy` is an instance of + * `Sequential`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isSequential: (self: ExecutionStrategy) => self is Sequential; +/** + * Returns `true` if the specified `ExecutionStrategy` is an instance of + * `Sequential`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isParallel: (self: ExecutionStrategy) => self is Parallel; +/** + * Returns `true` if the specified `ExecutionStrategy` is an instance of + * `Sequential`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isParallelN: (self: ExecutionStrategy) => self is ParallelN; +/** + * Folds over the specified `ExecutionStrategy` using the provided case + * functions. + * + * @since 2.0.0 + * @category folding + */ +export declare const match: { + /** + * Folds over the specified `ExecutionStrategy` using the provided case + * functions. + * + * @since 2.0.0 + * @category folding + */ + (options: { + readonly onSequential: LazyArg; + readonly onParallel: LazyArg; + readonly onParallelN: (n: number) => A; + }): (self: ExecutionStrategy) => A; + /** + * Folds over the specified `ExecutionStrategy` using the provided case + * functions. + * + * @since 2.0.0 + * @category folding + */ + (self: ExecutionStrategy, options: { + readonly onSequential: LazyArg; + readonly onParallel: LazyArg; + readonly onParallelN: (n: number) => A; + }): A; +}; +//# sourceMappingURL=ExecutionStrategy.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FastCheck.d.ts.map b/backend/node_modules/effect/dist/dts/FastCheck.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..30e2d2cb26ea925b43885e73fef93820f9ad8c55 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FastCheck.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"FastCheck.d.ts","sourceRoot":"","sources":["../../src/FastCheck.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,cAAc,YAAY,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Fiber.d.ts b/backend/node_modules/effect/dist/dts/Fiber.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fa9689a43d5930622fac9a004babfee38bdbc102 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Fiber.d.ts @@ -0,0 +1,831 @@ +/** + * @since 2.0.0 + */ +import type * as Cause from "./Cause.js"; +import type { Context } from "./Context.js"; +import type { DefaultServices } from "./DefaultServices.js"; +import type * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type * as Exit from "./Exit.js"; +import type * as FiberId from "./FiberId.js"; +import type { FiberRef } from "./FiberRef.js"; +import type * as FiberRefs from "./FiberRefs.js"; +import type * as FiberStatus from "./FiberStatus.js"; +import type * as HashSet from "./HashSet.js"; +import type * as Option from "./Option.js"; +import type * as order from "./Order.js"; +import type * as RuntimeFlags from "./RuntimeFlags.js"; +import type { Scheduler } from "./Scheduler.js"; +import type * as Scope from "./Scope.js"; +import type { Supervisor } from "./Supervisor.js"; +import type { AnySpan, Tracer } from "./Tracer.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FiberTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FiberTypeId = typeof FiberTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const RuntimeFiberTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type RuntimeFiberTypeId = typeof RuntimeFiberTypeId; +/** + * A fiber is a lightweight thread of execution that never consumes more than a + * whole thread (but may consume much less, depending on contention and + * asynchronicity). Fibers are spawned by forking effects, which run + * concurrently with the parent effect. + * + * Fibers can be joined, yielding their result to other fibers, or interrupted, + * which terminates the fiber, safely releasing all resources. + * + * @since 2.0.0 + * @category models + */ +export interface Fiber extends Effect.Effect, Fiber.Variance { + /** + * The identity of the fiber. + */ + id(): FiberId.FiberId; + /** + * Awaits the fiber, which suspends the awaiting fiber until the result of the + * fiber has been determined. + */ + readonly await: Effect.Effect>; + /** + * Retrieves the immediate children of the fiber. + */ + readonly children: Effect.Effect>>; + /** + * Inherits values from all `FiberRef` instances into current fiber. This + * will resume immediately. + */ + readonly inheritAll: Effect.Effect; + /** + * Tentatively observes the fiber, but returns immediately if it is not + * already done. + */ + readonly poll: Effect.Effect>>; + /** + * In the background, interrupts the fiber as if interrupted from the + * specified fiber. If the fiber has already exited, the returned effect will + * resume immediately. Otherwise, the effect will resume when the fiber exits. + */ + interruptAsFork(fiberId: FiberId.FiberId): Effect.Effect; + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: FiberUnify; + readonly [Unify.ignoreSymbol]?: FiberUnifyIgnore; +} +/** + * @category models + * @since 3.8.0 + */ +export interface FiberUnify extends Effect.EffectUnify { + Fiber?: () => A[Unify.typeSymbol] extends Fiber | infer _ ? Fiber : never; +} +/** + * @category models + * @since 3.8.0 + */ +export interface FiberUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * A runtime fiber that is executing an effect. Runtime fibers have an + * identity and a trace. + * + * @since 2.0.0 + * @category models + */ +export interface RuntimeFiber extends Fiber, Fiber.RuntimeVariance { + /** + * Reads the current number of ops that have occurred since the last yield + */ + get currentOpCount(): number; + /** + * Reads the current value of a fiber ref + */ + getFiberRef(fiberRef: FiberRef): X; + /** + * The identity of the fiber. + */ + id(): FiberId.Runtime; + /** + * The status of the fiber. + */ + readonly status: Effect.Effect; + /** + * Returns the current `RuntimeFlags` the fiber is running with. + */ + readonly runtimeFlags: Effect.Effect; + /** + * Adds an observer to the list of observers. + */ + addObserver(observer: (exit: Exit.Exit) => void): void; + /** + * Removes the specified observer from the list of observers that will be + * notified when the fiber exits. + */ + removeObserver(observer: (exit: Exit.Exit) => void): void; + /** + * Retrieves all fiber refs of the fiber. + */ + getFiberRefs(): FiberRefs.FiberRefs; + /** + * Unsafely observes the fiber, but returns immediately if it is not + * already done. + */ + unsafePoll(): Exit.Exit | null; + /** + * In the background, interrupts the fiber as if interrupted from the + * specified fiber. If the fiber has already exited, the returned effect will + * resume immediately. Otherwise, the effect will resume when the fiber exits. + */ + unsafeInterruptAsFork(fiberId: FiberId.FiberId): void; + /** + * Gets the current context + */ + get currentContext(): Context; + /** + * Gets the current context + */ + get currentDefaultServices(): Context; + /** + * Gets the current scheduler + */ + get currentScheduler(): Scheduler; + /** + * Gets the current tracer + */ + get currentTracer(): Tracer; + /** + * Gets the current span + */ + get currentSpan(): AnySpan | undefined; + /** + * Gets the current supervisor + */ + get currentSupervisor(): Supervisor; + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: RuntimeFiberUnify; + readonly [Unify.ignoreSymbol]?: RuntimeFiberUnifyIgnore; +} +/** + * @category models + * @since 3.8.0 + */ +export interface RuntimeFiberUnify extends FiberUnify { + RuntimeFiber?: () => A[Unify.typeSymbol] extends RuntimeFiber | infer _ ? RuntimeFiber : never; +} +/** + * @category models + * @since 3.8.0 + */ +export interface RuntimeFiberUnifyIgnore extends FiberUnifyIgnore { + Fiber?: true; +} +/** + * @since 2.0.0 + */ +export declare namespace Fiber { + /** + * @since 2.0.0 + * @category models + */ + type Runtime = RuntimeFiber; + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [FiberTypeId]: { + readonly _A: Types.Covariant; + readonly _E: Types.Covariant; + }; + } + /** + * @since 2.0.0 + */ + interface RuntimeVariance { + readonly [RuntimeFiberTypeId]: { + readonly _A: Types.Covariant; + readonly _E: Types.Covariant; + }; + } + /** + * @since 2.0.0 + * @category models + */ + interface Dump { + /** + * The fiber's unique identifier. + */ + readonly id: FiberId.Runtime; + /** + * The status of the fiber. + */ + readonly status: FiberStatus.FiberStatus; + } + /** + * A record containing information about a `Fiber`. + * + * @since 2.0.0 + * @category models + */ + interface Descriptor { + /** + * The fiber's unique identifier. + */ + readonly id: FiberId.FiberId; + /** + * The status of the fiber. + */ + readonly status: FiberStatus.FiberStatus; + /** + * The set of fibers attempting to interrupt the fiber or its ancestors. + */ + readonly interruptors: HashSet.HashSet; + } +} +/** + * @since 2.0.0 + * @category instances + */ +export declare const Order: order.Order>; +/** + * Returns `true` if the specified value is a `Fiber`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isFiber: (u: unknown) => u is Fiber; +/** + * Returns `true` if the specified `Fiber` is a `RuntimeFiber`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isRuntimeFiber: (self: Fiber) => self is RuntimeFiber; +/** + * The identity of the fiber. + * + * @since 2.0.0 + * @category getters + */ +export declare const id: (self: Fiber) => FiberId.FiberId; +declare const _await: (self: Fiber) => Effect.Effect>; +export { +/** + * Awaits the fiber, which suspends the awaiting fiber until the result of the + * fiber has been determined. + * + * @since 2.0.0 + * @category getters + */ +_await as await }; +/** + * Awaits on all fibers to be completed, successfully or not. + * + * @since 2.0.0 + * @category destructors + */ +export declare const awaitAll: >>(fibers: T) => Effect.Effect<[ + T +] extends [ReadonlyArray] ? number extends T["length"] ? Array ? Exit.Exit : never> : { + -readonly [K in keyof T]: T[K] extends Fiber ? Exit.Exit : never; +} : Array ? U extends Fiber ? Exit.Exit : never : never>>; +/** + * Retrieves the immediate children of the fiber. + * + * @since 2.0.0 + * @category getters + */ +export declare const children: (self: Fiber) => Effect.Effect>>; +/** + * Collects all fibers into a single fiber producing an in-order list of the + * results. + * + * @since 2.0.0 + * @category constructors + */ +export declare const all: (fibers: Iterable>) => Fiber, E>; +/** + * A fiber that is done with the specified `Exit` value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const done: (exit: Exit.Exit) => Fiber; +/** + * @since 2.0.0 + * @category destructors + */ +export declare const dump: (self: RuntimeFiber) => Effect.Effect; +/** + * @since 2.0.0 + * @category destructors + */ +export declare const dumpAll: (fibers: Iterable>) => Effect.Effect>; +/** + * A fiber that has already failed with the specified value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fail: (error: E) => Fiber; +/** + * Creates a `Fiber` that has already failed with the specified cause. + * + * @since 2.0.0 + * @category constructors + */ +export declare const failCause: (cause: Cause.Cause) => Fiber; +/** + * Lifts an `Effect` into a `Fiber`. + * + * @since 2.0.0 + * @category conversions + */ +export declare const fromEffect: (effect: Effect.Effect) => Effect.Effect>; +/** + * Gets the current fiber if one is running. + * + * @since 2.0.0 + * @category utilities + */ +export declare const getCurrentFiber: () => Option.Option>; +/** + * Inherits values from all `FiberRef` instances into current fiber. This + * will resume immediately. + * + * @since 2.0.0 + * @category destructors + */ +export declare const inheritAll: (self: Fiber) => Effect.Effect; +/** + * Interrupts the fiber from whichever fiber is calling this method. If the + * fiber has already exited, the returned effect will resume immediately. + * Otherwise, the effect will resume when the fiber exits. + * + * @since 2.0.0 + * @category interruption + */ +export declare const interrupt: (self: Fiber) => Effect.Effect>; +/** + * Constructrs a `Fiber` that is already interrupted. + * + * @since 2.0.0 + * @category constructors + */ +export declare const interrupted: (fiberId: FiberId.FiberId) => Fiber; +/** + * Interrupts the fiber as if interrupted from the specified fiber. If the + * fiber has already exited, the returned effect will resume immediately. + * Otherwise, the effect will resume when the fiber exits. + * + * @since 2.0.0 + * @category interruption + */ +export declare const interruptAs: { + /** + * Interrupts the fiber as if interrupted from the specified fiber. If the + * fiber has already exited, the returned effect will resume immediately. + * Otherwise, the effect will resume when the fiber exits. + * + * @since 2.0.0 + * @category interruption + */ + (fiberId: FiberId.FiberId): (self: Fiber) => Effect.Effect>; + /** + * Interrupts the fiber as if interrupted from the specified fiber. If the + * fiber has already exited, the returned effect will resume immediately. + * Otherwise, the effect will resume when the fiber exits. + * + * @since 2.0.0 + * @category interruption + */ + (self: Fiber, fiberId: FiberId.FiberId): Effect.Effect>; +}; +/** + * Interrupts the fiber as if interrupted from the specified fiber. If the + * fiber has already exited, the returned effect will resume immediately. + * Otherwise, the effect will resume when the fiber exits. + * + * @since 2.0.0 + * @category interruption + */ +export declare const interruptAsFork: { + /** + * Interrupts the fiber as if interrupted from the specified fiber. If the + * fiber has already exited, the returned effect will resume immediately. + * Otherwise, the effect will resume when the fiber exits. + * + * @since 2.0.0 + * @category interruption + */ + (fiberId: FiberId.FiberId): (self: Fiber) => Effect.Effect; + /** + * Interrupts the fiber as if interrupted from the specified fiber. If the + * fiber has already exited, the returned effect will resume immediately. + * Otherwise, the effect will resume when the fiber exits. + * + * @since 2.0.0 + * @category interruption + */ + (self: Fiber, fiberId: FiberId.FiberId): Effect.Effect; +}; +/** + * Interrupts all fibers, awaiting their interruption. + * + * @since 2.0.0 + * @category interruption + */ +export declare const interruptAll: (fibers: Iterable>) => Effect.Effect; +/** + * Interrupts all fibers as by the specified fiber, awaiting their + * interruption. + * + * @since 2.0.0 + * @category interruption + */ +export declare const interruptAllAs: { + /** + * Interrupts all fibers as by the specified fiber, awaiting their + * interruption. + * + * @since 2.0.0 + * @category interruption + */ + (fiberId: FiberId.FiberId): (fibers: Iterable>) => Effect.Effect; + /** + * Interrupts all fibers as by the specified fiber, awaiting their + * interruption. + * + * @since 2.0.0 + * @category interruption + */ + (fibers: Iterable>, fiberId: FiberId.FiberId): Effect.Effect; +}; +/** + * Interrupts the fiber from whichever fiber is calling this method. The + * interruption will happen in a separate daemon fiber, and the returned + * effect will always resume immediately without waiting. + * + * @since 2.0.0 + * @category interruption + */ +export declare const interruptFork: (self: Fiber) => Effect.Effect; +/** + * Joins the fiber, which suspends the joining fiber until the result of the + * fiber has been determined. Attempting to join a fiber that has erred will + * result in a catchable error. Joining an interrupted fiber will result in an + * "inner interruption" of this fiber, unlike interruption triggered by + * another fiber, "inner interruption" can be caught and recovered. + * + * @since 2.0.0 + * @category destructors + */ +export declare const join: (self: Fiber) => Effect.Effect; +/** + * Joins all fibers, awaiting their _successful_ completion. Attempting to + * join a fiber that has erred will result in a catchable error, _if_ that + * error does not result from interruption. + * + * @since 2.0.0 + * @category destructors + */ +export declare const joinAll: (fibers: Iterable>) => Effect.Effect, E>; +/** + * Maps over the value the Fiber computes. + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Maps over the value the Fiber computes. + * + * @since 2.0.0 + * @category mapping + */ + (f: (a: A) => B): (self: Fiber) => Fiber; + /** + * Maps over the value the Fiber computes. + * + * @since 2.0.0 + * @category mapping + */ + (self: Fiber, f: (a: A) => B): Fiber; +}; +/** + * Effectually maps over the value the fiber computes. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapEffect: { + /** + * Effectually maps over the value the fiber computes. + * + * @since 2.0.0 + * @category mapping + */ + (f: (a: A) => Effect.Effect): (self: Fiber) => Fiber; + /** + * Effectually maps over the value the fiber computes. + * + * @since 2.0.0 + * @category mapping + */ + (self: Fiber, f: (a: A) => Effect.Effect): Fiber; +}; +/** + * Passes the success of this fiber to the specified callback, and continues + * with the fiber that it returns. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapFiber: { + /** + * Passes the success of this fiber to the specified callback, and continues + * with the fiber that it returns. + * + * @since 2.0.0 + * @category mapping + */ + (f: (a: A) => Fiber): (self: Fiber) => Effect.Effect>; + /** + * Passes the success of this fiber to the specified callback, and continues + * with the fiber that it returns. + * + * @since 2.0.0 + * @category mapping + */ + (self: Fiber, f: (a: A) => Fiber): Effect.Effect>; +}; +/** + * Folds over the `Fiber` or `RuntimeFiber`. + * + * @since 2.0.0 + * @category folding + */ +export declare const match: { + /** + * Folds over the `Fiber` or `RuntimeFiber`. + * + * @since 2.0.0 + * @category folding + */ + (options: { + readonly onFiber: (fiber: Fiber) => Z; + readonly onRuntimeFiber: (fiber: RuntimeFiber) => Z; + }): (self: Fiber) => Z; + /** + * Folds over the `Fiber` or `RuntimeFiber`. + * + * @since 2.0.0 + * @category folding + */ + (self: Fiber, options: { + readonly onFiber: (fiber: Fiber) => Z; + readonly onRuntimeFiber: (fiber: RuntimeFiber) => Z; + }): Z; +}; +/** + * A fiber that never fails or succeeds. + * + * @since 2.0.0 + * @category constructors + */ +export declare const never: Fiber; +/** + * Returns a fiber that prefers `this` fiber, but falls back to the `that` one + * when `this` one fails. Interrupting the returned fiber will interrupt both + * fibers, sequentially, from left to right. + * + * @since 2.0.0 + * @category alternatives + */ +export declare const orElse: { + /** + * Returns a fiber that prefers `this` fiber, but falls back to the `that` one + * when `this` one fails. Interrupting the returned fiber will interrupt both + * fibers, sequentially, from left to right. + * + * @since 2.0.0 + * @category alternatives + */ + (that: Fiber): (self: Fiber) => Fiber; + /** + * Returns a fiber that prefers `this` fiber, but falls back to the `that` one + * when `this` one fails. Interrupting the returned fiber will interrupt both + * fibers, sequentially, from left to right. + * + * @since 2.0.0 + * @category alternatives + */ + (self: Fiber, that: Fiber): Fiber; +}; +/** + * Returns a fiber that prefers `this` fiber, but falls back to the `that` one + * when `this` one fails. Interrupting the returned fiber will interrupt both + * fibers, sequentially, from left to right. + * + * @since 2.0.0 + * @category alternatives + */ +export declare const orElseEither: { + /** + * Returns a fiber that prefers `this` fiber, but falls back to the `that` one + * when `this` one fails. Interrupting the returned fiber will interrupt both + * fibers, sequentially, from left to right. + * + * @since 2.0.0 + * @category alternatives + */ + (that: Fiber): (self: Fiber) => Fiber, E2 | E>; + /** + * Returns a fiber that prefers `this` fiber, but falls back to the `that` one + * when `this` one fails. Interrupting the returned fiber will interrupt both + * fibers, sequentially, from left to right. + * + * @since 2.0.0 + * @category alternatives + */ + (self: Fiber, that: Fiber): Fiber, E | E2>; +}; +/** + * Tentatively observes the fiber, but returns immediately if it is not + * already done. + * + * @since 2.0.0 + * @category getters + */ +export declare const poll: (self: Fiber) => Effect.Effect>>; +/** + * Pretty-prints a `RuntimeFiber`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const pretty: (self: RuntimeFiber) => Effect.Effect; +/** + * Returns a chunk containing all root fibers. + * + * @since 2.0.0 + * @category constructors + */ +export declare const roots: Effect.Effect>>; +/** + * Returns a chunk containing all root fibers. + * + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeRoots: (_: void) => Array>; +/** + * Converts this fiber into a scoped effect. The fiber is interrupted when the + * scope is closed. + * + * @since 2.0.0 + * @category destructors + */ +export declare const scoped: (self: Fiber) => Effect.Effect, never, Scope.Scope>; +/** + * Returns the `FiberStatus` of a `RuntimeFiber`. + * + * @since 2.0.0 + * @category getters + */ +export declare const status: (self: RuntimeFiber) => Effect.Effect; +/** + * Returns a fiber that has already succeeded with the specified value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const succeed: (value: A) => Fiber; +declare const void_: Fiber; +export { +/** + * A fiber that has already succeeded with unit. + * + * @since 2.0.0 + * @category constructors + */ +void_ as void }; +/** + * Zips this fiber and the specified fiber together, producing a tuple of + * their output. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zip: { + /** + * Zips this fiber and the specified fiber together, producing a tuple of + * their output. + * + * @since 2.0.0 + * @category zipping + */ + (that: Fiber): (self: Fiber) => Fiber<[A, A2], E2 | E>; + /** + * Zips this fiber and the specified fiber together, producing a tuple of + * their output. + * + * @since 2.0.0 + * @category zipping + */ + (self: Fiber, that: Fiber): Fiber<[A, A2], E | E2>; +}; +/** + * Same as `zip` but discards the output of that `Fiber`. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipLeft: { + /** + * Same as `zip` but discards the output of that `Fiber`. + * + * @since 2.0.0 + * @category zipping + */ + (that: Fiber): (self: Fiber) => Fiber; + /** + * Same as `zip` but discards the output of that `Fiber`. + * + * @since 2.0.0 + * @category zipping + */ + (self: Fiber, that: Fiber): Fiber; +}; +/** + * Same as `zip` but discards the output of this `Fiber`. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipRight: { + /** + * Same as `zip` but discards the output of this `Fiber`. + * + * @since 2.0.0 + * @category zipping + */ + (that: Fiber): (self: Fiber) => Fiber; + /** + * Same as `zip` but discards the output of this `Fiber`. + * + * @since 2.0.0 + * @category zipping + */ + (self: Fiber, that: Fiber): Fiber; +}; +/** + * Zips this fiber with the specified fiber, combining their results using the + * specified combiner function. Both joins and interruptions are performed in + * sequential order from left to right. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipWith: { + /** + * Zips this fiber with the specified fiber, combining their results using the + * specified combiner function. Both joins and interruptions are performed in + * sequential order from left to right. + * + * @since 2.0.0 + * @category zipping + */ + (that: Fiber, f: (a: A, b: B) => C): (self: Fiber) => Fiber; + /** + * Zips this fiber with the specified fiber, combining their results using the + * specified combiner function. Both joins and interruptions are performed in + * sequential order from left to right. + * + * @since 2.0.0 + * @category zipping + */ + (self: Fiber, that: Fiber, f: (a: A, b: B) => C): Fiber; +}; +//# sourceMappingURL=Fiber.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Fiber.d.ts.map b/backend/node_modules/effect/dist/dts/Fiber.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..33ed101656cfcc74192688891e131a6b5400d532 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Fiber.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Fiber.d.ts","sourceRoot":"","sources":["../../src/Fiber.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberHandle.d.ts.map b/backend/node_modules/effect/dist/dts/FiberHandle.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..8de010475f37aee22ee40fae5aa53c9c9a6bc1c5 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberHandle.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"FiberHandle.d.ts","sourceRoot":"","sources":["../../src/FiberHandle.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberId.d.ts b/backend/node_modules/effect/dist/dts/FiberId.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1e52915ed3b5002b28db5d4dafffec85b5a842ee --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberId.d.ts @@ -0,0 +1,196 @@ +/** + * @since 2.0.0 + */ +import type * as Equal from "./Equal.js"; +import type * as HashSet from "./HashSet.js"; +import type { Inspectable } from "./Inspectable.js"; +import type * as Option from "./Option.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FiberIdTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FiberIdTypeId = typeof FiberIdTypeId; +/** + * @since 2.0.0 + * @category models + */ +export type Single = None | Runtime; +/** + * @since 2.0.0 + * @category models + */ +export type FiberId = Single | Composite; +/** + * @since 2.0.0 + * @category models + */ +export interface None extends Equal.Equal, Inspectable { + readonly [FiberIdTypeId]: FiberIdTypeId; + readonly _tag: "None"; + readonly id: -1; + readonly startTimeMillis: -1; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Runtime extends Equal.Equal, Inspectable { + readonly [FiberIdTypeId]: FiberIdTypeId; + readonly _tag: "Runtime"; + readonly id: number; + readonly startTimeMillis: number; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Composite extends Equal.Equal, Inspectable { + readonly [FiberIdTypeId]: FiberIdTypeId; + readonly _tag: "Composite"; + readonly left: FiberId; + readonly right: FiberId; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const none: None; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const runtime: (id: number, startTimeMillis: number) => Runtime; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const composite: (left: FiberId, right: FiberId) => Composite; +/** + * Returns `true` if the specified unknown value is a `FiberId`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isFiberId: (self: unknown) => self is FiberId; +/** + * Returns `true` if the `FiberId` is a `None`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isNone: (self: FiberId) => self is None; +/** + * Returns `true` if the `FiberId` is a `Runtime`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isRuntime: (self: FiberId) => self is Runtime; +/** + * Returns `true` if the `FiberId` is a `Composite`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isComposite: (self: FiberId) => self is Composite; +/** + * Combine two `FiberId`s. + * + * @since 2.0.0 + * @category constructors + */ +export declare const combine: { + /** + * Combine two `FiberId`s. + * + * @since 2.0.0 + * @category constructors + */ + (that: FiberId): (self: FiberId) => FiberId; + /** + * Combine two `FiberId`s. + * + * @since 2.0.0 + * @category constructors + */ + (self: FiberId, that: FiberId): FiberId; +}; +/** + * Combines a set of `FiberId`s into a single `FiberId`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const combineAll: (fiberIds: HashSet.HashSet) => FiberId; +/** + * Returns this `FiberId` if it is not `None`, otherwise returns that `FiberId`. + * + * @since 2.0.0 + * @category utils + */ +export declare const getOrElse: { + /** + * Returns this `FiberId` if it is not `None`, otherwise returns that `FiberId`. + * + * @since 2.0.0 + * @category utils + */ + (that: FiberId): (self: FiberId) => FiberId; + /** + * Returns this `FiberId` if it is not `None`, otherwise returns that `FiberId`. + * + * @since 2.0.0 + * @category utils + */ + (self: FiberId, that: FiberId): FiberId; +}; +/** + * Get the set of identifiers for this `FiberId`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const ids: (self: FiberId) => HashSet.HashSet; +/** + * Creates a new `FiberId`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (id: number, startTimeSeconds: number) => FiberId; +/** + * Creates a string representing the name of the current thread of execution + * represented by the specified `FiberId`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const threadName: (self: FiberId) => string; +/** + * Convert a `FiberId` into an `Option`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const toOption: (self: FiberId) => Option.Option; +/** + * Convert a `FiberId` into a `HashSet`. + * + * @since 2.0.0 + * @category destructors + */ +export declare const toSet: (self: FiberId) => HashSet.HashSet; +/** + * Unsafely creates a new `FiberId`. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeMake: (_: void) => Runtime; +//# sourceMappingURL=FiberId.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberId.d.ts.map b/backend/node_modules/effect/dist/dts/FiberId.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..f5bc80ec7ff3f32bc53f1e24073a70fbdb373bb7 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberId.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"FiberId.d.ts","sourceRoot":"","sources":["../../src/FiberId.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberMap.d.ts b/backend/node_modules/effect/dist/dts/FiberMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..14bb40fe6fd1f13c67ee89962943407bbb584db2 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberMap.d.ts @@ -0,0 +1,368 @@ +/** + * @since 2.0.0 + */ +import type { NoSuchElementException } from "./Cause.js"; +import * as Deferred from "./Deferred.js"; +import * as Effect from "./Effect.js"; +import * as Fiber from "./Fiber.js"; +import * as FiberId from "./FiberId.js"; +import * as Inspectable from "./Inspectable.js"; +import * as Option from "./Option.js"; +import { type Pipeable } from "./Pipeable.js"; +import * as Runtime from "./Runtime.js"; +import type * as Scope from "./Scope.js"; +/** + * @since 2.0.0 + * @categories type ids + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @categories type ids + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @categories models + */ +export interface FiberMap extends Pipeable, Inspectable.Inspectable, Iterable<[K, Fiber.RuntimeFiber]> { + readonly [TypeId]: TypeId; + readonly deferred: Deferred.Deferred; +} +/** + * @since 2.0.0 + * @categories refinements + */ +export declare const isFiberMap: (u: unknown) => u is FiberMap; +/** + * A FiberMap can be used to store a collection of fibers, indexed by some key. + * When the associated Scope is closed, all fibers in the map will be interrupted. + * + * You can add fibers to the map using `FiberMap.set` or `FiberMap.run`, and the fibers will + * be automatically removed from the FiberMap when they complete. + * + * @example + * ```ts + * import { Effect, FiberMap } from "effect" + * + * Effect.gen(function*() { + * const map = yield* FiberMap.make() + * + * // run some effects and add the fibers to the map + * yield* FiberMap.run(map, "fiber a", Effect.never) + * yield* FiberMap.run(map, "fiber b", Effect.never) + * + * yield* Effect.sleep(1000) + * }).pipe( + * Effect.scoped // The fibers will be interrupted when the scope is closed + * ) + * ``` + * + * @since 2.0.0 + * @categories constructors + */ +export declare const make: () => Effect.Effect, never, Scope.Scope>; +/** + * Create an Effect run function that is backed by a FiberMap. + * + * @since 2.0.0 + * @categories constructors + */ +export declare const makeRuntime: () => Effect.Effect<((key: K, effect: Effect.Effect, options?: (Runtime.RunForkOptions & { + readonly onlyIfMissing?: boolean | undefined; +}) | undefined) => Fiber.RuntimeFiber), never, Scope.Scope | R>; +/** + * Create an Effect run function that is backed by a FiberMap. + * + * @since 3.13.0 + * @categories constructors + */ +export declare const makeRuntimePromise: () => Effect.Effect<((key: K, effect: Effect.Effect, options?: (Runtime.RunForkOptions & { + readonly onlyIfMissing?: boolean | undefined; +}) | undefined) => Promise), never, Scope.Scope | R>; +/** + * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. + * If the key already exists in the FiberMap, the previous fiber will be interrupted. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const unsafeSet: { + /** + * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. + * If the key already exists in the FiberMap, the previous fiber will be interrupted. + * + * @since 2.0.0 + * @categories combinators + */ + (key: K, fiber: Fiber.RuntimeFiber, options?: { + readonly interruptAs?: FiberId.FiberId | undefined; + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): (self: FiberMap) => void; + /** + * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. + * If the key already exists in the FiberMap, the previous fiber will be interrupted. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K, fiber: Fiber.RuntimeFiber, options?: { + readonly interruptAs?: FiberId.FiberId | undefined; + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): void; +}; +/** + * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. + * If the key already exists in the FiberMap, the previous fiber will be interrupted. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const set: { + /** + * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. + * If the key already exists in the FiberMap, the previous fiber will be interrupted. + * + * @since 2.0.0 + * @categories combinators + */ + (key: K, fiber: Fiber.RuntimeFiber, options?: { + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): (self: FiberMap) => Effect.Effect; + /** + * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. + * If the key already exists in the FiberMap, the previous fiber will be interrupted. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K, fiber: Fiber.RuntimeFiber, options?: { + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): Effect.Effect; +}; +/** + * Retrieve a fiber from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const unsafeGet: { + /** + * Retrieve a fiber from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (key: K): (self: FiberMap) => Option.Option>; + /** + * Retrieve a fiber from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K): Option.Option>; +}; +/** + * Retrieve a fiber from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const get: { + /** + * Retrieve a fiber from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (key: K): (self: FiberMap) => Effect.Effect, NoSuchElementException>; + /** + * Retrieve a fiber from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K): Effect.Effect, NoSuchElementException>; +}; +/** + * Check if a key exists in the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const unsafeHas: { + /** + * Check if a key exists in the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (key: K): (self: FiberMap) => boolean; + /** + * Check if a key exists in the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K): boolean; +}; +/** + * Check if a key exists in the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const has: { + /** + * Check if a key exists in the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (key: K): (self: FiberMap) => Effect.Effect; + /** + * Check if a key exists in the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K): Effect.Effect; +}; +/** + * Remove a fiber from the FiberMap, interrupting it if it exists. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const remove: { + /** + * Remove a fiber from the FiberMap, interrupting it if it exists. + * + * @since 2.0.0 + * @categories combinators + */ + (key: K): (self: FiberMap) => Effect.Effect; + /** + * Remove a fiber from the FiberMap, interrupting it if it exists. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K): Effect.Effect; +}; +/** + * @since 2.0.0 + * @categories combinators + */ +export declare const clear: (self: FiberMap) => Effect.Effect; +/** + * Run an Effect and add the forked fiber to the FiberMap. + * When the fiber completes, it will be removed from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const run: { + /** + * Run an Effect and add the forked fiber to the FiberMap. + * When the fiber completes, it will be removed from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K, options?: { + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): (effect: Effect.Effect) => Effect.Effect, never, R>; + /** + * Run an Effect and add the forked fiber to the FiberMap. + * When the fiber completes, it will be removed from the FiberMap. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberMap, key: K, effect: Effect.Effect, options?: { + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): Effect.Effect, never, R>; +}; +/** + * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap. + * + * @example + * ```ts + * import { Context, Effect, FiberMap } from "effect" + * + * interface Users { + * readonly _: unique symbol + * } + * const Users = Context.GenericTag> + * }>("Users") + * + * Effect.gen(function*() { + * const map = yield* FiberMap.make() + * const run = yield* FiberMap.runtime(map)() + * + * // run some effects and add the fibers to the map + * run("effect-a", Effect.andThen(Users, _ => _.getAll)) + * run("effect-b", Effect.andThen(Users, _ => _.getAll)) + * }).pipe( + * Effect.scoped // The fibers will be interrupted when the scope is closed + * ) + * ``` + * + * @since 2.0.0 + * @categories combinators + */ +export declare const runtime: (self: FiberMap) => () => Effect.Effect<((key: K, effect: Effect.Effect, options?: Runtime.RunForkOptions & { + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; +} | undefined) => Fiber.RuntimeFiber), never, R>; +/** + * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap. + * + * @since 3.13.0 + * @categories combinators + */ +export declare const runtimePromise: (self: FiberMap) => () => Effect.Effect<((key: K, effect: Effect.Effect, options?: (Runtime.RunForkOptions & { + readonly onlyIfMissing?: boolean | undefined; + readonly propagateInterruption?: boolean | undefined; +}) | undefined) => Promise), never, R>; +/** + * @since 2.0.0 + * @categories combinators + */ +export declare const size: (self: FiberMap) => Effect.Effect; +/** + * Join all fibers in the FiberMap. If any of the Fiber's in the map terminate with a failure, + * the returned Effect will terminate with the first failure that occurred. + * + * @since 2.0.0 + * @categories combinators + * @example + * ```ts + * import { Effect, FiberMap } from "effect"; + * + * Effect.gen(function* (_) { + * const map = yield* _(FiberMap.make()); + * yield* _(FiberMap.set(map, "a", Effect.runFork(Effect.fail("error")))); + * + * // parent fiber will fail with "error" + * yield* _(FiberMap.join(map)); + * }); + * ``` + */ +export declare const join: (self: FiberMap) => Effect.Effect; +/** + * Wait for the FiberMap to be empty. + * + * @since 3.13.0 + * @categories combinators + */ +export declare const awaitEmpty: (self: FiberMap) => Effect.Effect; +//# sourceMappingURL=FiberMap.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberMap.d.ts.map b/backend/node_modules/effect/dist/dts/FiberMap.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..389cbb80caa2f84686377973ede65a435c88e73d --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberMap.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"FiberMap.d.ts","sourceRoot":"","sources":["../../src/FiberMap.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberRef.d.ts b/backend/node_modules/effect/dist/dts/FiberRef.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5183f0003f6d585bc9e8df329427985bd1e2619f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberRef.d.ts @@ -0,0 +1,422 @@ +/** + * @since 2.0.0 + */ +import type * as Cause from "./Cause.js"; +import type * as Chunk from "./Chunk.js"; +import type * as Context from "./Context.js"; +import type * as Differ from "./Differ.js"; +import type * as Effect from "./Effect.js"; +import type { LazyArg } from "./Function.js"; +import type * as HashMap from "./HashMap.js"; +import type * as HashSet from "./HashSet.js"; +import type * as List from "./List.js"; +import type * as Logger from "./Logger.js"; +import type * as LogLevel from "./LogLevel.js"; +import type * as LogSpan from "./LogSpan.js"; +import type * as MetricLabel from "./MetricLabel.js"; +import type * as Option from "./Option.js"; +import type * as Request from "./Request.js"; +import type * as RuntimeFlags from "./RuntimeFlags.js"; +import * as Scheduler from "./Scheduler.js"; +import type * as Scope from "./Scope.js"; +import type * as Supervisor from "./Supervisor.js"; +import type * as Tracer from "./Tracer.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FiberRefTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FiberRefTypeId = typeof FiberRefTypeId; +/** + * @since 2.0.0 + * @category model + */ +export interface FiberRef extends Effect.Effect, Variance { + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: FiberRefUnify; + readonly [Unify.ignoreSymbol]?: FiberRefUnifyIgnore; +} +/** + * @category models + * @since 3.8.0 + */ +export interface FiberRefUnify extends Effect.EffectUnify { + FiberRef?: () => Extract>; +} +/** + * @category models + * @since 3.8.0 + */ +export interface FiberRefUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Variance { + readonly [FiberRefTypeId]: { + readonly _A: Types.Invariant; + }; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (initial: A, options?: { + readonly fork?: ((a: A) => A) | undefined; + readonly join?: ((left: A, right: A) => A) | undefined; +}) => Effect.Effect, never, Scope.Scope>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const makeWith: (ref: LazyArg>) => Effect.Effect, never, Scope.Scope>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const makeContext: (initial: Context.Context) => Effect.Effect>, never, Scope.Scope>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const makeRuntimeFlags: (initial: RuntimeFlags.RuntimeFlags) => Effect.Effect, never, Scope.Scope>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeMake: (initial: Value, options?: { + readonly fork?: ((a: Value) => Value) | undefined; + readonly join?: ((left: Value, right: Value) => Value) | undefined; +}) => FiberRef; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeMakeHashSet: (initial: HashSet.HashSet) => FiberRef>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeMakeContext: (initial: Context.Context) => FiberRef>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeMakeSupervisor: (initial: Supervisor.Supervisor) => FiberRef>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const unsafeMakePatch: (initial: Value, options: { + readonly differ: Differ.Differ; + readonly fork: Patch; + readonly join?: ((oldV: Value, newV: Value) => Value) | undefined; +}) => FiberRef; +/** + * @since 2.0.0 + * @category getters + */ +export declare const get: (self: FiberRef) => Effect.Effect; +/** + * @since 2.0.0 + * @category utils + */ +export declare const getAndSet: { + /** + * @since 2.0.0 + * @category utils + */ + (value: A): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, value: A): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const getAndUpdate: { + /** + * @since 2.0.0 + * @category utils + */ + (f: (a: A) => A): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, f: (a: A) => A): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const getAndUpdateSome: { + /** + * @since 2.0.0 + * @category utils + */ + (pf: (a: A) => Option.Option): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, pf: (a: A) => Option.Option): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const getWith: { + /** + * @since 2.0.0 + * @category utils + */ + (f: (a: A) => Effect.Effect): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, f: (a: A) => Effect.Effect): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const set: { + /** + * @since 2.0.0 + * @category utils + */ + (value: A): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, value: A): Effect.Effect; +}; +declare const _delete: (self: FiberRef) => Effect.Effect; +export { +/** + * @since 2.0.0 + * @category utils + */ +_delete as delete }; +/** + * @since 2.0.0 + * @category utils + */ +export declare const reset: (self: FiberRef) => Effect.Effect; +/** + * @since 2.0.0 + * @category utils + */ +export declare const modify: { + /** + * @since 2.0.0 + * @category utils + */ + (f: (a: A) => readonly [B, A]): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, f: (a: A) => readonly [B, A]): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const modifySome: (self: FiberRef, def: B, f: (a: A) => Option.Option) => Effect.Effect; +/** + * @since 2.0.0 + * @category utils + */ +export declare const update: { + /** + * @since 2.0.0 + * @category utils + */ + (f: (a: A) => A): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, f: (a: A) => A): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const updateSome: { + /** + * @since 2.0.0 + * @category utils + */ + (pf: (a: A) => Option.Option): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, pf: (a: A) => Option.Option): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const updateAndGet: { + /** + * @since 2.0.0 + * @category utils + */ + (f: (a: A) => A): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, f: (a: A) => A): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare const updateSomeAndGet: { + /** + * @since 2.0.0 + * @category utils + */ + (pf: (a: A) => Option.Option): (self: FiberRef) => Effect.Effect; + /** + * @since 2.0.0 + * @category utils + */ + (self: FiberRef, pf: (a: A) => Option.Option): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentConcurrency: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentRequestBatchingEnabled: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentRequestCache: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentRequestCacheEnabled: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentContext: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentSchedulingPriority: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentMaxOpsBeforeYield: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const unhandledErrorLogLevel: FiberRef>; +/** + * @since 3.17.0 + * @category fiberRefs + */ +export declare const versionMismatchErrorLogLevel: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentLogAnnotations: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentLoggers: FiberRef>>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentLogLevel: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentMinimumLogLevel: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentLogSpan: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentRuntimeFlags: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentScheduler: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentSupervisor: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentMetricLabels: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentTracerEnabled: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentTracerTimingEnabled: FiberRef; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentTracerSpanAnnotations: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const currentTracerSpanLinks: FiberRef>; +/** + * @since 2.0.0 + * @category fiberRefs + */ +export declare const interruptedCause: FiberRef>; +//# sourceMappingURL=FiberRef.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberRef.d.ts.map b/backend/node_modules/effect/dist/dts/FiberRef.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..fdb2f0b1196e1269b4ebb5051144c33fa40aa93f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberRef.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"FiberRef.d.ts","sourceRoot":"","sources":["../../src/FiberRef.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberRefs.d.ts b/backend/node_modules/effect/dist/dts/FiberRefs.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8a2fcc26bf76baa89081fd97072f2a8199758a90 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberRefs.d.ts @@ -0,0 +1,256 @@ +/** + * @since 2.0.0 + */ +import type * as Arr from "./Array.js"; +import type * as Effect from "./Effect.js"; +import type * as FiberId from "./FiberId.js"; +import type * as FiberRef from "./FiberRef.js"; +import type * as HashSet from "./HashSet.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FiberRefsSym: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FiberRefsSym = typeof FiberRefsSym; +/** + * `FiberRefs` is a data type that represents a collection of `FiberRef` values. + * + * This allows safely propagating `FiberRef` values across fiber boundaries, for + * example between an asynchronous producer and consumer. + * + * @since 2.0.0 + * @category models + */ +export interface FiberRefs extends Pipeable { + readonly [FiberRefsSym]: FiberRefsSym; + readonly locals: Map, Arr.NonEmptyReadonlyArray>; +} +declare const delete_: { + (fiberRef: FiberRef.FiberRef): (self: FiberRefs) => FiberRefs; + (self: FiberRefs, fiberRef: FiberRef.FiberRef): FiberRefs; +}; +export { +/** + * Deletes the specified `FiberRef` from the `FibterRefs`. + * + * @since 2.0.0 + * @category utils + */ +delete_ as delete }; +/** + * Returns a set of each `FiberRef` in this collection. + * + * @since 2.0.0 + * @category getters + */ +export declare const fiberRefs: (self: FiberRefs) => HashSet.HashSet>; +/** + * Forks this collection of fiber refs as the specified child fiber id. This + * will potentially modify the value of the fiber refs, as determined by the + * individual fiber refs that make up the collection. + * + * @since 2.0.0 + * @category utils + */ +export declare const forkAs: { + /** + * Forks this collection of fiber refs as the specified child fiber id. This + * will potentially modify the value of the fiber refs, as determined by the + * individual fiber refs that make up the collection. + * + * @since 2.0.0 + * @category utils + */ + (childId: FiberId.Single): (self: FiberRefs) => FiberRefs; + /** + * Forks this collection of fiber refs as the specified child fiber id. This + * will potentially modify the value of the fiber refs, as determined by the + * individual fiber refs that make up the collection. + * + * @since 2.0.0 + * @category utils + */ + (self: FiberRefs, childId: FiberId.Single): FiberRefs; +}; +/** + * Gets the value of the specified `FiberRef` in this collection of `FiberRef` + * values if it exists or `None` otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const get: { + /** + * Gets the value of the specified `FiberRef` in this collection of `FiberRef` + * values if it exists or `None` otherwise. + * + * @since 2.0.0 + * @category getters + */ + (fiberRef: FiberRef.FiberRef): (self: FiberRefs) => Option.Option; + /** + * Gets the value of the specified `FiberRef` in this collection of `FiberRef` + * values if it exists or `None` otherwise. + * + * @since 2.0.0 + * @category getters + */ + (self: FiberRefs, fiberRef: FiberRef.FiberRef): Option.Option; +}; +/** + * Gets the value of the specified `FiberRef` in this collection of `FiberRef` + * values if it exists or the `initial` value of the `FiberRef` otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const getOrDefault: { + /** + * Gets the value of the specified `FiberRef` in this collection of `FiberRef` + * values if it exists or the `initial` value of the `FiberRef` otherwise. + * + * @since 2.0.0 + * @category getters + */ + (fiberRef: FiberRef.FiberRef): (self: FiberRefs) => A; + /** + * Gets the value of the specified `FiberRef` in this collection of `FiberRef` + * values if it exists or the `initial` value of the `FiberRef` otherwise. + * + * @since 2.0.0 + * @category getters + */ + (self: FiberRefs, fiberRef: FiberRef.FiberRef): A; +}; +/** + * Joins this collection of fiber refs to the specified collection, as the + * specified fiber id. This will perform diffing and merging to ensure + * preservation of maximum information from both child and parent refs. + * + * @since 2.0.0 + * @category utils + */ +export declare const joinAs: { + /** + * Joins this collection of fiber refs to the specified collection, as the + * specified fiber id. This will perform diffing and merging to ensure + * preservation of maximum information from both child and parent refs. + * + * @since 2.0.0 + * @category utils + */ + (fiberId: FiberId.Single, that: FiberRefs): (self: FiberRefs) => FiberRefs; + /** + * Joins this collection of fiber refs to the specified collection, as the + * specified fiber id. This will perform diffing and merging to ensure + * preservation of maximum information from both child and parent refs. + * + * @since 2.0.0 + * @category utils + */ + (self: FiberRefs, fiberId: FiberId.Single, that: FiberRefs): FiberRefs; +}; +/** + * Set each ref to either its value or its default. + * + * @since 2.0.0 + * @category utils + */ +export declare const setAll: (self: FiberRefs) => Effect.Effect; +/** + * Updates the value of the specified `FiberRef` using the provided `FiberId` + * + * @since 2.0.0 + * @category utils + */ +export declare const updateAs: { + /** + * Updates the value of the specified `FiberRef` using the provided `FiberId` + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly fiberId: FiberId.Single; + readonly fiberRef: FiberRef.FiberRef; + readonly value: A; + }): (self: FiberRefs) => FiberRefs; + /** + * Updates the value of the specified `FiberRef` using the provided `FiberId` + * + * @since 2.0.0 + * @category utils + */ + (self: FiberRefs, options: { + readonly fiberId: FiberId.Single; + readonly fiberRef: FiberRef.FiberRef; + readonly value: A; + }): FiberRefs; +}; +/** + * Updates the values of the specified `FiberRef` & value pairs using the provided `FiberId` + * + * @since 2.0.0 + * @category utils + */ +export declare const updateManyAs: { + /** + * Updates the values of the specified `FiberRef` & value pairs using the provided `FiberId` + * + * @since 2.0.0 + * @category utils + */ + (options: { + readonly forkAs?: FiberId.Single | undefined; + readonly entries: readonly [ + readonly [ + FiberRef.FiberRef, + readonly [readonly [FiberId.Single, any], ...Array] + ], + ...Array, + readonly [readonly [FiberId.Single, any], ...Array] + ]> + ]; + }): (self: FiberRefs) => FiberRefs; + /** + * Updates the values of the specified `FiberRef` & value pairs using the provided `FiberId` + * + * @since 2.0.0 + * @category utils + */ + (self: FiberRefs, options: { + readonly forkAs?: FiberId.Single | undefined; + readonly entries: readonly [ + readonly [ + FiberRef.FiberRef, + readonly [readonly [FiberId.Single, any], ...Array] + ], + ...Array, + readonly [readonly [FiberId.Single, any], ...Array] + ]> + ]; + }): FiberRefs; +}; +/** + * Note: it will not copy the provided Map, make sure to provide a fresh one. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeMake: (fiberRefLocals: Map, Arr.NonEmptyReadonlyArray>) => FiberRefs; +/** + * The empty collection of `FiberRef` values. + * + * @category constructors + * @since 2.0.0 + */ +export declare const empty: () => FiberRefs; +//# sourceMappingURL=FiberRefs.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberRefsPatch.d.ts b/backend/node_modules/effect/dist/dts/FiberRefsPatch.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa425ef0e7a637006a241fe7c34d4f9a6b2f9d7f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberRefsPatch.d.ts @@ -0,0 +1,125 @@ +/** + * @since 2.0.0 + */ +import type * as FiberId from "./FiberId.js"; +import type * as FiberRef from "./FiberRef.js"; +import type * as FiberRefs from "./FiberRefs.js"; +/** + * A `FiberRefsPatch` captures the changes in `FiberRef` values made by a single + * fiber as a value. This allows fibers to apply the changes made by a workflow + * without inheriting all the `FiberRef` values of the fiber that executed the + * workflow. + * + * @since 2.0.0 + * @category models + */ +export type FiberRefsPatch = Empty | Add | Remove | Update | AndThen; +/** + * @since 2.0.0 + * @category models + */ +export interface Empty { + readonly _tag: "Empty"; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Add { + readonly _tag: "Add"; + readonly fiberRef: FiberRef.FiberRef; + readonly value: unknown; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Remove { + readonly _tag: "Remove"; + readonly fiberRef: FiberRef.FiberRef; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Update { + readonly _tag: "Update"; + readonly fiberRef: FiberRef.FiberRef; + readonly patch: unknown; +} +/** + * @since 2.0.0 + * @category models + */ +export interface AndThen { + readonly _tag: "AndThen"; + readonly first: FiberRefsPatch; + readonly second: FiberRefsPatch; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const empty: FiberRefsPatch; +/** + * Constructs a patch that describes the changes between the specified + * collections of `FiberRef` + * + * @since 2.0.0 + * @category constructors + */ +export declare const diff: (oldValue: FiberRefs.FiberRefs, newValue: FiberRefs.FiberRefs) => FiberRefsPatch; +/** + * Combines this patch and the specified patch to create a new patch that + * describes applying the changes from this patch and the specified patch + * sequentially. + * + * @since 2.0.0 + * @category constructors + */ +export declare const combine: { + /** + * Combines this patch and the specified patch to create a new patch that + * describes applying the changes from this patch and the specified patch + * sequentially. + * + * @since 2.0.0 + * @category constructors + */ + (that: FiberRefsPatch): (self: FiberRefsPatch) => FiberRefsPatch; + /** + * Combines this patch and the specified patch to create a new patch that + * describes applying the changes from this patch and the specified patch + * sequentially. + * + * @since 2.0.0 + * @category constructors + */ + (self: FiberRefsPatch, that: FiberRefsPatch): FiberRefsPatch; +}; +/** + * Applies the changes described by this patch to the specified collection + * of `FiberRef` values. + * + * @since 2.0.0 + * @category destructors + */ +export declare const patch: { + /** + * Applies the changes described by this patch to the specified collection + * of `FiberRef` values. + * + * @since 2.0.0 + * @category destructors + */ + (fiberId: FiberId.Runtime, oldValue: FiberRefs.FiberRefs): (self: FiberRefsPatch) => FiberRefs.FiberRefs; + /** + * Applies the changes described by this patch to the specified collection + * of `FiberRef` values. + * + * @since 2.0.0 + * @category destructors + */ + (self: FiberRefsPatch, fiberId: FiberId.Runtime, oldValue: FiberRefs.FiberRefs): FiberRefs.FiberRefs; +}; +//# sourceMappingURL=FiberRefsPatch.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberSet.d.ts b/backend/node_modules/effect/dist/dts/FiberSet.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dd92a34acd9232f8f463d0305729ebf8703a41a1 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberSet.d.ts @@ -0,0 +1,236 @@ +import * as Deferred from "./Deferred.js"; +import * as Effect from "./Effect.js"; +import * as Fiber from "./Fiber.js"; +import * as FiberId from "./FiberId.js"; +import * as Inspectable from "./Inspectable.js"; +import { type Pipeable } from "./Pipeable.js"; +import * as Runtime from "./Runtime.js"; +import type * as Scope from "./Scope.js"; +/** + * @since 2.0.0 + * @categories type ids + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @categories type ids + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @categories models + */ +export interface FiberSet extends Pipeable, Inspectable.Inspectable, Iterable> { + readonly [TypeId]: TypeId; + readonly deferred: Deferred.Deferred; +} +/** + * @since 2.0.0 + * @categories refinements + */ +export declare const isFiberSet: (u: unknown) => u is FiberSet; +/** + * A FiberSet can be used to store a collection of fibers. + * When the associated Scope is closed, all fibers in the set will be interrupted. + * + * You can add fibers to the set using `FiberSet.add` or `FiberSet.run`, and the fibers will + * be automatically removed from the FiberSet when they complete. + * + * @example + * ```ts + * import { Effect, FiberSet } from "effect" + * + * Effect.gen(function*() { + * const set = yield* FiberSet.make() + * + * // run some effects and add the fibers to the set + * yield* FiberSet.run(set, Effect.never) + * yield* FiberSet.run(set, Effect.never) + * + * yield* Effect.sleep(1000) + * }).pipe( + * Effect.scoped // The fibers will be interrupted when the scope is closed + * ) + * ``` + * + * @since 2.0.0 + * @categories constructors + */ +export declare const make: () => Effect.Effect, never, Scope.Scope>; +/** + * Create an Effect run function that is backed by a FiberSet. + * + * @since 2.0.0 + * @categories constructors + */ +export declare const makeRuntime: () => Effect.Effect<((effect: Effect.Effect, options?: Runtime.RunForkOptions | undefined) => Fiber.RuntimeFiber), never, Scope.Scope | R>; +/** + * Create an Effect run function that is backed by a FiberSet. + * + * @since 3.13.0 + * @categories constructors + */ +export declare const makeRuntimePromise: () => Effect.Effect<((effect: Effect.Effect, options?: Runtime.RunForkOptions | undefined) => Promise), never, Scope.Scope | R>; +/** + * Add a fiber to the FiberSet. When the fiber completes, it will be removed. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const unsafeAdd: { + /** + * Add a fiber to the FiberSet. When the fiber completes, it will be removed. + * + * @since 2.0.0 + * @categories combinators + */ + (fiber: Fiber.RuntimeFiber, options?: { + readonly interruptAs?: FiberId.FiberId | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): (self: FiberSet) => void; + /** + * Add a fiber to the FiberSet. When the fiber completes, it will be removed. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberSet, fiber: Fiber.RuntimeFiber, options?: { + readonly interruptAs?: FiberId.FiberId | undefined; + readonly propagateInterruption?: boolean | undefined; + } | undefined): void; +}; +/** + * Add a fiber to the FiberSet. When the fiber completes, it will be removed. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const add: { + /** + * Add a fiber to the FiberSet. When the fiber completes, it will be removed. + * + * @since 2.0.0 + * @categories combinators + */ + (fiber: Fiber.RuntimeFiber, options?: { + readonly propagateInterruption?: boolean | undefined; + } | undefined): (self: FiberSet) => Effect.Effect; + /** + * Add a fiber to the FiberSet. When the fiber completes, it will be removed. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberSet, fiber: Fiber.RuntimeFiber, options?: { + readonly propagateInterruption?: boolean | undefined; + } | undefined): Effect.Effect; +}; +/** + * @since 2.0.0 + * @categories combinators + */ +export declare const clear: (self: FiberSet) => Effect.Effect; +/** + * Fork an Effect and add the forked fiber to the FiberSet. + * When the fiber completes, it will be removed from the FiberSet. + * + * @since 2.0.0 + * @categories combinators + */ +export declare const run: { + /** + * Fork an Effect and add the forked fiber to the FiberSet. + * When the fiber completes, it will be removed from the FiberSet. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberSet, options?: { + readonly propagateInterruption?: boolean | undefined; + } | undefined): (effect: Effect.Effect) => Effect.Effect, never, R>; + /** + * Fork an Effect and add the forked fiber to the FiberSet. + * When the fiber completes, it will be removed from the FiberSet. + * + * @since 2.0.0 + * @categories combinators + */ + (self: FiberSet, effect: Effect.Effect, options?: { + readonly propagateInterruption?: boolean | undefined; + } | undefined): Effect.Effect, never, R>; +}; +/** + * 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 { + * readonly _: unique symbol + * } + * const Users = Context.GenericTag> + * }>("Users") + * + * Effect.gen(function*() { + * const set = yield* FiberSet.make() + * const run = yield* FiberSet.runtime(set)() + * + * // run some effects and add the fibers to the set + * run(Effect.andThen(Users, _ => _.getAll)) + * }).pipe( + * Effect.scoped // The fibers will be interrupted when the scope is closed + * ) + * ``` + * + * @since 2.0.0 + * @categories combinators + */ +export declare const runtime: (self: FiberSet) => () => Effect.Effect<((effect: Effect.Effect, options?: Runtime.RunForkOptions & { + readonly propagateInterruption?: boolean | undefined; +} | undefined) => Fiber.RuntimeFiber), never, R>; +/** + * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet. + * + * The returned run function will return Promise's. + * + * @since 3.13.0 + * @categories combinators + */ +export declare const runtimePromise: (self: FiberSet) => () => Effect.Effect<((effect: Effect.Effect, options?: (Runtime.RunForkOptions & { + readonly propagateInterruption?: boolean | undefined; +}) | undefined) => Promise), never, R>; +/** + * @since 2.0.0 + * @categories combinators + */ +export declare const size: (self: FiberSet) => Effect.Effect; +/** + * Join all fibers in the FiberSet. If any of the Fiber's in the set terminate with a failure, + * the returned Effect will terminate with the first failure that occurred. + * + * @since 2.0.0 + * @categories combinators + * @example + * ```ts + * import { Effect, FiberSet } from "effect"; + * + * Effect.gen(function* (_) { + * const set = yield* _(FiberSet.make()); + * yield* _(FiberSet.add(set, Effect.runFork(Effect.fail("error")))); + * + * // parent fiber will fail with "error" + * yield* _(FiberSet.join(set)); + * }); + * ``` + */ +export declare const join: (self: FiberSet) => Effect.Effect; +/** + * Wait until the fiber set is empty. + * + * @since 3.13.0 + * @categories combinators + */ +export declare const awaitEmpty: (self: FiberSet) => Effect.Effect; +//# sourceMappingURL=FiberSet.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberSet.d.ts.map b/backend/node_modules/effect/dist/dts/FiberSet.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..3564cc5a262031693951f15a7c5b43d605d459e6 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberSet.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"FiberSet.d.ts","sourceRoot":"","sources":["../../src/FiberSet.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAGvC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C,OAAO,EAAE,KAAK,QAAQ,EAAiB,MAAM,eAAe,CAAA;AAE5D,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,MAAsC,CAAA;AAElE;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAA;AAElC;;;GAGG;AACH,MAAM,WAAW,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,OAAO,CACxD,SAAQ,QAAQ,EAAE,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE7E,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;CAQpD;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAqC,CAAA;AAqC3G;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,OAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAa/F,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,OAAK,MAAM,CAAC,MAAM,EAC/E,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EACzB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAChC,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,GAAG,SAAS,KACzC,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,GAC/B,KAAK,EACL,KAAK,CAAC,KAAK,GAAG,CAAC,CAKd,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,OAAK,MAAM,CAAC,MAAM,EACtF,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EACzB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAChC,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,GAAG,SAAS,KACzC,OAAO,CAAC,EAAE,CAAC,GAChB,KAAK,EACL,KAAK,CAAC,KAAK,GAAG,CAAC,CAKd,CAAA;AAaH;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;OAKG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EAC/B,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,EACjC,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,OAAO,GAAG,SAAS,CAAA;QAClD,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACrD,GAAG,SAAS,GACZ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAA;IACjC;;;;;OAKG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EAC/B,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,EACjC,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,OAAO,GAAG,SAAS,CAAA;QAClD,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACrD,GAAG,SAAS,GACZ,IAAI,CAAA;CAgCP,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;;;OAKG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EAC/B,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,EACjC,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACrD,GAAG,SAAS,GACZ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAChD;;;;;OAKG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EAC/B,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,EACjC,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACrD,GAAG,SAAS,GACZ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAkBvB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAQjE,CAAA;AAYJ;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;;;;OAMG;IACH,CAAC,CAAC,EAAE,CAAC,EACH,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACrD,GAAG,SAAS,GACZ,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAA;IACxD;;;;;;OAMG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAChC,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KACrD,GAAG,SAAS,GACZ,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAA;CAQvD,CAAA;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EACzB,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KACjB,CAAC,CAAC,GAAG,KAAK,OAAO,MAAM,CAAC,MAAM,EACjC,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EACzB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAChC,OAAO,CAAC,EACJ,OAAO,CAAC,cAAc,GAAG;IAAE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,GACjF,SAAS,KACV,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,GAC/B,KAAK,EACL,CAAC,CAoBA,CAAA;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAAC,CAAC,GAAG,KAAK,OAAO,MAAM,CAAC,MAAM,EACxF,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,CAAC,EACzB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAChC,OAAO,CAAC,EACN,CAAE,OAAO,CAAC,cAAc,GAAG;IAAE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAE,IACjF,SAAS,KACV,OAAO,CAAC,EAAE,CAAC,GAChB,KAAK,EACL,CAAC,CAqBA,CAAA;AAEH;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CACS,CAAA;AAE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CACV,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAKtE,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberStatus.d.ts b/backend/node_modules/effect/dist/dts/FiberStatus.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..be9c5887aed9e5a4e8b8b377f4fec9b955b9a9aa --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberStatus.d.ts @@ -0,0 +1,94 @@ +/** + * @since 2.0.0 + */ +import type * as Equal from "./Equal.js"; +import type * as FiberId from "./FiberId.js"; +import type * as RuntimeFlags from "./RuntimeFlags.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FiberStatusTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FiberStatusTypeId = typeof FiberStatusTypeId; +/** + * @since 2.0.0 + * @category models + */ +export type FiberStatus = Done | Running | Suspended; +/** + * @since 2.0.0 + * @category models + */ +export interface Done extends Equal.Equal { + readonly _tag: "Done"; + readonly [FiberStatusTypeId]: FiberStatusTypeId; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Running extends Equal.Equal { + readonly _tag: "Running"; + readonly [FiberStatusTypeId]: FiberStatusTypeId; + readonly runtimeFlags: RuntimeFlags.RuntimeFlags; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Suspended extends Equal.Equal { + readonly _tag: "Suspended"; + readonly [FiberStatusTypeId]: FiberStatusTypeId; + readonly runtimeFlags: RuntimeFlags.RuntimeFlags; + readonly blockingOn: FiberId.FiberId; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const done: FiberStatus; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const running: (runtimeFlags: RuntimeFlags.RuntimeFlags) => FiberStatus; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const suspended: (runtimeFlags: RuntimeFlags.RuntimeFlags, blockingOn: FiberId.FiberId) => FiberStatus; +/** + * Returns `true` if the specified value is a `FiberStatus`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isFiberStatus: (u: unknown) => u is FiberStatus; +/** + * Returns `true` if the specified `FiberStatus` is `Done`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isDone: (self: FiberStatus) => self is Done; +/** + * Returns `true` if the specified `FiberStatus` is `Running`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isRunning: (self: FiberStatus) => self is Running; +/** + * Returns `true` if the specified `FiberStatus` is `Suspended`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isSuspended: (self: FiberStatus) => self is Suspended; +//# sourceMappingURL=FiberStatus.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/FiberStatus.d.ts.map b/backend/node_modules/effect/dist/dts/FiberStatus.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e6b24615efe7b7026e7212bc6ffa8f4beff0dac9 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/FiberStatus.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"FiberStatus.d.ts","sourceRoot":"","sources":["../../src/FiberStatus.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAE5C,OAAO,KAAK,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEtD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,OAAO,MAAmC,CAAA;AAE1E;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD;;;GAGG;AACH,MAAM,WAAW,IAAK,SAAQ,KAAK,CAAC,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;CAChD;AAED;;;GAGG;AACH,MAAM,WAAW,OAAQ,SAAQ,KAAK,CAAC,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IAC/C,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC,YAAY,CAAA;CACjD;AAED;;;GAGG;AACH,MAAM,WAAW,SAAU,SAAQ,KAAK,CAAC,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IAC/C,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC,YAAY,CAAA;IAChD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAA;CACrC;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,WAA2B,CAAA;AAE9C;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,YAAY,KAAK,WAA8B,CAAA;AAEjG;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,YAAY,EAAE,UAAU,EAAE,OAAO,CAAC,OAAO,KAAK,WAC9E,CAAA;AAEpB;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,WAAoC,CAAA;AAErF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,IAAI,IAAsB,CAAA;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,IAAI,OAA4B,CAAA;AAEnF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,IAAI,SAAgC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/GlobalValue.d.ts b/backend/node_modules/effect/dist/dts/GlobalValue.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..06e5ea34ce4ddcac028ab5cc1a56119f14fc6093 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/GlobalValue.d.ts @@ -0,0 +1,25 @@ +/** + * Retrieves or computes a global value associated with the given `id`. If the value for this `id` + * has already been computed, it will be returned from the global store. If it does not exist yet, + * the provided `compute` function will be executed to compute the value, store it, and then return it. + * + * This ensures that even in cases where the module is imported multiple times (e.g., in mixed environments + * like CommonJS and ESM, or during hot-reloading in development), the value is computed only once and reused + * thereafter. + * + * @example + * ```ts + * import { globalValue } from "effect/GlobalValue" + * + * // This cache will persist as long as the module is running, + * // even if reloaded or imported elsewhere + * const myCache = globalValue( + * Symbol.for("myCache"), + * () => new WeakMap() + * ) + * ``` + * + * @since 2.0.0 + */ +export declare const globalValue: (id: unknown, compute: () => A) => A; +//# sourceMappingURL=GlobalValue.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Graph.d.ts b/backend/node_modules/effect/dist/dts/Graph.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f177d217fe78b39485bc4ea886c238a9f8c13cf7 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Graph.d.ts @@ -0,0 +1,1753 @@ +/** + * @experimental + * @since 3.18.0 + */ +import * as Data from "./Data.js"; +import * as Equal from "./Equal.js"; +import type { Inspectable } from "./Inspectable.js"; +import * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +/** + * Unique identifier for Graph instances. + * + * @since 3.18.0 + * @category symbol + */ +export declare const TypeId: "~effect/Graph"; +/** + * Type identifier for Graph instances. + * + * @since 3.18.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * Node index for node identification using plain numbers. + * + * @since 3.18.0 + * @category models + */ +export type NodeIndex = number; +/** + * Edge index for edge identification using plain numbers. + * + * @since 3.18.0 + * @category models + */ +export type EdgeIndex = number; +/** + * Edge data containing source, target, and user data. + * + * @since 3.18.0 + * @category models + */ +export declare class Edge extends Data.Class<{ + readonly source: NodeIndex; + readonly target: NodeIndex; + readonly data: E; +}> { +} +/** + * Graph type for distinguishing directed and undirected graphs. + * + * @since 3.18.0 + * @category models + */ +export type Kind = "directed" | "undirected"; +/** + * Graph prototype interface. + * + * @since 3.18.0 + * @category models + */ +export interface Proto extends Iterable, Equal.Equal, Pipeable, Inspectable { + readonly [TypeId]: TypeId; + readonly nodes: Map; + readonly edges: Map>; + readonly adjacency: Map>; + readonly reverseAdjacency: Map>; + nextNodeIndex: NodeIndex; + nextEdgeIndex: EdgeIndex; + isAcyclic: Option.Option; +} +/** + * Immutable graph interface. + * + * @since 3.18.0 + * @category models + */ +export interface Graph extends Proto { + readonly type: T; + readonly mutable: false; +} +/** + * Mutable graph interface. + * + * @since 3.18.0 + * @category models + */ +export interface MutableGraph extends Proto { + readonly type: T; + readonly mutable: true; +} +/** + * Directed graph type alias. + * + * @since 3.18.0 + * @category models + */ +export type DirectedGraph = Graph; +/** + * Undirected graph type alias. + * + * @since 3.18.0 + * @category models + */ +export type UndirectedGraph = Graph; +/** + * Mutable directed graph type alias. + * + * @since 3.18.0 + * @category models + */ +export type MutableDirectedGraph = MutableGraph; +/** + * Mutable undirected graph type alias. + * + * @since 3.18.0 + * @category models + */ +export type MutableUndirectedGraph = MutableGraph; +declare const GraphError_base: new = {}>(args: import("./Types.js").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("./Cause.js").YieldableError & { + readonly _tag: "GraphError"; +} & Readonly; +/** + * Error thrown when a graph operation fails. + * + * @since 3.18.0 + * @category errors + */ +export declare class GraphError extends GraphError_base<{ + readonly message: string; +}> { +} +/** + * Creates a directed graph, optionally with initial mutations. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * // Directed graph with initial nodes and edges + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, "A->B") + * Graph.addEdge(mutable, b, c, "B->C") + * }) + * ``` + * + * @since 3.18.0 + * @category constructors + */ +export declare const directed: (mutate?: (mutable: MutableDirectedGraph) => void) => DirectedGraph; +/** + * Creates an undirected graph, optionally with initial mutations. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * // Undirected graph with initial nodes and edges + * const graph = Graph.undirected((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, "A-B") + * Graph.addEdge(mutable, b, c, "B-C") + * }) + * ``` + * + * @since 3.18.0 + * @category constructors + */ +export declare const undirected: (mutate?: (mutable: MutableUndirectedGraph) => void) => UndirectedGraph; +/** + * Creates a mutable scope for safe graph mutations by copying the data structure. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed() + * const mutable = Graph.beginMutation(graph) + * // Now mutable can be safely modified without affecting original graph + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const beginMutation: (graph: Graph) => MutableGraph; +/** + * Converts a mutable graph back to an immutable graph, ending the mutation scope. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed() + * const mutable = Graph.beginMutation(graph) + * // ... perform mutations on mutable ... + * const newGraph = Graph.endMutation(mutable) + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const endMutation: (mutable: MutableGraph) => Graph; +/** + * Performs scoped mutations on a graph, automatically managing the mutation lifecycle. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed() + * const newGraph = Graph.mutate(graph, (mutable) => { + * // Safe mutations go here + * // mutable gets automatically converted back to immutable + * }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const mutate: { + /** + * Performs scoped mutations on a graph, automatically managing the mutation lifecycle. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed() + * const newGraph = Graph.mutate(graph, (mutable) => { + * // Safe mutations go here + * // mutable gets automatically converted back to immutable + * }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ + (f: (mutable: MutableGraph) => void): (graph: Graph) => Graph; + /** + * Performs scoped mutations on a graph, automatically managing the mutation lifecycle. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed() + * const newGraph = Graph.mutate(graph, (mutable) => { + * // Safe mutations go here + * // mutable gets automatically converted back to immutable + * }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ + (graph: Graph, f: (mutable: MutableGraph) => void): Graph; +}; +/** + * Adds a new node to a mutable graph and returns its index. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const result = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * console.log(nodeA) // NodeIndex with value 0 + * console.log(nodeB) // NodeIndex with value 1 + * }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const addNode: (mutable: MutableGraph, data: N) => NodeIndex; +/** + * Gets the data associated with a node index, if it exists. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * Graph.addNode(mutable, "Node A") + * }) + * + * const nodeIndex = 0 + * const nodeData = Graph.getNode(graph, nodeIndex) + * + * if (Option.isSome(nodeData)) { + * console.log(nodeData.value) // "Node A" + * } + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const getNode: (graph: Graph | MutableGraph, nodeIndex: NodeIndex) => Option.Option; +/** + * Checks if a node with the given index exists in the graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * Graph.addNode(mutable, "Node A") + * }) + * + * const nodeIndex = 0 + * const exists = Graph.hasNode(graph, nodeIndex) + * console.log(exists) // true + * + * const nonExistentIndex = 999 + * const notExists = Graph.hasNode(graph, nonExistentIndex) + * console.log(notExists) // false + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const hasNode: (graph: Graph | MutableGraph, nodeIndex: NodeIndex) => boolean; +/** + * Returns the number of nodes in the graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const emptyGraph = Graph.directed() + * console.log(Graph.nodeCount(emptyGraph)) // 0 + * + * const graphWithNodes = Graph.mutate(emptyGraph, (mutable) => { + * Graph.addNode(mutable, "Node A") + * Graph.addNode(mutable, "Node B") + * Graph.addNode(mutable, "Node C") + * }) + * + * console.log(Graph.nodeCount(graphWithNodes)) // 3 + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const nodeCount: (graph: Graph | MutableGraph) => number; +/** + * Finds the first node that matches the given predicate. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * Graph.addNode(mutable, "Node A") + * Graph.addNode(mutable, "Node B") + * Graph.addNode(mutable, "Node C") + * }) + * + * const result = Graph.findNode(graph, (data) => data.startsWith("Node B")) + * console.log(result) // Option.some(1) + * + * const notFound = Graph.findNode(graph, (data) => data === "Node D") + * console.log(notFound) // Option.none() + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const findNode: (graph: Graph | MutableGraph, predicate: (data: N) => boolean) => Option.Option; +/** + * Finds all nodes that match the given predicate. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * Graph.addNode(mutable, "Start A") + * Graph.addNode(mutable, "Node B") + * Graph.addNode(mutable, "Start C") + * }) + * + * const result = Graph.findNodes(graph, (data) => data.startsWith("Start")) + * console.log(result) // [0, 2] + * + * const empty = Graph.findNodes(graph, (data) => data === "Not Found") + * console.log(empty) // [] + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const findNodes: (graph: Graph | MutableGraph, predicate: (data: N) => boolean) => Array; +/** + * Finds the first edge that matches the given predicate. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const nodeC = Graph.addNode(mutable, "Node C") + * Graph.addEdge(mutable, nodeA, nodeB, 10) + * Graph.addEdge(mutable, nodeB, nodeC, 20) + * }) + * + * const result = Graph.findEdge(graph, (data) => data > 15) + * console.log(result) // Option.some(1) + * + * const notFound = Graph.findEdge(graph, (data) => data > 100) + * console.log(notFound) // Option.none() + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const findEdge: (graph: Graph | MutableGraph, predicate: (data: E, source: NodeIndex, target: NodeIndex) => boolean) => Option.Option; +/** + * Finds all edges that match the given predicate. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const nodeC = Graph.addNode(mutable, "Node C") + * Graph.addEdge(mutable, nodeA, nodeB, 10) + * Graph.addEdge(mutable, nodeB, nodeC, 20) + * Graph.addEdge(mutable, nodeC, nodeA, 30) + * }) + * + * const result = Graph.findEdges(graph, (data) => data >= 20) + * console.log(result) // [1, 2] + * + * const empty = Graph.findEdges(graph, (data) => data > 100) + * console.log(empty) // [] + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const findEdges: (graph: Graph | MutableGraph, predicate: (data: E, source: NodeIndex, target: NodeIndex) => boolean) => Array; +/** + * Updates a single node's data by applying a transformation function. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * Graph.addNode(mutable, "Node A") + * Graph.addNode(mutable, "Node B") + * Graph.updateNode(mutable, 0, (data) => data.toUpperCase()) + * }) + * + * const nodeData = Graph.getNode(graph, 0) + * console.log(nodeData) // Option.some("NODE A") + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const updateNode: (mutable: MutableGraph, index: NodeIndex, f: (data: N) => N) => void; +/** + * Updates a single edge's data by applying a transformation function. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const result = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const edgeIndex = Graph.addEdge(mutable, nodeA, nodeB, 10) + * Graph.updateEdge(mutable, edgeIndex, (data) => data * 2) + * }) + * + * const edgeData = Graph.getEdge(result, 0) + * console.log(edgeData) // Option.some({ source: 0, target: 1, data: 20 }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const updateEdge: (mutable: MutableGraph, edgeIndex: EdgeIndex, f: (data: E) => E) => void; +/** + * Creates a new graph with transformed node data using the provided mapping function. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * Graph.addNode(mutable, "node a") + * Graph.addNode(mutable, "node b") + * Graph.addNode(mutable, "node c") + * Graph.mapNodes(mutable, (data) => data.toUpperCase()) + * }) + * + * const nodeData = Graph.getNode(graph, 0) + * console.log(nodeData) // Option.some("NODE A") + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const mapNodes: (mutable: MutableGraph, f: (data: N) => N) => void; +/** + * Transforms all edge data in a mutable graph using the provided mapping function. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 10) + * Graph.addEdge(mutable, b, c, 20) + * Graph.mapEdges(mutable, (data) => data * 2) + * }) + * + * const edgeData = Graph.getEdge(graph, 0) + * console.log(edgeData) // Option.some({ source: 0, target: 1, data: 20 }) + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const mapEdges: (mutable: MutableGraph, f: (data: E) => E) => void; +/** + * Reverses all edge directions in a mutable graph by swapping source and target nodes. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 1) // A -> B + * Graph.addEdge(mutable, b, c, 2) // B -> C + * Graph.reverse(mutable) // Now B -> A, C -> B + * }) + * + * const edge0 = Graph.getEdge(graph, 0) + * console.log(edge0) // Option.some({ source: 1, target: 0, data: 1 }) - B -> A + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const reverse: (mutable: MutableGraph) => void; +/** + * Filters and optionally transforms nodes in a mutable graph using a predicate function. + * Nodes that return Option.none are removed along with all their connected edges. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "active") + * const b = Graph.addNode(mutable, "inactive") + * const c = Graph.addNode(mutable, "active") + * Graph.addEdge(mutable, a, b, 1) + * Graph.addEdge(mutable, b, c, 2) + * + * // Keep only "active" nodes and transform to uppercase + * Graph.filterMapNodes(mutable, (data) => + * data === "active" ? Option.some(data.toUpperCase()) : Option.none() + * ) + * }) + * + * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain) + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const filterMapNodes: (mutable: MutableGraph, f: (data: N) => Option.Option) => void; +/** + * Filters and optionally transforms edges in a mutable graph using a predicate function. + * Edges that return Option.none are removed from the graph. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 5) + * Graph.addEdge(mutable, b, c, 15) + * Graph.addEdge(mutable, c, a, 25) + * + * // Keep only edges with weight >= 10 and double their weight + * Graph.filterMapEdges(mutable, (data) => + * data >= 10 ? Option.some(data * 2) : Option.none() + * ) + * }) + * + * console.log(Graph.edgeCount(graph)) // 2 (edges with weight 5 removed) + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const filterMapEdges: (mutable: MutableGraph, f: (data: E) => Option.Option) => void; +/** + * Filters nodes by removing those that don't match the predicate. + * This function modifies the mutable graph in place. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * Graph.addNode(mutable, "active") + * Graph.addNode(mutable, "inactive") + * Graph.addNode(mutable, "pending") + * Graph.addNode(mutable, "active") + * + * // Keep only "active" nodes + * Graph.filterNodes(mutable, (data) => data === "active") + * }) + * + * console.log(Graph.nodeCount(graph)) // 2 (only "active" nodes remain) + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const filterNodes: (mutable: MutableGraph, predicate: (data: N) => boolean) => void; +/** + * Filters edges by removing those that don't match the predicate. + * This function modifies the mutable graph in place. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * + * Graph.addEdge(mutable, a, b, 5) + * Graph.addEdge(mutable, b, c, 15) + * Graph.addEdge(mutable, c, a, 25) + * + * // Keep only edges with weight >= 10 + * Graph.filterEdges(mutable, (data) => data >= 10) + * }) + * + * console.log(Graph.edgeCount(graph)) // 2 (edge with weight 5 removed) + * ``` + * + * @since 3.18.0 + * @category transformations + */ +export declare const filterEdges: (mutable: MutableGraph, predicate: (data: E) => boolean) => void; +/** + * Adds a new edge to a mutable graph and returns its index. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const result = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const edge = Graph.addEdge(mutable, nodeA, nodeB, 42) + * console.log(edge) // EdgeIndex with value 0 + * }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const addEdge: (mutable: MutableGraph, source: NodeIndex, target: NodeIndex, data: E) => EdgeIndex; +/** + * Removes a node and all its incident edges from a mutable graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const result = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * Graph.addEdge(mutable, nodeA, nodeB, 42) + * + * // Remove nodeA and all edges connected to it + * Graph.removeNode(mutable, nodeA) + * }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const removeNode: (mutable: MutableGraph, nodeIndex: NodeIndex) => void; +/** + * Removes an edge from a mutable graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const result = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const edge = Graph.addEdge(mutable, nodeA, nodeB, 42) + * + * // Remove the edge + * Graph.removeEdge(mutable, edge) + * }) + * ``` + * + * @since 3.18.0 + * @category mutations + */ +export declare const removeEdge: (mutable: MutableGraph, edgeIndex: EdgeIndex) => void; +/** + * Gets the edge data associated with an edge index, if it exists. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * Graph.addEdge(mutable, nodeA, nodeB, 42) + * }) + * + * const edgeIndex = 0 + * const edgeData = Graph.getEdge(graph, edgeIndex) + * + * if (Option.isSome(edgeData)) { + * console.log(edgeData.value.data) // 42 + * console.log(edgeData.value.source) // NodeIndex(0) + * console.log(edgeData.value.target) // NodeIndex(1) + * } + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const getEdge: (graph: Graph | MutableGraph, edgeIndex: EdgeIndex) => Option.Option>; +/** + * Checks if an edge exists between two nodes in the graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const nodeC = Graph.addNode(mutable, "Node C") + * Graph.addEdge(mutable, nodeA, nodeB, 42) + * }) + * + * const nodeA = 0 + * const nodeB = 1 + * const nodeC = 2 + * + * const hasAB = Graph.hasEdge(graph, nodeA, nodeB) + * console.log(hasAB) // true + * + * const hasAC = Graph.hasEdge(graph, nodeA, nodeC) + * console.log(hasAC) // false + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const hasEdge: (graph: Graph | MutableGraph, source: NodeIndex, target: NodeIndex) => boolean; +/** + * Returns the number of edges in the graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const emptyGraph = Graph.directed() + * console.log(Graph.edgeCount(emptyGraph)) // 0 + * + * const graphWithEdges = Graph.mutate(emptyGraph, (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const nodeC = Graph.addNode(mutable, "Node C") + * Graph.addEdge(mutable, nodeA, nodeB, 1) + * Graph.addEdge(mutable, nodeB, nodeC, 2) + * Graph.addEdge(mutable, nodeC, nodeA, 3) + * }) + * + * console.log(Graph.edgeCount(graphWithEdges)) // 3 + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const edgeCount: (graph: Graph | MutableGraph) => number; +/** + * Returns the neighboring nodes (targets of outgoing edges) for a given node. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const nodeC = Graph.addNode(mutable, "Node C") + * Graph.addEdge(mutable, nodeA, nodeB, 1) + * Graph.addEdge(mutable, nodeA, nodeC, 2) + * }) + * + * const nodeA = 0 + * const nodeB = 1 + * const nodeC = 2 + * + * const neighborsA = Graph.neighbors(graph, nodeA) + * console.log(neighborsA) // [NodeIndex(1), NodeIndex(2)] + * + * const neighborsB = Graph.neighbors(graph, nodeB) + * console.log(neighborsB) // [] + * ``` + * + * @since 3.18.0 + * @category getters + */ +export declare const neighbors: (graph: Graph | MutableGraph, nodeIndex: NodeIndex) => Array; +/** + * Get neighbors of a node in a specific direction for bidirectional traversal. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, "A->B") + * }) + * + * const nodeA = 0 + * const nodeB = 1 + * + * // Get outgoing neighbors (nodes that nodeA points to) + * const outgoing = Graph.neighborsDirected(graph, nodeA, "outgoing") + * + * // Get incoming neighbors (nodes that point to nodeB) + * const incoming = Graph.neighborsDirected(graph, nodeB, "incoming") + * ``` + * + * @since 3.18.0 + * @category queries + */ +export declare const neighborsDirected: (graph: Graph | MutableGraph, nodeIndex: NodeIndex, direction: Direction) => Array; +/** + * Configuration options for GraphViz DOT format generation from graphs. + * + * @since 3.18.0 + * @category models + */ +export interface GraphVizOptions { + readonly nodeLabel?: (data: N) => string; + readonly edgeLabel?: (data: E) => string; + readonly graphName?: string; +} +/** + * Exports a graph to GraphViz DOT format for visualization. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * const nodeA = Graph.addNode(mutable, "Node A") + * const nodeB = Graph.addNode(mutable, "Node B") + * const nodeC = Graph.addNode(mutable, "Node C") + * Graph.addEdge(mutable, nodeA, nodeB, 1) + * Graph.addEdge(mutable, nodeB, nodeC, 2) + * Graph.addEdge(mutable, nodeC, nodeA, 3) + * }) + * + * const dot = Graph.toGraphViz(graph) + * console.log(dot) + * // digraph G { + * // "0" [label="Node A"]; + * // "1" [label="Node B"]; + * // "2" [label="Node C"]; + * // "0" -> "1" [label="1"]; + * // "1" -> "2" [label="2"]; + * // "2" -> "0" [label="3"]; + * // } + * ``` + * + * @since 3.18.0 + * @category utils + */ +export declare const toGraphViz: (graph: Graph | MutableGraph, options?: GraphVizOptions) => string; +/** + * Mermaid node shape types. + * + * @since 3.18.0 + * @category models + */ +export type MermaidNodeShape = "rectangle" | "rounded" | "circle" | "diamond" | "hexagon" | "stadium" | "subroutine" | "cylindrical"; +/** + * Mermaid diagram direction types. + * + * @since 3.18.0 + * @category models + */ +export type MermaidDirection = "TB" | "TD" | "BT" | "LR" | "RL"; +/** + * Mermaid diagram type. + * + * @since 3.18.0 + * @category models + */ +export type MermaidDiagramType = "flowchart" | "graph"; +/** + * Configuration options for Mermaid diagram generation. + * + * @since 3.18.0 + * @category models + */ +export interface MermaidOptions { + readonly nodeLabel?: (data: N) => string; + readonly edgeLabel?: (data: E) => string; + readonly diagramType?: MermaidDiagramType; + readonly direction?: MermaidDirection; + readonly nodeShape?: (data: N) => MermaidNodeShape; +} +/** + * Exports a graph to Mermaid diagram format for visualization. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.mutate(Graph.directed(), (mutable) => { + * const app = Graph.addNode(mutable, "App") + * const db = Graph.addNode(mutable, "Database") + * const cache = Graph.addNode(mutable, "Cache") + * Graph.addEdge(mutable, app, db, 1) + * Graph.addEdge(mutable, app, cache, 2) + * }) + * + * const mermaid = Graph.toMermaid(graph) + * console.log(mermaid) + * // flowchart TD + * // 0["App"] + * // 1["Database"] + * // 2["Cache"] + * // 0 -->|"1"| 1 + * // 0 -->|"2"| 2 + * ``` + * + * @since 3.18.0 + * @category utils + */ +export declare const toMermaid: (graph: Graph | MutableGraph, options?: MermaidOptions) => string; +/** + * Direction for graph traversal, indicating which edges to follow. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, "A->B") + * }) + * + * // Follow outgoing edges (normal direction) + * const outgoingNodes = Array.from(Graph.indices(Graph.dfs(graph, { start: [0], direction: "outgoing" }))) + * + * // Follow incoming edges (reverse direction) + * const incomingNodes = Array.from(Graph.indices(Graph.dfs(graph, { start: [1], direction: "incoming" }))) + * ``` + * + * @since 3.18.0 + * @category models + */ +export type Direction = "outgoing" | "incoming"; +/** + * Checks if the graph is acyclic (contains no cycles). + * + * Uses depth-first search to detect back edges, which indicate cycles. + * For directed graphs, any back edge creates a cycle. For undirected graphs, + * a back edge that doesn't go to the immediate parent creates a cycle. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * // Acyclic directed graph (DAG) + * const dag = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, "A->B") + * Graph.addEdge(mutable, b, c, "B->C") + * }) + * console.log(Graph.isAcyclic(dag)) // true + * + * // Cyclic directed graph + * const cyclic = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, "A->B") + * Graph.addEdge(mutable, b, a, "B->A") // Creates cycle + * }) + * console.log(Graph.isAcyclic(cyclic)) // false + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const isAcyclic: (graph: Graph | MutableGraph) => boolean; +/** + * Checks if an undirected graph is bipartite. + * + * A bipartite graph is one whose vertices can be divided into two disjoint sets + * such that no two vertices within the same set are adjacent. Uses BFS coloring + * to determine bipartiteness. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * // Bipartite graph (alternating coloring possible) + * const bipartite = Graph.undirected((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * const d = Graph.addNode(mutable, "D") + * Graph.addEdge(mutable, a, b, "edge") // Set 1: {A, C}, Set 2: {B, D} + * Graph.addEdge(mutable, b, c, "edge") + * Graph.addEdge(mutable, c, d, "edge") + * }) + * console.log(Graph.isBipartite(bipartite)) // true + * + * // Non-bipartite graph (odd cycle) + * const triangle = Graph.undirected((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, "edge") + * Graph.addEdge(mutable, b, c, "edge") + * Graph.addEdge(mutable, c, a, "edge") // Triangle (3-cycle) + * }) + * console.log(Graph.isBipartite(triangle)) // false + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const isBipartite: (graph: Graph | MutableGraph) => boolean; +/** + * Find connected components in an undirected graph. + * Each component is represented as an array of node indices. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.undirected((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * const d = Graph.addNode(mutable, "D") + * Graph.addEdge(mutable, a, b, "edge") // Component 1: A-B + * Graph.addEdge(mutable, c, d, "edge") // Component 2: C-D + * }) + * + * const components = Graph.connectedComponents(graph) + * console.log(components) // [[0, 1], [2, 3]] + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const connectedComponents: (graph: Graph | MutableGraph) => Array>; +/** + * Find strongly connected components in a directed graph using Kosaraju's algorithm. + * Each SCC is represented as an array of node indices. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, "A->B") + * Graph.addEdge(mutable, b, c, "B->C") + * Graph.addEdge(mutable, c, a, "C->A") // Creates SCC: A-B-C + * }) + * + * const sccs = Graph.stronglyConnectedComponents(graph) + * console.log(sccs) // [[0, 1, 2]] + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const stronglyConnectedComponents: (graph: Graph | MutableGraph) => Array>; +/** + * Result of a shortest path computation containing the path and total distance. + * + * @since 3.18.0 + * @category models + */ +export interface PathResult { + readonly path: Array; + readonly distance: number; + readonly costs: Array; +} +/** + * Configuration for Dijkstra's algorithm. + * + * @since 3.18.0 + * @category models + */ +export interface DijkstraConfig { + source: NodeIndex; + target: NodeIndex; + cost: (edgeData: E) => number; +} +/** + * Configuration for A* algorithm. + * + * @since 3.18.0 + * @category models + */ +export interface AstarConfig { + source: NodeIndex; + target: NodeIndex; + cost: (edgeData: E) => number; + heuristic: (sourceNodeData: N, targetNodeData: N) => number; +} +/** + * Configuration for Bellman-Ford algorithm. + * + * @since 3.18.0 + * @category models + */ +export interface BellmanFordConfig { + source: NodeIndex; + target: NodeIndex; + cost: (edgeData: E) => number; +} +/** + * Find the shortest path between two nodes using Dijkstra's algorithm. + * + * Dijkstra's algorithm works with non-negative edge weights and finds the shortest + * path from a source node to a target node in O((V + E) log V) time complexity. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 5) + * Graph.addEdge(mutable, a, c, 10) + * Graph.addEdge(mutable, b, c, 2) + * }) + * + * const result = Graph.dijkstra(graph, { source: 0, target: 2, cost: (edgeData) => edgeData }) + * if (Option.isSome(result)) { + * console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C + * console.log(result.value.distance) // 7 - total distance + * } + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const dijkstra: (graph: Graph | MutableGraph, config: DijkstraConfig) => Option.Option>; +/** + * Result of all-pairs shortest path computation. + * + * @since 3.18.0 + * @category models + */ +export interface AllPairsResult { + readonly distances: Map>; + readonly paths: Map | null>>; + readonly costs: Map>>; +} +/** + * Find shortest paths between all pairs of nodes using Floyd-Warshall algorithm. + * + * Floyd-Warshall algorithm computes shortest paths between all pairs of nodes in O(V³) time. + * It can handle negative edge weights and detect negative cycles. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 3) + * Graph.addEdge(mutable, b, c, 2) + * Graph.addEdge(mutable, a, c, 7) + * }) + * + * const result = Graph.floydWarshall(graph, (edgeData) => edgeData) + * const distanceAToC = result.distances.get(0)?.get(2) // 5 (A->B->C) + * const pathAToC = result.paths.get(0)?.get(2) // [0, 1, 2] + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const floydWarshall: (graph: Graph | MutableGraph, cost: (edgeData: E) => number) => AllPairsResult; +/** + * Find the shortest path between two nodes using A* pathfinding algorithm. + * + * A* is an extension of Dijkstra's algorithm that uses a heuristic function to guide + * the search towards the target, potentially finding paths faster than Dijkstra's. + * The heuristic must be admissible (never overestimate the actual cost). + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.directed<{x: number, y: number}, number>((mutable) => { + * const a = Graph.addNode(mutable, {x: 0, y: 0}) + * const b = Graph.addNode(mutable, {x: 1, y: 0}) + * const c = Graph.addNode(mutable, {x: 2, y: 0}) + * Graph.addEdge(mutable, a, b, 1) + * Graph.addEdge(mutable, b, c, 1) + * }) + * + * // Manhattan distance heuristic + * const heuristic = (nodeData: {x: number, y: number}, targetData: {x: number, y: number}) => + * Math.abs(nodeData.x - targetData.x) + Math.abs(nodeData.y - targetData.y) + * + * const result = Graph.astar(graph, { source: 0, target: 2, cost: (edgeData) => edgeData, heuristic }) + * if (Option.isSome(result)) { + * console.log(result.value.path) // [0, 1, 2] - shortest path + * console.log(result.value.distance) // 2 - total distance + * } + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const astar: (graph: Graph | MutableGraph, config: AstarConfig) => Option.Option>; +/** + * Find the shortest path between two nodes using Bellman-Ford algorithm. + * + * Bellman-Ford algorithm can handle negative edge weights and detects negative cycles. + * It has O(VE) time complexity, slower than Dijkstra's but more versatile. + * Returns Option.none() if a negative cycle is detected that affects the path. + * + * @example + * ```ts + * import { Graph, Option } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, -1) // Negative weight allowed + * Graph.addEdge(mutable, b, c, 3) + * Graph.addEdge(mutable, a, c, 5) + * }) + * + * const result = Graph.bellmanFord(graph, { source: 0, target: 2, cost: (edgeData) => edgeData }) + * if (Option.isSome(result)) { + * console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C + * console.log(result.value.distance) // 2 - total distance + * } + * ``` + * + * @since 3.18.0 + * @category algorithms + */ +export declare const bellmanFord: (graph: Graph | MutableGraph, config: BellmanFordConfig) => Option.Option>; +/** + * Concrete class for iterables that produce [NodeIndex, NodeData] tuples. + * + * This class provides a common abstraction for all iterables that return node data, + * including traversal iterators (DFS, BFS, etc.) and element iterators (nodes, externals). + * It uses a mapEntry function pattern for flexible iteration and transformation. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, 1) + * }) + * + * // Both traversal and element iterators return NodeWalker + * const dfsNodes: Graph.NodeWalker = Graph.dfs(graph, { start: [0] }) + * const allNodes: Graph.NodeWalker = Graph.nodes(graph) + * + * // Common interface for working with node iterables + * function processNodes(nodeIterable: Graph.NodeWalker): Array { + * return Array.from(Graph.indices(nodeIterable)) + * } + * + * // Access node data using values() or entries() + * const nodeData = Array.from(Graph.values(dfsNodes)) // ["A", "B"] + * const nodeEntries = Array.from(Graph.entries(allNodes)) // [[0, "A"], [1, "B"]] + * ``` + * + * @since 3.18.0 + * @category models + */ +export declare class Walker implements Iterable<[T, N]> { + /** + * @since 3.18.0 + */ + readonly [Symbol.iterator]: () => Iterator<[T, N]>; + /** + * Visits each element and maps it to a value using the provided function. + * + * Takes a function that receives the index and data, + * and returns an iterable of the mapped values. Skips elements that + * no longer exist in the graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, 1) + * }) + * + * const dfs = Graph.dfs(graph, { start: [0] }) + * + * // Map to just the node data + * const values = Array.from(dfs.visit((index, data) => data)) + * console.log(values) // ["A", "B"] + * + * // Map to custom objects + * const custom = Array.from(dfs.visit((index, data) => ({ id: index, name: data }))) + * console.log(custom) // [{ id: 0, name: "A" }, { id: 1, name: "B" }] + * ``` + * + * @since 3.18.0 + * @category iterators + */ + readonly visit: (f: (index: T, data: N) => U) => Iterable; + constructor( + /** + * Visits each element and maps it to a value using the provided function. + * + * Takes a function that receives the index and data, + * and returns an iterable of the mapped values. Skips elements that + * no longer exist in the graph. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, 1) + * }) + * + * const dfs = Graph.dfs(graph, { start: [0] }) + * + * // Map to just the node data + * const values = Array.from(dfs.visit((index, data) => data)) + * console.log(values) // ["A", "B"] + * + * // Map to custom objects + * const custom = Array.from(dfs.visit((index, data) => ({ id: index, name: data }))) + * console.log(custom) // [{ id: 0, name: "A" }, { id: 1, name: "B" }] + * ``` + * + * @since 3.18.0 + * @category iterators + */ + visit: (f: (index: T, data: N) => U) => Iterable); +} +/** + * Type alias for node iteration using Walker. + * NodeWalker is represented as Walker. + * + * @since 3.18.0 + * @category models + */ +export type NodeWalker = Walker; +/** + * Type alias for edge iteration using Walker. + * EdgeWalker is represented as Walker>. + * + * @since 3.18.0 + * @category models + */ +export type EdgeWalker = Walker>; +/** + * Returns an iterator over the indices in the walker. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, 1) + * }) + * + * const dfs = Graph.dfs(graph, { start: [0] }) + * const indices = Array.from(Graph.indices(dfs)) + * console.log(indices) // [0, 1] + * ``` + * + * @since 3.18.0 + * @category utilities + */ +export declare const indices: (walker: Walker) => Iterable; +/** + * Returns an iterator over the values (data) in the walker. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, 1) + * }) + * + * const dfs = Graph.dfs(graph, { start: [0] }) + * const values = Array.from(Graph.values(dfs)) + * console.log(values) // ["A", "B"] + * ``` + * + * @since 3.18.0 + * @category utilities + */ +export declare const values: (walker: Walker) => Iterable; +/** + * Returns an iterator over [index, data] entries in the walker. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, 1) + * }) + * + * const dfs = Graph.dfs(graph, { start: [0] }) + * const entries = Array.from(Graph.entries(dfs)) + * console.log(entries) // [[0, "A"], [1, "B"]] + * ``` + * + * @since 3.18.0 + * @category utilities + */ +export declare const entries: (walker: Walker) => Iterable<[T, N]>; +/** + * Configuration for graph search iterators. + * + * @since 3.18.0 + * @category models + */ +export interface SearchConfig { + readonly start?: Array; + readonly direction?: Direction; +} +/** + * Creates a new DFS iterator with optional configuration. + * + * The iterator maintains a stack of nodes to visit and tracks discovered nodes. + * It provides lazy evaluation of the depth-first search. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 1) + * Graph.addEdge(mutable, b, c, 1) + * }) + * + * // Start from a specific node + * const dfs1 = Graph.dfs(graph, { start: [0] }) + * for (const nodeIndex of Graph.indices(dfs1)) { + * console.log(nodeIndex) // Traverses in DFS order: 0, 1, 2 + * } + * + * // Empty iterator (no starting nodes) + * const dfs2 = Graph.dfs(graph) + * // Can be used programmatically + * ``` + * + * @since 3.18.0 + * @category iterators + */ +export declare const dfs: (graph: Graph | MutableGraph, config?: SearchConfig) => NodeWalker; +/** + * Creates a new BFS iterator with optional configuration. + * + * The iterator maintains a queue of nodes to visit and tracks discovered nodes. + * It provides lazy evaluation of the breadth-first search. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 1) + * Graph.addEdge(mutable, b, c, 1) + * }) + * + * // Start from a specific node + * const bfs1 = Graph.bfs(graph, { start: [0] }) + * for (const nodeIndex of Graph.indices(bfs1)) { + * console.log(nodeIndex) // Traverses in BFS order: 0, 1, 2 + * } + * + * // Empty iterator (no starting nodes) + * const bfs2 = Graph.bfs(graph) + * // Can be used programmatically + * ``` + * + * @since 3.18.0 + * @category iterators + */ +export declare const bfs: (graph: Graph | MutableGraph, config?: SearchConfig) => NodeWalker; +/** + * Configuration options for topological sort iterator. + * + * @since 3.18.0 + * @category models + */ +export interface TopoConfig { + readonly initials?: Array; +} +/** + * Creates a new topological sort iterator with optional configuration. + * + * The iterator uses Kahn's algorithm to lazily produce nodes in topological order. + * Throws an error if the graph contains cycles. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 1) + * Graph.addEdge(mutable, b, c, 1) + * }) + * + * // Standard topological sort + * const topo1 = Graph.topo(graph) + * for (const nodeIndex of Graph.indices(topo1)) { + * console.log(nodeIndex) // 0, 1, 2 (topological order) + * } + * + * // With initial nodes + * const topo2 = Graph.topo(graph, { initials: [0] }) + * + * // Throws error for cyclic graph + * const cyclicGraph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * Graph.addEdge(mutable, a, b, 1) + * Graph.addEdge(mutable, b, a, 2) // Creates cycle + * }) + * + * try { + * Graph.topo(cyclicGraph) // Throws: "Cannot perform topological sort on cyclic graph" + * } catch (error) { + * console.log((error as Error).message) + * } + * ``` + * + * @since 3.18.0 + * @category iterators + */ +export declare const topo: (graph: Graph | MutableGraph, config?: TopoConfig) => NodeWalker; +/** + * Creates a new DFS postorder iterator with optional configuration. + * + * The iterator maintains a stack with visit state tracking and emits nodes + * in postorder (after all descendants have been processed). Essential for + * dependency resolution and tree destruction algorithms. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const root = Graph.addNode(mutable, "root") + * const child1 = Graph.addNode(mutable, "child1") + * const child2 = Graph.addNode(mutable, "child2") + * Graph.addEdge(mutable, root, child1, 1) + * Graph.addEdge(mutable, root, child2, 1) + * }) + * + * // Postorder: children before parents + * const postOrder = Graph.dfsPostOrder(graph, { start: [0] }) + * for (const node of postOrder) { + * console.log(node) // 1, 2, 0 + * } + * ``` + * + * @since 3.18.0 + * @category iterators + */ +export declare const dfsPostOrder: (graph: Graph | MutableGraph, config?: SearchConfig) => NodeWalker; +/** + * Creates an iterator over all node indices in the graph. + * + * The iterator produces node indices in the order they were added to the graph. + * This provides access to all nodes regardless of connectivity. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 1) + * }) + * + * const indices = Array.from(Graph.indices(Graph.nodes(graph))) + * console.log(indices) // [0, 1, 2] + * ``` + * + * @since 3.18.0 + * @category iterators + */ +export declare const nodes: (graph: Graph | MutableGraph) => NodeWalker; +/** + * Creates an iterator over all edge indices in the graph. + * + * The iterator produces edge indices in the order they were added to the graph. + * This provides access to all edges regardless of connectivity. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const a = Graph.addNode(mutable, "A") + * const b = Graph.addNode(mutable, "B") + * const c = Graph.addNode(mutable, "C") + * Graph.addEdge(mutable, a, b, 1) + * Graph.addEdge(mutable, b, c, 2) + * }) + * + * const indices = Array.from(Graph.indices(Graph.edges(graph))) + * console.log(indices) // [0, 1] + * ``` + * + * @since 3.18.0 + * @category iterators + */ +export declare const edges: (graph: Graph | MutableGraph) => EdgeWalker; +/** + * Configuration for externals iterator. + * + * @since 3.18.0 + * @category models + */ +export interface ExternalsConfig { + readonly direction?: Direction; +} +/** + * Creates an iterator over external nodes (nodes without edges in specified direction). + * + * External nodes are nodes that have no outgoing edges (direction="outgoing") or + * no incoming edges (direction="incoming"). These are useful for finding + * sources, sinks, or isolated nodes. + * + * @example + * ```ts + * import { Graph } from "effect" + * + * const graph = Graph.directed((mutable) => { + * const source = Graph.addNode(mutable, "source") // 0 - no incoming + * const middle = Graph.addNode(mutable, "middle") // 1 - has both + * const sink = Graph.addNode(mutable, "sink") // 2 - no outgoing + * const isolated = Graph.addNode(mutable, "isolated") // 3 - no edges + * + * Graph.addEdge(mutable, source, middle, 1) + * Graph.addEdge(mutable, middle, sink, 2) + * }) + * + * // Nodes with no outgoing edges (sinks + isolated) + * const sinks = Array.from(Graph.indices(Graph.externals(graph, { direction: "outgoing" }))) + * console.log(sinks) // [2, 3] + * + * // Nodes with no incoming edges (sources + isolated) + * const sources = Array.from(Graph.indices(Graph.externals(graph, { direction: "incoming" }))) + * console.log(sources) // [0, 3] + * ``` + * + * @since 3.18.0 + * @category iterators + */ +export declare const externals: (graph: Graph | MutableGraph, config?: ExternalsConfig) => NodeWalker; +export {}; +//# sourceMappingURL=Graph.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/GroupBy.d.ts.map b/backend/node_modules/effect/dist/dts/GroupBy.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..10765671cf858d587eec8e124ed7f7827d317401 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/GroupBy.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"GroupBy.d.ts","sourceRoot":"","sources":["../../src/GroupBy.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/HKT.d.ts b/backend/node_modules/effect/dist/dts/HKT.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4dd1a988ab69c8c654d48fddac869e062f6e8981 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/HKT.d.ts @@ -0,0 +1,41 @@ +/** + * @since 2.0.0 + */ +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + */ +export declare const URI: unique symbol; +/** + * @since 2.0.0 + */ +export interface TypeClass { + readonly [URI]?: F; +} +/** + * @since 2.0.0 + */ +export interface TypeLambda { + readonly In: unknown; + readonly Out2: unknown; + readonly Out1: unknown; + readonly Target: unknown; +} +/** + * @since 2.0.0 + */ +export type Kind = F extends { + readonly type: unknown; +} ? (F & { + readonly In: In; + readonly Out2: Out2; + readonly Out1: Out1; + readonly Target: Target; +})["type"] : { + readonly F: F; + readonly In: Types.Contravariant; + readonly Out2: Types.Covariant; + readonly Out1: Types.Covariant; + readonly Target: Types.Invariant; +}; +//# sourceMappingURL=HKT.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/HKT.d.ts.map b/backend/node_modules/effect/dist/dts/HKT.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e678eb19cb6fa1ed3a6ed9f280b0c2ea3b2dc0af --- /dev/null +++ b/backend/node_modules/effect/dist/dts/HKT.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"HKT.d.ts","sourceRoot":"","sources":["../../src/HKT.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;GAEG;AACH,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,EAAE,OAAO,MAAM,CAAA;AAEvC;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,UAAU;IAC7C,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,UAAU,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC,SAAS;IACzE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB,GAAG,CAAC,CAAC,GAAG;IACL,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAA;IACf,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC,CAAC,MAAM,CAAC,GACR;IACA,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAA;IACb,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;IACpC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;CACzC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Hash.d.ts b/backend/node_modules/effect/dist/dts/Hash.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..58123910c59f702def2b5176f0f6ccdb3759f112 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Hash.d.ts @@ -0,0 +1,79 @@ +/** + * @since 2.0.0 + * @category symbols + */ +export declare const symbol: unique symbol; +/** + * @since 2.0.0 + * @category models + */ +export interface Hash { + [symbol](): number; +} +/** + * @since 2.0.0 + * @category hashing + */ +export declare const hash: (self: A) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const random: (self: A) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const combine: (b: number) => (self: number) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const optimize: (n: number) => number; +/** + * @since 2.0.0 + * @category guards + */ +export declare const isHash: (u: unknown) => u is Hash; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const number: (n: number) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const string: (str: string) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const structureKeys: (o: A, keys: ReadonlyArray) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const structure: (o: A) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const array: (arr: ReadonlyArray) => number; +/** + * @since 2.0.0 + * @category hashing + */ +export declare const cached: { + /** + * @since 2.0.0 + * @category hashing + */ + (self: object): (hash: number) => number; + /** + * @since 2.0.0 + * @category hashing + */ + (self: object, hash: number): number; +}; +//# sourceMappingURL=Hash.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Hash.d.ts.map b/backend/node_modules/effect/dist/dts/Hash.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..997b2ba6f9469519afe1b7a2d974e2b569cda4e4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Hash.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Hash.d.ts","sourceRoot":"","sources":["../../src/Hash.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,MAAkC,CAAA;AAE9D;;;GAGG;AACH,MAAM,WAAW,IAAI;IACnB,CAAC,MAAM,CAAC,IAAI,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,MAwClC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,MAKnD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,CAAC,IAAI,EAAE,MAAM,KAAK,MAAyC,CAAA;AAEhG;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,KAAG,MAAqD,CAAA;AAE1F;;;GAGG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,IAA8B,CAAA;AAEvE;;;GAGG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,MAAM,WAY/B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,MAAM,WAMjC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC,WAMjF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EAAE,GAAG,CAAC,WACuB,CAAA;AAEvE;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,KAAK,aAAa,CAAC,CAAC,CAAC,WAM7C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB;;;OAGG;IACH,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IACxC;;;OAGG;IACH,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAwBrC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/HashMap.d.ts b/backend/node_modules/effect/dist/dts/HashMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d47343c6854d506f4665ff39697336810d441ae3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/HashMap.d.ts @@ -0,0 +1,863 @@ +/** + * @since 2.0.0 + */ +import type { Equal } from "./Equal.js"; +import type { HashSet } from "./HashSet.js"; +import type { Inspectable } from "./Inspectable.js"; +import type { Option } from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { NoInfer } from "./Types.js"; +declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface HashMap extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable { + readonly [TypeId]: TypeId; +} +/** + * @since 2.0.0 + */ +export declare namespace HashMap { + /** + * @since 2.0.0 + * @category models + */ + type UpdateFn = (option: Option) => Option; + /** + * This type-level utility extracts the key type `K` from a `HashMap` type. + * + * @example + * ```ts + * import { HashMap } from "effect" + * + * declare const hm: HashMap.HashMap + * + * // $ExpectType string + * type K = HashMap.HashMap.Key + * + * ``` + * @since 2.0.0 + * @category type-level + */ + type Key> = [T] extends [HashMap] ? _K : never; + /** + * This type-level utility extracts the value type `V` from a `HashMap` type. + * + * @example + * ```ts + * import { HashMap } from "effect" + * + * declare const hm: HashMap.HashMap + * + * // $ExpectType number + * type V = HashMap.HashMap.Value + * + * ``` + * @since 2.0.0 + * @category type-level + */ + type Value> = [T] extends [HashMap] ? _V : never; + /** + * This type-level utility extracts the entry type `[K, V]` from a `HashMap` type. + * + * @example + * ```ts + * import { HashMap } from "effect" + * + * declare const hm: HashMap.HashMap + * + * // $ExpectType [string, number] + * type V = HashMap.HashMap.Entry + * + * ``` + * @since 3.9.0 + * @category type-level + */ + type Entry> = [Key, Value]; +} +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isHashMap: { + /** + * @since 2.0.0 + * @category refinements + */ + (u: Iterable): u is HashMap; + /** + * @since 2.0.0 + * @category refinements + */ + (u: unknown): u is HashMap; +}; +/** + * Creates a new `HashMap`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const empty: () => HashMap; +/** + * Constructs a new `HashMap` from an array of key/value pairs. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: >(...entries: Entries) => HashMap; +/** + * Creates a new `HashMap` from an iterable collection of key/value pairs. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromIterable: (entries: Iterable) => HashMap; +/** + * Checks if the `HashMap` contains any entries. + * + * @since 2.0.0 + * @category elements + */ +export declare const isEmpty: (self: HashMap) => boolean; +/** + * Safely lookup the value for the specified key in the `HashMap` using the + * internal hashing function. + * + * @since 2.0.0 + * @category elements + */ +export declare const get: { + /** + * Safely lookup the value for the specified key in the `HashMap` using the + * internal hashing function. + * + * @since 2.0.0 + * @category elements + */ + (key: K1): (self: HashMap) => Option; + /** + * Safely lookup the value for the specified key in the `HashMap` using the + * internal hashing function. + * + * @since 2.0.0 + * @category elements + */ + (self: HashMap, key: K1): Option; +}; +/** + * Lookup the value for the specified key in the `HashMap` using a custom hash. + * + * @since 2.0.0 + * @category elements + */ +export declare const getHash: { + /** + * Lookup the value for the specified key in the `HashMap` using a custom hash. + * + * @since 2.0.0 + * @category elements + */ + (key: K1, hash: number): (self: HashMap) => Option; + /** + * Lookup the value for the specified key in the `HashMap` using a custom hash. + * + * @since 2.0.0 + * @category elements + */ + (self: HashMap, key: K1, hash: number): Option; +}; +/** + * Unsafely lookup the value for the specified key in the `HashMap` using the + * internal hashing function. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeGet: { + /** + * Unsafely lookup the value for the specified key in the `HashMap` using the + * internal hashing function. + * + * @since 2.0.0 + * @category unsafe + */ + (key: K1): (self: HashMap) => V; + /** + * Unsafely lookup the value for the specified key in the `HashMap` using the + * internal hashing function. + * + * @since 2.0.0 + * @category unsafe + */ + (self: HashMap, key: K1): V; +}; +/** + * Checks if the specified key has an entry in the `HashMap`. + * + * @since 2.0.0 + * @category elements + */ +export declare const has: { + /** + * Checks if the specified key has an entry in the `HashMap`. + * + * @since 2.0.0 + * @category elements + */ + (key: K1): (self: HashMap) => boolean; + /** + * Checks if the specified key has an entry in the `HashMap`. + * + * @since 2.0.0 + * @category elements + */ + (self: HashMap, key: K1): boolean; +}; +/** + * Checks if the specified key has an entry in the `HashMap` using a custom + * hash. + * + * @since 2.0.0 + * @category elements + */ +export declare const hasHash: { + /** + * Checks if the specified key has an entry in the `HashMap` using a custom + * hash. + * + * @since 2.0.0 + * @category elements + */ + (key: K1, hash: number): (self: HashMap) => boolean; + /** + * Checks if the specified key has an entry in the `HashMap` using a custom + * hash. + * + * @since 2.0.0 + * @category elements + */ + (self: HashMap, key: K1, hash: number): boolean; +}; +/** + * Checks if an element matching the given predicate exists in the given `HashMap`. + * + * @example + * ```ts + * import { HashMap } from "effect" + * + * const hm = HashMap.make([1, 'a']) + * HashMap.hasBy(hm, (value, key) => value === 'a' && key === 1); // -> true + * HashMap.hasBy(hm, (value) => value === 'b'); // -> false + * + * ``` + * + * @since 3.16.0 + * @category elements + */ +export declare const hasBy: { + /** + * Checks if an element matching the given predicate exists in the given `HashMap`. + * + * @example + * ```ts + * import { HashMap } from "effect" + * + * const hm = HashMap.make([1, 'a']) + * HashMap.hasBy(hm, (value, key) => value === 'a' && key === 1); // -> true + * HashMap.hasBy(hm, (value) => value === 'b'); // -> false + * + * ``` + * + * @since 3.16.0 + * @category elements + */ + (predicate: (value: NoInfer, key: NoInfer) => boolean): (self: HashMap) => boolean; + /** + * Checks if an element matching the given predicate exists in the given `HashMap`. + * + * @example + * ```ts + * import { HashMap } from "effect" + * + * const hm = HashMap.make([1, 'a']) + * HashMap.hasBy(hm, (value, key) => value === 'a' && key === 1); // -> true + * HashMap.hasBy(hm, (value) => value === 'b'); // -> false + * + * ``` + * + * @since 3.16.0 + * @category elements + */ + (self: HashMap, predicate: (value: NoInfer, key: NoInfer) => boolean): boolean; +}; +/** + * Sets the specified key to the specified value using the internal hashing + * function. + * + * @since 2.0.0 + */ +export declare const set: { + /** + * Sets the specified key to the specified value using the internal hashing + * function. + * + * @since 2.0.0 + */ + (key: K, value: V): (self: HashMap) => HashMap; + /** + * Sets the specified key to the specified value using the internal hashing + * function. + * + * @since 2.0.0 + */ + (self: HashMap, key: K, value: V): HashMap; +}; +/** + * Returns an `IterableIterator` of the keys within the `HashMap`. + * + * @since 2.0.0 + * @category getters + */ +export declare const keys: (self: HashMap) => IterableIterator; +/** + * Returns a `HashSet` of keys within the `HashMap`. + * + * @since 2.0.0 + * @category getter + */ +export declare const keySet: (self: HashMap) => HashSet; +/** + * Returns an `IterableIterator` of the values within the `HashMap`. + * + * @since 2.0.0 + * @category getters + */ +export declare const values: (self: HashMap) => IterableIterator; +/** + * Returns an `Array` of the values within the `HashMap`. + * + * @since 3.13.0 + * @category getters + */ +export declare const toValues: (self: HashMap) => Array; +/** + * Returns an `IterableIterator` of the entries within the `HashMap`. + * + * @since 2.0.0 + * @category getters + */ +export declare const entries: (self: HashMap) => IterableIterator<[K, V]>; +/** + * Returns an `Array<[K, V]>` of the entries within the `HashMap`. + * + * @since 2.0.0 + * @category getters + */ +export declare const toEntries: (self: HashMap) => Array<[K, V]>; +/** + * Returns the number of entries within the `HashMap`. + * + * @since 2.0.0 + * @category getters + */ +export declare const size: (self: HashMap) => number; +/** + * Counts all the element of the given HashMap that pass the given predicate + * + * **Example** + * + * ```ts + * import { HashMap } from "effect" + * + * const map = HashMap.make([1, "a"], [2, "b"], [3, "c"]) + * const result = HashMap.countBy(map, (_v, key) => key % 2 === 1) + * console.log(result) // 2 + * ``` + * + * @since 3.17.0 + * @category folding + */ +export declare const countBy: { + /** + * Counts all the element of the given HashMap that pass the given predicate + * + * **Example** + * + * ```ts + * import { HashMap } from "effect" + * + * const map = HashMap.make([1, "a"], [2, "b"], [3, "c"]) + * const result = HashMap.countBy(map, (_v, key) => key % 2 === 1) + * console.log(result) // 2 + * ``` + * + * @since 3.17.0 + * @category folding + */ + (predicate: (value: NoInfer, key: NoInfer) => boolean): (self: HashMap) => number; + /** + * Counts all the element of the given HashMap that pass the given predicate + * + * **Example** + * + * ```ts + * import { HashMap } from "effect" + * + * const map = HashMap.make([1, "a"], [2, "b"], [3, "c"]) + * const result = HashMap.countBy(map, (_v, key) => key % 2 === 1) + * console.log(result) // 2 + * ``` + * + * @since 3.17.0 + * @category folding + */ + (self: HashMap, predicate: (value: NoInfer, key: NoInfer) => boolean): number; +}; +/** + * Marks the `HashMap` as mutable. + * + * @since 2.0.0 + */ +export declare const beginMutation: (self: HashMap) => HashMap; +/** + * Marks the `HashMap` as immutable. + * + * @since 2.0.0 + */ +export declare const endMutation: (self: HashMap) => HashMap; +/** + * Mutates the `HashMap` within the context of the provided function. + * + * @since 2.0.0 + */ +export declare const mutate: { + /** + * Mutates the `HashMap` within the context of the provided function. + * + * @since 2.0.0 + */ + (f: (self: HashMap) => void): (self: HashMap) => HashMap; + /** + * Mutates the `HashMap` within the context of the provided function. + * + * @since 2.0.0 + */ + (self: HashMap, f: (self: HashMap) => void): HashMap; +}; +/** + * Set or remove the specified key in the `HashMap` using the specified + * update function. The value of the specified key will be computed using the + * provided hash. + * + * The update function will be invoked with the current value of the key if it + * exists, or `None` if no such value exists. + * + * @since 2.0.0 + */ +export declare const modifyAt: { + /** + * Set or remove the specified key in the `HashMap` using the specified + * update function. The value of the specified key will be computed using the + * provided hash. + * + * The update function will be invoked with the current value of the key if it + * exists, or `None` if no such value exists. + * + * @since 2.0.0 + */ + (key: K, f: HashMap.UpdateFn): (self: HashMap) => HashMap; + /** + * Set or remove the specified key in the `HashMap` using the specified + * update function. The value of the specified key will be computed using the + * provided hash. + * + * The update function will be invoked with the current value of the key if it + * exists, or `None` if no such value exists. + * + * @since 2.0.0 + */ + (self: HashMap, key: K, f: HashMap.UpdateFn): HashMap; +}; +/** + * Alter the value of the specified key in the `HashMap` using the specified + * update function. The value of the specified key will be computed using the + * provided hash. + * + * The update function will be invoked with the current value of the key if it + * exists, or `None` if no such value exists. + * + * This function will always either update or insert a value into the `HashMap`. + * + * @since 2.0.0 + */ +export declare const modifyHash: { + /** + * Alter the value of the specified key in the `HashMap` using the specified + * update function. The value of the specified key will be computed using the + * provided hash. + * + * The update function will be invoked with the current value of the key if it + * exists, or `None` if no such value exists. + * + * This function will always either update or insert a value into the `HashMap`. + * + * @since 2.0.0 + */ + (key: K, hash: number, f: HashMap.UpdateFn): (self: HashMap) => HashMap; + /** + * Alter the value of the specified key in the `HashMap` using the specified + * update function. The value of the specified key will be computed using the + * provided hash. + * + * The update function will be invoked with the current value of the key if it + * exists, or `None` if no such value exists. + * + * This function will always either update or insert a value into the `HashMap`. + * + * @since 2.0.0 + */ + (self: HashMap, key: K, hash: number, f: HashMap.UpdateFn): HashMap; +}; +/** + * Updates the value of the specified key within the `HashMap` if it exists. + * + * @since 2.0.0 + */ +export declare const modify: { + /** + * Updates the value of the specified key within the `HashMap` if it exists. + * + * @since 2.0.0 + */ + (key: K, f: (v: V) => V): (self: HashMap) => HashMap; + /** + * Updates the value of the specified key within the `HashMap` if it exists. + * + * @since 2.0.0 + */ + (self: HashMap, key: K, f: (v: V) => V): HashMap; +}; +/** + * Performs a union of this `HashMap` and that `HashMap`. + * + * @since 2.0.0 + */ +export declare const union: { + /** + * Performs a union of this `HashMap` and that `HashMap`. + * + * @since 2.0.0 + */ + (that: HashMap): (self: HashMap) => HashMap; + /** + * Performs a union of this `HashMap` and that `HashMap`. + * + * @since 2.0.0 + */ + (self: HashMap, that: HashMap): HashMap; +}; +/** + * Remove the entry for the specified key in the `HashMap` using the internal + * hashing function. + * + * @since 2.0.0 + */ +export declare const remove: { + /** + * Remove the entry for the specified key in the `HashMap` using the internal + * hashing function. + * + * @since 2.0.0 + */ + (key: K): (self: HashMap) => HashMap; + /** + * Remove the entry for the specified key in the `HashMap` using the internal + * hashing function. + * + * @since 2.0.0 + */ + (self: HashMap, key: K): HashMap; +}; +/** + * Removes all entries in the `HashMap` which have the specified keys. + * + * @since 2.0.0 + */ +export declare const removeMany: { + /** + * Removes all entries in the `HashMap` which have the specified keys. + * + * @since 2.0.0 + */ + (keys: Iterable): (self: HashMap) => HashMap; + /** + * Removes all entries in the `HashMap` which have the specified keys. + * + * @since 2.0.0 + */ + (self: HashMap, keys: Iterable): HashMap; +}; +/** + * Maps over the entries of the `HashMap` using the specified function. + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Maps over the entries of the `HashMap` using the specified function. + * + * @since 2.0.0 + * @category mapping + */ + (f: (value: V, key: K) => A): (self: HashMap) => HashMap; + /** + * Maps over the entries of the `HashMap` using the specified function. + * + * @since 2.0.0 + * @category mapping + */ + (self: HashMap, f: (value: V, key: K) => A): HashMap; +}; +/** + * Chains over the entries of the `HashMap` using the specified function. + * + * **NOTE**: the hash and equal of both maps have to be the same. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatMap: { + /** + * Chains over the entries of the `HashMap` using the specified function. + * + * **NOTE**: the hash and equal of both maps have to be the same. + * + * @since 2.0.0 + * @category sequencing + */ + (f: (value: A, key: K) => HashMap): (self: HashMap) => HashMap; + /** + * Chains over the entries of the `HashMap` using the specified function. + * + * **NOTE**: the hash and equal of both maps have to be the same. + * + * @since 2.0.0 + * @category sequencing + */ + (self: HashMap, f: (value: A, key: K) => HashMap): HashMap; +}; +/** + * Applies the specified function to the entries of the `HashMap`. + * + * @since 2.0.0 + * @category traversing + */ +export declare const forEach: { + /** + * Applies the specified function to the entries of the `HashMap`. + * + * @since 2.0.0 + * @category traversing + */ + (f: (value: V, key: K) => void): (self: HashMap) => void; + /** + * Applies the specified function to the entries of the `HashMap`. + * + * @since 2.0.0 + * @category traversing + */ + (self: HashMap, f: (value: V, key: K) => void): void; +}; +/** + * Reduces the specified state over the entries of the `HashMap`. + * + * @since 2.0.0 + * @category folding + */ +export declare const reduce: { + /** + * Reduces the specified state over the entries of the `HashMap`. + * + * @since 2.0.0 + * @category folding + */ + (zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap) => Z; + /** + * Reduces the specified state over the entries of the `HashMap`. + * + * @since 2.0.0 + * @category folding + */ + (self: HashMap, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z; +}; +/** + * Filters entries out of a `HashMap` using the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filter: { + /** + * Filters entries out of a `HashMap` using the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ + (f: (a: NoInfer, k: K) => a is B): (self: HashMap) => HashMap; + /** + * Filters entries out of a `HashMap` using the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ + (f: (a: NoInfer, k: K) => boolean): (self: HashMap) => HashMap; + /** + * Filters entries out of a `HashMap` using the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ + (self: HashMap, f: (a: A, k: K) => a is B): HashMap; + /** + * Filters entries out of a `HashMap` using the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ + (self: HashMap, f: (a: A, k: K) => boolean): HashMap; +}; +/** + * Filters out `None` values from a `HashMap` of `Options`s. + * + * @since 2.0.0 + * @category filtering + */ +export declare const compact: (self: HashMap>) => HashMap; +/** + * Maps over the entries of the `HashMap` using the specified partial function + * and filters out `None` values. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterMap: { + /** + * Maps over the entries of the `HashMap` using the specified partial function + * and filters out `None` values. + * + * @since 2.0.0 + * @category filtering + */ + (f: (value: A, key: K) => Option): (self: HashMap) => HashMap; + /** + * Maps over the entries of the `HashMap` using the specified partial function + * and filters out `None` values. + * + * @since 2.0.0 + * @category filtering + */ + (self: HashMap, f: (value: A, key: K) => Option): HashMap; +}; +/** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirst: { + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, k: K) => a is B): (self: HashMap) => Option<[K, B]>; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, k: K) => boolean): (self: HashMap) => Option<[K, A]>; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: HashMap, predicate: (a: A, k: K) => a is B): Option<[K, B]>; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: HashMap, predicate: (a: A, k: K) => boolean): Option<[K, A]>; +}; +/** + * Checks if any entry in a hashmap meets a specific condition. + * + * @since 3.13.0 + * @category elements + */ +export declare const some: { + /** + * Checks if any entry in a hashmap meets a specific condition. + * + * @since 3.13.0 + * @category elements + */ + (predicate: (a: NoInfer, k: K) => boolean): (self: HashMap) => boolean; + /** + * Checks if any entry in a hashmap meets a specific condition. + * + * @since 3.13.0 + * @category elements + */ + (self: HashMap, predicate: (a: A, k: K) => boolean): boolean; +}; +/** + * Checks if all entries in a hashmap meets a specific condition. + * + * @param self - The hashmap to check. + * @param predicate - The condition to test entries (value, key). + * + * @since 3.14.0 + * @category elements + */ +export declare const every: { + /** + * Checks if all entries in a hashmap meets a specific condition. + * + * @param self - The hashmap to check. + * @param predicate - The condition to test entries (value, key). + * + * @since 3.14.0 + * @category elements + */ + (predicate: (a: NoInfer, k: K) => boolean): (self: HashMap) => boolean; + /** + * Checks if all entries in a hashmap meets a specific condition. + * + * @param self - The hashmap to check. + * @param predicate - The condition to test entries (value, key). + * + * @since 3.14.0 + * @category elements + */ + (self: HashMap, predicate: (a: A, k: K) => boolean): boolean; +}; +export {}; +//# sourceMappingURL=HashMap.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/HashRing.d.ts b/backend/node_modules/effect/dist/dts/HashRing.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c5aa8324543101e2c8581c9bcd8dec2ad980fe82 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/HashRing.d.ts @@ -0,0 +1,158 @@ +import { type Pipeable } from "./Pipeable.js"; +import * as PrimaryKey from "./PrimaryKey.js"; +declare const TypeId: "~effect/cluster/HashRing"; +/** + * @since 3.19.0 + * @category Models + * @experimental + */ +export interface HashRing extends Pipeable, Iterable { + readonly [TypeId]: typeof TypeId; + readonly baseWeight: number; + totalWeightCache: number; + readonly nodes: Map; + ring: Array<[hash: number, node: string]>; +} +/** + * @since 3.19.0 + * @category Guards + * @experimental + */ +export declare const isHashRing: (u: unknown) => u is HashRing; +/** + * @since 3.19.0 + * @category Constructors + * @experimental + */ +export declare const make: (options?: { + readonly baseWeight?: number | undefined; +}) => HashRing; +/** + * Add new nodes to the ring. If a node already exists in the ring, it + * will be updated. For example, you can use this to update the node's weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ +export declare const addMany: { + /** + * Add new nodes to the ring. If a node already exists in the ring, it + * will be updated. For example, you can use this to update the node's weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (nodes: Iterable, options?: { + readonly weight?: number | undefined; + }): (self: HashRing) => HashRing; + /** + * Add new nodes to the ring. If a node already exists in the ring, it + * will be updated. For example, you can use this to update the node's weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (self: HashRing, nodes: Iterable, options?: { + readonly weight?: number | undefined; + }): HashRing; +}; +/** + * Add a new node to the ring. If the node already exists in the ring, it + * will be updated. For example, you can use this to update the node's weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ +export declare const add: { + /** + * Add a new node to the ring. If the node already exists in the ring, it + * will be updated. For example, you can use this to update the node's weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (node: A, options?: { + readonly weight?: number | undefined; + }): (self: HashRing) => HashRing; + /** + * Add a new node to the ring. If the node already exists in the ring, it + * will be updated. For example, you can use this to update the node's weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (self: HashRing, node: A, options?: { + readonly weight?: number | undefined; + }): HashRing; +}; +/** + * Removes the node from the ring. No-op's if the node does not exist. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ +export declare const remove: { + /** + * Removes the node from the ring. No-op's if the node does not exist. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (node: A): (self: HashRing) => HashRing; + /** + * Removes the node from the ring. No-op's if the node does not exist. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (self: HashRing, node: A): HashRing; +}; +/** + * @since 3.19.0 + * @category Combinators + * @experimental + */ +export declare const has: { + /** + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (node: A): (self: HashRing) => boolean; + /** + * @since 3.19.0 + * @category Combinators + * @experimental + */ + (self: HashRing, node: A): boolean; +}; +/** + * Gets the node which should handle the given input. Returns undefined if + * the hashring has no elements with weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ +export declare const get: (self: HashRing, input: string) => A | undefined; +/** + * Distributes `count` shards across the nodes in the ring, attempting to + * balance the number of shards allocated to each node. Returns undefined if + * the hashring has no elements with weight. + * + * @since 3.19.0 + * @category Combinators + * @experimental + */ +export declare const getShards: (self: HashRing, count: number) => Array | undefined; +export {}; +//# sourceMappingURL=HashRing.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/HashRing.d.ts.map b/backend/node_modules/effect/dist/dts/HashRing.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e97f74f83213b64547e8cdf47a49e3d14f9a8983 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/HashRing.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"HashRing.d.ts","sourceRoot":"","sources":["../../src/HashRing.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/HashSet.d.ts b/backend/node_modules/effect/dist/dts/HashSet.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5e78a13c415ec140adb03a7476fe5752e23bfab3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/HashSet.d.ts @@ -0,0 +1,2271 @@ +/** + * # HashSet + * + * An immutable `HashSet` provides a collection of unique values with efficient + * lookup, insertion and removal. Once created, a `HashSet` cannot be modified; + * any operation that would alter the set instead returns a new `HashSet` with + * the changes. This immutability offers benefits like predictable state + * management and easier reasoning about your code. + * + * ## What Problem Does It Solve? + * + * `HashSet` solves the problem of maintaining an unsorted collection where each + * value appears exactly once, with fast operations for checking membership and + * adding/removing values. + * + * ## When to Use + * + * Use `HashSet` when you need: + * + * - A collection with no duplicate values + * - Efficient membership testing (**`O(1)`** average complexity) + * - Set operations like union, intersection, and difference + * - An immutable data structure that preserves functional programming patterns + * + * ## Advanced Features + * + * HashSet provides operations for: + * + * - Transforming sets with map and flatMap + * - Filtering elements with filter + * - Combining sets with union, intersection and difference + * - Performance optimizations via mutable operations in controlled contexts + * + * ## Performance Characteristics + * + * - **Lookup** operations ({@link module:HashSet.has}): **`O(1)`** average time + * complexity + * - **Insertion** operations ({@link module:HashSet.add}): **`O(1)`** average time + * complexity + * - **Removal** operations ({@link module:HashSet.remove}): **`O(1)`** average + * time complexity + * - **Set** operations ({@link module:HashSet.union}, + * {@link module:HashSet.intersection}): **`O(n)`** where n is the size of the + * smaller set + * - **Iteration**: **`O(n)`** where n is the size of the set + * + * The HashSet data structure implements the following traits: + * + * - {@link Iterable}: allows iterating over the values in the set + * - {@link Equal}: allows comparing two sets for value-based equality + * - {@link Pipeable}: allows chaining operations with the pipe operator + * - {@link Inspectable}: allows inspecting the contents of the set + * + * ## Operations Reference + * + * | Category | Operation | Description | Complexity | + * | ------------ | ----------------------------------- | ------------------------------------------- | ---------- | + * | constructors | {@link module:HashSet.empty} | Creates an empty HashSet | O(1) | + * | constructors | {@link module:HashSet.fromIterable} | Creates a HashSet from an iterable | O(n) | + * | constructors | {@link module:HashSet.make} | Creates a HashSet from multiple values | O(n) | + * | | | | | + * | elements | {@link module:HashSet.has} | Checks if a value exists in the set | O(1) avg | + * | elements | {@link module:HashSet.some} | Checks if any element satisfies a predicate | O(n) | + * | elements | {@link module:HashSet.every} | Checks if all elements satisfy a predicate | O(n) | + * | elements | {@link module:HashSet.isSubset} | Checks if a set is a subset of another | O(n) | + * | | | | | + * | getters | {@link module:HashSet.values} | Gets an iterator of all values | O(1) | + * | getters | {@link module:HashSet.toValues} | Gets an array of all values | O(n) | + * | getters | {@link module:HashSet.size} | Gets the number of elements | O(1) | + * | | | | | + * | mutations | {@link module:HashSet.add} | Adds a value to the set | O(1) avg | + * | mutations | {@link module:HashSet.remove} | Removes a value from the set | O(1) avg | + * | mutations | {@link module:HashSet.toggle} | Toggles a value's presence | O(1) avg | + * | | | | | + * | operations | {@link module:HashSet.difference} | Computes set difference (A - B) | O(n) | + * | operations | {@link module:HashSet.intersection} | Computes set intersection (A ∩ B) | O(n) | + * | operations | {@link module:HashSet.union} | Computes set union (A ∪ B) | O(n) | + * | | | | | + * | mapping | {@link module:HashSet.map} | Transforms each element | O(n) | + * | | | | | + * | sequencing | {@link module:HashSet.flatMap} | Transforms and flattens elements | O(n) | + * | | | | | + * | traversing | {@link module:HashSet.forEach} | Applies a function to each element | O(n) | + * | | | | | + * | folding | {@link module:HashSet.reduce} | Reduces the set to a single value | O(n) | + * | | | | | + * | filtering | {@link module:HashSet.filter} | Keeps elements that satisfy a predicate | O(n) | + * | | | | | + * | partitioning | {@link module:HashSet.partition} | Splits into two sets by a predicate | O(n) | + * + * ## Notes + * + * ### Composability with the Effect Ecosystem: + * + * This `HashSet` is designed to work seamlessly within the Effect ecosystem. It + * implements the {@link Iterable}, {@link Equal}, {@link Pipeable}, and + * {@link Inspectable} traits from Effect. This ensures compatibility with other + * Effect data structures and functionalities. For example, you can easily use + * Effect's `pipe` method to chain operations on the `HashSet`. + * + * **Equality of Elements with Effect's {@link Equal `Equal`} Trait:** + * + * This `HashSet` relies on Effect's {@link Equal} trait to determine the + * uniqueness of elements within the set. The way equality is checked depends on + * the type of the elements: + * + * - **Primitive Values:** For primitive JavaScript values like strings, numbers, + * booleans, `null`, and `undefined`, equality is determined by their value + * (similar to the `===` operator). + * - **Objects and Custom Types:** For objects and other custom types, equality is + * determined by whether those types implement the {@link Equal} interface + * themselves. If an element type implements `Equal`, the `HashSet` will + * delegate to that implementation to perform the equality check. This allows + * you to define custom logic for determining when two instances of your + * objects should be considered equal based on their properties, rather than + * just their object identity. + * + * ```ts + * import { Equal, Hash, HashSet } from "effect" + * + * class Person implements Equal.Equal { + * constructor( + * readonly id: number, // Unique identifier + * readonly name: string, + * readonly age: number + * ) {} + * + * // Define equality based on id, name, and age + * [Equal.symbol](that: Equal.Equal): boolean { + * if (that instanceof Person) { + * return ( + * Equal.equals(this.id, that.id) && + * Equal.equals(this.name, that.name) && + * Equal.equals(this.age, that.age) + * ) + * } + * return false + * } + * + * // Generate a hash code based on the unique id + * [Hash.symbol](): number { + * return Hash.hash(this.id) + * } + * } + * + * // Creating a HashSet with objects that implement the Equal interface + * const set = HashSet.empty().pipe( + * HashSet.add(new Person(1, "Alice", 30)), + * HashSet.add(new Person(1, "Alice", 30)) + * ) + * + * // HashSet recognizes them as equal, so only one element is stored + * console.log(HashSet.size(set)) + * // Output: 1 + * ``` + * + * **Simplifying Equality and Hashing with `Data` and `Schema`:** + * + * Effect's {@link Data} and {@link Schema `Schema.Data`} modules offer powerful + * ways to automatically handle the implementation of both the {@link Equal} and + * {@link Hash} traits for your custom data structures. + * + * - **`Data` Module:** By using constructors like `Data.struct`, `Data.tuple`, + * `Data.array`, or `Data.case` to define your data types, Effect + * automatically generates the necessary implementations for value-based + * equality and consistent hashing. This significantly reduces boilerplate and + * ensures correctness. + * + * ```ts + * import { HashSet, Data, Equal } from "effect" + * import assert from "node:assert/strict" + * + * // Data.* implements the `Equal` traits for us + * const person1 = Data.struct({ id: 1, name: "Alice", age: 30 }) + * const person2 = Data.struct({ id: 1, name: "Alice", age: 30 }) + * + * assert(Equal.equals(person1, person2)) + * + * const set = HashSet.empty().pipe( + * HashSet.add(person1), + * HashSet.add(person2) + * ) + * + * // HashSet recognizes them as equal, so only one element is stored + * console.log(HashSet.size(set)) // Output: 1 + * ``` + * + * - **`Schema` Module:** When defining data schemas using the {@link Schema} + * module, you can use `Schema.Data` to automatically include the `Equal` and + * `Hash` traits in the decoded objects. This is particularly important when + * working with `HashSet`. **For decoded objects to be correctly recognized as + * equal within a `HashSet`, ensure that the schema for those objects is + * defined using `Schema.Data`.** + * + * ```ts + * import { Equal, HashSet, Schema } from "effect" + * import assert from "node:assert/strict" + * + * // Schema.Data implements the `Equal` traits for us + * const PersonSchema = Schema.Data( + * Schema.Struct({ + * id: Schema.Number, + * name: Schema.String, + * age: Schema.Number + * }) + * ) + * + * const Person = Schema.decode(PersonSchema) + * + * const person1 = Person({ id: 1, name: "Alice", age: 30 }) + * const person2 = Person({ id: 1, name: "Alice", age: 30 }) + * + * assert(Equal.equals(person1, person2)) // Output: true + * + * const set = HashSet.empty().pipe( + * HashSet.add(person1), + * HashSet.add(person2) + * ) + * + * // HashSet thanks to Schema.Data implementation of the `Equal` trait, recognizes the two Person as equal, so only one element is stored + * console.log(HashSet.size(set)) // Output: 1 + * ``` + * + * ### Interoperability with the JavaScript Runtime: + * + * To interoperate with the regular JavaScript runtime, Effect's `HashSet` + * provides methods to access its elements in formats readily usable by + * JavaScript APIs: {@link values `HashSet.values`}, + * {@link toValues `HashSet.toValues`} + * + * ```ts + * import { HashSet } from "effect" + * + * const hashSet: HashSet.HashSet = HashSet.make(1, 2, 3) + * + * // Using HashSet.values to convert HashSet.HashSet to IterableIterator + * const iterable: IterableIterator = HashSet.values(hashSet) + * + * console.log(...iterable) // Logs: 1 2 3 + * + * // Using HashSet.toValues to convert HashSet.HashSet to Array + * const array: Array = HashSet.toValues(hashSet) + * + * console.log(array) // Logs: [ 1, 2, 3 ] + * ``` + * + * Be mindful of performance implications (both time and space complexity) when + * frequently converting between Effect's immutable HashSet and mutable + * JavaScript data structures, especially for large collections. + * + * @module HashSet + * @since 2.0.0 + */ +import type { Equal } from "./Equal.js"; +import type { Inspectable } from "./Inspectable.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import type { NoInfer } from "./Types.js"; +declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @memberof HashSet + * @since 2.0.0 + * @category models + * @example + * + * ```ts + * // Syntax + * import { HashSet } from "effect" + * + * let numberSet: HashSet.HashSet + * ``` + * + * @interface + */ +export interface HashSet extends Iterable, Equal, Pipeable, Inspectable { + readonly [TypeId]: TypeId; +} +/** + * @memberof HashSet + * @since 2.0.0 + * @category refinements + */ +export declare const isHashSet: { + /** + * Type guard function to determine if a given iterable is a `HashSet`. + * + * This overload preserves the type of the iterable's elements. + * + * @example + * + * ```ts + * import { HashSet } from "effect" + * + * const numberIterable: Iterable<1 | 2 | 3> = [1, 2, 3] + * + * if ( + * // if passed an Iterable the type guard that preserves the type parameter + * HashSet.isHashSet(numberIterable) + * ) { + * const HashSet: HashSet.HashSet<1 | 2 | 3> = numberIterable + * } + * ``` + * + * @param u - The iterable input to be checked. + * @returns A boolean indicating whether the provided iterable is a `HashSet`. + */ + (u: Iterable): u is HashSet; + /** + * Type guard function that checks if the provided value is a `HashSet` of + * unknown type. + * + * @example + * + * ```ts + * import { HashSet } from "effect" + * import assert from "node:assert/strict" + * + * // Check if a value is a HashSet + * const set = HashSet.make(1, 2, 3) + * + * assert.equal(HashSet.isHashSet(set), true) // true + * assert.equal(HashSet.isHashSet(HashSet.empty()), true) + * + * // Works with any type + * assert.equal(HashSet.isHashSet(null), false) // false + * assert.equal(HashSet.isHashSet({}), false) // false + * assert.equal(HashSet.isHashSet([1, 2, 3]), false) // false + * ``` + * + * @param u - The value to check. + * @returns A boolean indicating whether the value is a `HashSet`. + */ + (u: unknown): u is HashSet; +}; +/** + * Creates an empty `HashSet`. + * + * Time complexity: **`O(1)`** + * + * @memberof HashSet + * @since 2.0.0 + * @category constructors + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * + * console.log( + * pipe( + * // Provide a type argument to create a HashSet of a specific type + * HashSet.empty(), + * HashSet.add(1), + * HashSet.add(1), // Notice the duplicate + * HashSet.add(2), + * HashSet.toValues + * ) + * ) // Output: [1, 2] + * ``` + * + * @see Other `HashSet` constructors are {@link module:HashSet.make} {@link module:HashSet.fromIterable} + */ +export declare const empty: () => HashSet; +/** + * Creates a new `HashSet` from an iterable collection of values. + * + * Time complexity: **`O(n)`** where n is the number of elements in the iterable + * + * @memberof HashSet + * @since 2.0.0 + * @category constructors + * @example + * + * ```ts + * // Creating a HashSet from an Array + * import { HashSet, pipe } from "effect" + * + * console.log( + * pipe( + * [1, 2, 3, 4, 5, 1, 2, 3], // Array is an Iterable; Note the duplicates. + * HashSet.fromIterable, + * HashSet.toValues + * ) + * ) // Output: [1, 2, 3, 4, 5] + * ``` + * + * @example + * + * ```ts + * // Creating a HashSet from a Set + * import { HashSet, pipe } from "effect" + * + * console.log( + * pipe( + * new Set(["apple", "banana", "orange", "apple"]), // Set is an Iterable + * HashSet.fromIterable, + * HashSet.toValues + * ) + * ) // Output: ["apple", "banana", "orange"] + * ``` + * + * @example + * + * ```ts + * // Creating a HashSet from a Generator + * import { HashSet } from "effect" + * + * // Generator functions return iterables + * function* fibonacci(n: number): Generator { + * let [a, b] = [0, 1] + * for (let i = 0; i < n; i++) { + * yield a + * ;[a, b] = [b, a + b] + * } + * } + * + * // Create a HashSet from the first 10 Fibonacci numbers + * const fibonacciSet = HashSet.fromIterable(fibonacci(10)) + * + * console.log(HashSet.toValues(fibonacciSet)) + * // Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order + * ``` + * + * @example + * + * ```ts + * // Creating a HashSet from another HashSet + * import { HashSet, pipe } from "effect" + * + * console.log( + * pipe( + * // since HashSet implements the Iterable interface, we can use it to create a new HashSet + * HashSet.make(1, 2, 3, 4), + * HashSet.fromIterable, + * HashSet.toValues // turns the HashSet back into an array + * ) + * ) // Output: [1, 2, 3, 4] + * ``` + * + * @example + * + * ```ts + * // Creating a HashSet from other Effect's data structures like Chunk + * import { Chunk, HashSet, pipe } from "effect" + * + * console.log( + * pipe( + * Chunk.make(1, 2, 3, 4), // Iterable + * HashSet.fromIterable, + * HashSet.toValues // turns the HashSet back into an array + * ) + * ) // Outputs: [1, 2, 3, 4] + * ``` + * + * @see Other `HashSet` constructors are {@link module:HashSet.empty} {@link module:HashSet.make} + */ +export declare const fromIterable: (elements: Iterable) => HashSet; +/** + * Construct a new `HashSet` from a variable number of values. + * + * Time complexity: **`O(n)`** where n is the number of elements + * + * @memberof HashSet + * @since 2.0.0 + * @category constructors + * @example + * + * ```ts + * import { Equal, Hash, HashSet, pipe } from "effect" + * import assert from "node:assert/strict" + * + * class Character implements Equal.Equal { + * readonly name: string + * readonly trait: string + * + * constructor(name: string, trait: string) { + * this.name = name + * this.trait = trait + * } + * + * // Define equality based on name, and trait + * [Equal.symbol](that: Equal.Equal): boolean { + * if (that instanceof Character) { + * return ( + * Equal.equals(this.name, that.name) && + * Equal.equals(this.trait, that.trait) + * ) + * } + * return false + * } + * + * // Generate a hash code based on the sum of the character's name and trait + * [Hash.symbol](): number { + * return Hash.hash(this.name + this.trait) + * } + * + * static readonly of = (name: string, trait: string): Character => { + * return new Character(name, trait) + * } + * } + * + * assert.strictEqual( + * Equal.equals( + * HashSet.make( + * Character.of("Alice", "Curious"), + * Character.of("Alice", "Curious"), + * Character.of("White Rabbit", "Always late"), + * Character.of("Mad Hatter", "Tea enthusiast") + * ), + * // Is the same as adding each character to an empty set + * pipe( + * HashSet.empty(), + * HashSet.add(Character.of("Alice", "Curious")), + * HashSet.add(Character.of("Alice", "Curious")), // Alice tried to attend twice! + * HashSet.add(Character.of("White Rabbit", "Always late")), + * HashSet.add(Character.of("Mad Hatter", "Tea enthusiast")) + * ) + * ), + * true, + * "`HashSet.make` and `HashSet.empty() + HashSet.add()` should be equal" + * ) + * + * assert.strictEqual( + * Equal.equals( + * HashSet.make( + * Character.of("Alice", "Curious"), + * Character.of("Alice", "Curious"), + * Character.of("White Rabbit", "Always late"), + * Character.of("Mad Hatter", "Tea enthusiast") + * ), + * HashSet.fromIterable([ + * Character.of("Alice", "Curious"), + * Character.of("Alice", "Curious"), + * Character.of("White Rabbit", "Always late"), + * Character.of("Mad Hatter", "Tea enthusiast") + * ]) + * ), + * true, + * "`HashSet.make` and `HashSet.fromIterable` should be equal" + * ) + * ``` + * + * @see Other `HashSet` constructors are {@link module:HashSet.fromIterable} {@link module:HashSet.empty} + */ +export declare const make: >(...elements: As) => HashSet; +/** + * Checks if the specified value exists in the `HashSet`. + * + * Time complexity: **`O(1)`** average + * + * @memberof HashSet + * @since 2.0.0 + * @category elements + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe(HashSet.make(0, 1, 2), HashSet.has(3)) // false + * + * // or piped with the pipe function + * HashSet.make(0, 1, 2).pipe(HashSet.has(3)) // false + * + * // or with `data-first` API + * HashSet.has(HashSet.make(0, 1, 2), 3) // false + * ``` + * + * @returns A `boolean` signaling the presence of the value in the HashSet + * @see Other `HashSet` elements are {@link module:HashSet.some} {@link module:HashSet.every} {@link module:HashSet.isSubset} + */ +export declare const has: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import * as assert from "node:assert/strict" + * import { HashSet, pipe } from "effect" + * + * const set = HashSet.make(0, 1, 2) + * + * assert.equal(pipe(set, HashSet.has(0)), true) + * assert.equal(pipe(set, HashSet.has(1)), true) + * assert.equal(pipe(set, HashSet.has(2)), true) + * assert.equal(pipe(set, HashSet.has(3)), false) + * ``` + */ + (value: A): (self: HashSet) => boolean; + /** + * @example + * + * ```ts + * // `data-first` API + * import * as assert from "node:assert/strict" + * import { HashSet, pipe } from "effect" + * + * const set = HashSet.make(0, 1, 2) + * + * assert.equal(HashSet.has(set, 0), true) + * assert.equal(HashSet.has(set, 1), true) + * assert.equal(HashSet.has(set, 2), true) + * assert.equal(HashSet.has(set, 3), false) + * ``` + */ + (self: HashSet, value: A): boolean; +}; +/** + * Check if a predicate holds true for some `HashSet` element. + * + * Time complexity: **`O(n)`** where n is the number of elements in the set + * + * @memberof HashSet + * @since 2.0.0 + * @category elements + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * const set: HashSet.HashSet = HashSet.make(0, 1, 2) + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * set, + * HashSet.some((n) => n > 0) + * ) // true + * + * // or piped with the pipe function + * set.pipe(HashSet.some((n) => n > 0)) // true + * + * // or with `data-first` API + * HashSet.some(set, (n) => n > 0) // true + * ``` + * + * @see Other `HashSet` elements are {@link module:HashSet.has} {@link module:HashSet.every} {@link module:HashSet.isSubset} + */ +export declare const some: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import * as assert from "node:assert/strict" + * import { HashSet, pipe } from "effect" + * + * const set = HashSet.make(0, 1, 2) + * + * assert.equal( + * pipe( + * set, + * HashSet.some((n) => n > 0) + * ), + * true + * ) + * + * assert.equal( + * pipe( + * set, + * HashSet.some((n) => n > 2) + * ), + * false + * ) + * ``` + */ + (f: Predicate): (self: HashSet) => boolean; + /** + * @example + * + * ```ts + * // `data-first` API + * import * as assert from "node:assert/strict" + * import { HashSet } from "effect" + * + * const set = HashSet.make(0, 1, 2) + * + * assert.equal( + * HashSet.some(set, (n) => n > 0), + * true + * ) + * + * assert.equal( + * HashSet.some(set, (n) => n > 2), + * false + * ) + * ``` + */ + (self: HashSet, f: Predicate): boolean; +}; +/** + * Check if a predicate holds true for every `HashSet` element. + * + * Time complexity is **`O(n)`** as it needs to traverse the whole HashSet + * collection + * + * @memberof HashSet + * @since 2.0.0 + * @category elements + * @example + * + * ```ts + * // Syntax with Refinement + * import { HashSet, pipe, Predicate } from "effect" + * + * const numberOrString = HashSet.make(1, "1", "one", "uno") + * + * // with `data-last`, a.k.a. `pipeable` API and `Refinement` + * pipe( + * numberOrString, // HashSet.HashSet + * HashSet.every(Predicate.isString) + * ) // HashSet.HashSet + * + * // or piped with the pipe function and `Refinement` + * numberOrString // HashSet.HashSet + * .pipe(HashSet.every(Predicate.isString)) // HashSet.HashSet + * + * // or with `data-first` API and `Refinement` + * HashSet.every( + * numberOrString, // HashSet.HashSet + * Predicate.isString + * ) // HashSet.HashSet + * ``` + * + * @example + * + * ```ts + * // Syntax with Predicate + * import { HashSet, pipe } from "effect" + * + * const set = HashSet.make(1, 2, 3) + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * set, + * HashSet.every((n) => n >= 0) + * ) // true + * + * // or piped with the pipe function + * set.pipe(HashSet.every((n) => n >= 0)) // true + * + * // or with `data-first` API + * HashSet.every(set, (n) => n >= 0) // true + * ``` + * + * @returns A boolean once it has evaluated that whole collection fulfill the + * Predicate function + * @see Other `HashSet` elements are {@link module:HashSet.has} {@link module:HashSet.some} {@link module:HashSet.isSubset} + */ +export declare const every: { + /** + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Effect, HashSet, pipe, Predicate } from "effect" + * + * const numberOrString: HashSet.HashSet = HashSet.make( + * 1, + * "1", + * "one", + * "uno" + * ) + * + * assert.equal( + * pipe( + * numberOrString, // HashSet.HashSet + * HashSet.every(Predicate.isString) + * ), // HashSet.HashSet + * false + * ) + * ``` + */ + (refinement: Refinement, B>): (self: HashSet) => self is HashSet; + /** + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { HashSet, pipe } from "effect" + * + * const set = HashSet.make(0, 1, 2) + * + * assert.equal( + * pipe( + * set, + * HashSet.every((n) => n >= 0) + * ), + * true + * ) + * ``` + */ + (predicate: Predicate): (self: HashSet) => boolean; + /** + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Effect, HashSet, pipe, Predicate } from "effect" + * + * const numberOrString: HashSet.HashSet = HashSet.make( + * 1, + * "1", + * "one", + * "uno" + * ) + * + * assert.equal( + * HashSet.every( + * numberOrString, // HashSet.HashSet + * Predicate.isString + * ), // HashSet.HashSet + * false + * ) + * ``` + */ + (self: HashSet, refinement: Refinement): self is HashSet; + /** + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { HashSet } from "effect" + * + * const set = HashSet.make(0, 1, 2) + * + * assert.equal( + * HashSet.every(set, (n) => n >= 0), + * true + * ) + * ``` + */ + (self: HashSet, predicate: Predicate): boolean; +}; +/** + * Returns `true` if and only if every element in the this `HashSet` is an + * element of the second set, + * + * **NOTE**: the hash and equal of both sets must be the same. + * + * Time complexity analysis is of **`O(n)`** + * + * @memberof HashSet + * @since 2.0.0 + * @category elements + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * const set1 = HashSet.make(0, 1) + * const set2 = HashSet.make(1, 2) + * const set3 = HashSet.make(0, 1, 2) + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe(set1, HashSet.isSubset(set2)) // false + * pipe(set1, HashSet.isSubset(set3)) // true + * + * // or piped with the pipe function + * set1.pipe(HashSet.isSubset(set2)) // false + * set1.pipe(HashSet.isSubset(set3)) // true + * + * // or with `data-first` API + * HashSet.isSubset(set1, set2) // false + * HashSet.isSubset(set1, set3) // true) + * ``` + * + * @see Other `HashSet` elements are {@link module:HashSet.has} {@link module:HashSet.some} {@link module:HashSet.every} + */ +export declare const isSubset: { + /** + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.equal( + * pipe( + * HashSet.make(0, 1), // + * HashSet.isSubset(HashSet.make(1, 2)) + * ), + * false + * ) + * + * assert.equal( + * pipe( + * HashSet.make(0, 1), // + * HashSet.isSubset(HashSet.make(0, 1, 2)) + * ), + * true + * ) + * ``` + */ + (that: HashSet): (self: HashSet) => boolean; + /** + * @example + * + * ```ts + * import { HashSet } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.equal(HashSet.isSubset(set1, set2), false) + * + * assert.equal(HashSet.isSubset(set1, set3), true) + * ``` + */ + (self: HashSet, that: HashSet): boolean; +}; +/** + * Returns an `IterableIterator` of the values in the `HashSet`. + * + * Time complexity: **`O(1)`** + * + * @memberof HashSet + * @since 2.0.0 + * @category getters + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * + * const numberIterable = pipe( + * HashSet.make(0, 1, 1, 2), // HashSet.HashSet + * HashSet.values // takes an HashSet and returns an IterableIterator + * ) + * + * for (const number of numberIterable) { + * console.log(number) // it will logs: 0, 1, 2 + * } + * ``` + * + * @see Other `HashSet` getters are {@link module:HashSet.toValues} {@link module:HashSet.size} + */ +export declare const values: (self: HashSet) => IterableIterator; +/** + * Returns an `Array` of the values within the `HashSet`. + * + * Time complexity: **`O(n)`** where n is the number of elements in the set + * + * @memberof HashSet + * @since 3.13.0 + * @category getters + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import { deepStrictEqual } from "node:assert/strict" + * + * deepStrictEqual( + * pipe( + * HashSet.make(0, 1, 1, 2), // HashSet + * HashSet.toValues // takes an HashSet and returns an Array + * ), + * Array.of(0, 1, 2) + * ) + * ``` + * + * @see Other `HashSet` getters are {@link module:HashSet.values} {@link module:HashSet.size} + */ +export declare const toValues: (self: HashSet) => Array; +/** + * Calculates the number of values in the `HashSet`. + * + * Time complexity: **`O(1)`** + * + * @memberof HashSet + * @since 2.0.0 + * @category getters + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import assert from "node:assert/strict" + * + * assert.deepStrictEqual(pipe(HashSet.empty(), HashSet.size), 0) + * + * assert.deepStrictEqual( + * pipe(HashSet.make(1, 2, 2, 3, 4, 3), HashSet.size), + * 4 + * ) + * ``` + * + * @see Other `HashSet` getters are {@link module:HashSet.values} {@link module:HashSet.toValues} + */ +export declare const size: (self: HashSet) => number; +/** + * Creates a new mutable version of the `HashSet` + * + * When a `HashSet` is mutable, operations like {@link add} and {@link remove} + * modify the data structure in place instead of creating a new one, which is + * more efficient when performing multiple operations. + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * import { HashSet } from "effect" + * import assert from "node:assert/strict" + * + * const UPPER_BOUND = 10_000 + * + * const immutableSet = HashSet.empty().pipe(HashSet.add(0)) + * + * // Create a mutable version of the immutableSet + * const mutableSet = HashSet.beginMutation(immutableSet) + * + * for (let i = 1; i < UPPER_BOUND; i++) { + * // Operations now modify the set in place instead of creating new instances + * // This is more efficient when making multiple changes + * const pointerToMutableSet = HashSet.add(mutableSet, i) + * + * // the two sets have the same identity, hence `add` is mutating mutableSet and not returning a new HashSet instance + * assert(Object.is(mutableSet, pointerToMutableSet)) + * assert.equal(HashSet.has(mutableSet, i), true) // `i` is in the mutableSet + * assert.equal(HashSet.has(immutableSet, i), false) // `i` is not in the immutableSet + * } + * + * const next = UPPER_BOUND + 1 + * // When done, mark the set as immutable again + * HashSet.endMutation(mutableSet).pipe( + * HashSet.add(next) // since this returns a new HashSet, it will not be logged as part of the mutableSet + * ) + * assert.equal(HashSet.has(mutableSet, next), false) + * + * console.log(HashSet.toValues(immutableSet)) // [0] + * console.log(HashSet.toValues(mutableSet).sort((a, b) => a - b)) // [0, 1, 2, 3, ...rest] + * ``` + * + * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.endMutation} {@link module:HashSet.mutate} + */ +export declare const beginMutation: (self: HashSet) => HashSet; +/** + * Makes the `HashSet` immutable again. + * + * After calling `endMutation`, operations like {@link add} and {@link remove} + * will create new instances of the `HashSet` instead of modifying the existing + * one. + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * import { HashSet } from "effect" + * import assert from "node:assert/strict" + * + * // Create a mutable set + * const mutableSet = HashSet.beginMutation(HashSet.empty()) + * + * // Add some elements to the mutable set + * HashSet.add(mutableSet, 1) + * HashSet.add(mutableSet, 2) + * + * // Before endMutation, operations modify the set in place + * const sameSet = HashSet.add(mutableSet, 3) + * assert(Object.is(mutableSet, sameSet)) // true - same object reference + * assert.deepStrictEqual(HashSet.toValues(mutableSet).sort(), [1, 2, 3]) + * + * // Make the set immutable again + * const immutableSet = HashSet.endMutation(mutableSet) + * + * // endMutation returns the same set instance, now made immutable + * assert(Object.is(mutableSet, immutableSet)) // true - same object reference + * + * // After endMutation, operations create new instances + * const newSet = HashSet.add(immutableSet, 4) + * assert(!Object.is(immutableSet, newSet)) // false - different object references + * + * // The original set remains unchanged + * assert.deepStrictEqual(HashSet.toValues(immutableSet).sort(), [1, 2, 3]) + * + * // The new set contains the added element + * assert.deepStrictEqual(HashSet.toValues(newSet).sort(), [1, 2, 3, 4]) + * ``` + * + * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.mutate} + */ +export declare const endMutation: (self: HashSet) => HashSet; +/** + * Mutates the `HashSet` within the context of the provided function. + * + * You can consider it a functional abstraction on top of the lower-level + * mutation primitives of {@link module:HashSet.beginMutation} `->` `mutable + * context` `->` {@link HashSet.endMutation}. + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with data-last, a.k.a. pipeable API + * pipe( + * HashSet.make(1, 2, 3), + * HashSet.mutate((set) => { + * HashSet.add(set, 4) + * HashSet.remove(set, 1) + * }) + * ) + * + * // or piped with the pipe function + * HashSet.make(1, 2, 3).pipe( + * HashSet.mutate((set) => { + * HashSet.add(set, 4) + * HashSet.remove(set, 1) + * }) + * ) + * + * // or with data-first API + * HashSet.mutate(HashSet.make(1, 2, 3), (set) => { + * HashSet.add(set, 4) + * HashSet.remove(set, 1) + * }) + * ``` + * + * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} + */ +export declare const mutate: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import { HashSet, pipe } from "effect" + * import assert from "node:assert/strict" + * + * // Create a set with initial values + * const immutableSet = HashSet.make(1, 2, 3) + * + * // Use mutate to perform multiple operations efficiently + * const result = pipe( + * immutableSet, + * HashSet.mutate((set) => { + * assert.equal(Object.is(immutableSet, set), false) + * + * // The set is temporarily mutable inside this function + * const mod1 = HashSet.add(set, 4) + * const mod2 = HashSet.remove(set, 1) + * assert.equal(Object.is(mod1, mod2), true) // they are the same object by reference + * }) + * ) + * + * // The original set is unchanged + * assert.equal(Object.is(immutableSet, result), false) + * assert.deepStrictEqual( + * HashSet.toValues(immutableSet).sort(), + * [1, 2, 3] + * ) + * + * // The result contains the mutations + * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3, 4]) + * ``` + */ + (f: (set: HashSet) => void): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * // `data-first` API + * import { HashSet } from "effect" + * import assert from "node:assert/strict" + * + * // Create a set with initial values + * const immutableSet = HashSet.make(1, 2, 3) + * + * // Use mutate with data-first API + * const result = HashSet.mutate(immutableSet, (set) => { + * // The set is temporarily mutable inside this function + * HashSet.add(set, 4) + * HashSet.remove(set, 1) + * }) + * + * // The original set is unchanged + * assert.equal(Object.is(immutableSet, result), false) + * assert.deepStrictEqual( + * HashSet.toValues(immutableSet).sort(), + * [1, 2, 3] + * ) + * + * // The result contains the mutations + * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3, 4]) + * ``` + */ + (self: HashSet, f: (set: HashSet) => void): HashSet; +}; +/** + * Adds a value to the `HashSet`. + * + * Time complexity: **`O(1)`** average + * + * @remarks + * Remember that a `HashSet` is a collection of unique values, so adding a value + * that already exists in the `HashSet` will not add a duplicate. + * + * Remember that HashSet is an immutable data structure, so the `add` function, + * like all other functions that modify the HashSet, will return a new HashSet + * with the added value. + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with data-last, a.k.a. pipeable API + * pipe(HashSet.empty(), HashSet.add(0), HashSet.add(0)) + * + * // or piped with the pipe function + * HashSet.empty().pipe(HashSet.add(0)) + * + * // or with data-first API + * HashSet.add(HashSet.empty(), 0) + * ``` + * + * @see Other `HashSet` mutations are {@link module:HashSet.remove} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate} + */ +export declare const add: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import { HashSet, pipe } from "effect" + * import assert from "node:assert/strict" + * + * assert.deepStrictEqual( + * pipe( + * HashSet.empty(), // HashSet.HashSet + * HashSet.add(0), + * HashSet.add(1), + * HashSet.add(1), + * HashSet.add(2), + * HashSet.toValues + * ), + * Array.of(0, 1, 2) + * ) + * ``` + */ + (value: A): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * // `data-first` API + * import { HashSet, pipe } from "effect" + * import assert from "node:assert/strict" + * + * const empty = HashSet.empty() + * const withZero = HashSet.add(empty, 0) + * const withOne = HashSet.add(withZero, 1) + * const withTwo = HashSet.add(withOne, 2) + * const withTwoTwo = HashSet.add(withTwo, 2) + * + * assert.deepStrictEqual(HashSet.toValues(withTwoTwo), Array.of(0, 1, 2)) + * ``` + */ + (self: HashSet, value: A): HashSet; +}; +/** + * Removes a value from the `HashSet`. + * + * Time complexity: **`O(1)`** average + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe(HashSet.make(0, 1, 2), HashSet.remove(0)) + * + * // or piped with the pipe function + * HashSet.make(0, 1, 2).pipe(HashSet.remove(0)) + * + * // or with `data-first` API + * HashSet.remove(HashSet.make(0, 1, 2), 0) + * ``` + * + * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate} + */ +export declare const remove: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * const set = HashSet.make(0, 1, 2) + * const result = pipe(set, HashSet.remove(0)) + * + * assert.equal(pipe(result, HashSet.has(0)), false) // it has correctly removed 0 + * assert.equal(pipe(set, HashSet.has(0)), true) // it does not mutate the original set + * assert.equal(pipe(result, HashSet.has(1)), true) + * assert.equal(pipe(result, HashSet.has(2)), true) + * ``` + */ + (value: A): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * // `data-first` API + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * const set = HashSet.make(0, 1, 2) + * const result = HashSet.remove(set, 0) + * + * assert.equal(HashSet.has(result, 0), false) // it has correctly removed 0 + * assert.equal(HashSet.has(set, 0), true) // it does not mutate the original set + * assert.equal(HashSet.has(result, 1), true) + * assert.equal(HashSet.has(result, 2), true) + * ``` + */ + (self: HashSet, value: A): HashSet; +}; +/** + * Computes the set difference `(A - B)` between this `HashSet` and the + * specified `Iterable`. + * + * Time complexity: **`O(n)`** where n is the number of elements in the set + * + * **NOTE**: the hash and equal of the values in both the set and the iterable + * must be the same; meaning we cannot compute a difference between a `HashSet + * of bananas` and a `HashSet of elephants` as they are not the same type and + * won't implement the Equal trait in the same way. + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with data-last, a.k.a. pipeable API + * pipe(HashSet.make(1, 2, 3), HashSet.difference(HashSet.make(3, 4, 5))) + * + * // or piped with the pipe function + * HashSet.make(1, 2, 3).pipe(HashSet.difference(HashSet.make(3, 4, 5))) + * + * // or with data-first API + * HashSet.difference(HashSet.make(1, 2, 3), HashSet.make(3, 4, 5)) + * ``` + * + * @see Other `HashSet` operations are {@link module:HashSet.intersection} {@link module:HashSet.union} + */ +export declare const difference: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * // Create two sets with some overlapping elements + * const thisSet = HashSet.make(1, 2, 3) + * const thatIterable = HashSet.make(3, 4, 5) + * + * // Compute the difference (elements in thisSet that are not in thatIterable) + * const result = pipe(thisSet, HashSet.difference(thatIterable)) + * + * // The result contains only elements from thisSet that are not in thatIterable + * assert.deepStrictEqual(HashSet.toValues(result).sort(), [1, 2]) + * + * // The original sets are unchanged + * assert.deepStrictEqual(HashSet.toValues(thisSet).sort(), [1, 2, 3]) + * assert.deepStrictEqual( + * HashSet.toValues(thatIterable).sort(), + * [3, 4, 5] + * ) + * + * // You can also use arrays or other iterables + * const diffWithArray = pipe(thisSet, HashSet.difference([3, 4])) + * assert.deepStrictEqual(HashSet.toValues(diffWithArray).sort(), [1, 2]) + * ``` + */ + (that: Iterable): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * // `data-first` API + * import { HashSet } from "effect" + * import * as assert from "node:assert/strict" + * + * // Create two sets with some overlapping elements + * const thisSet = HashSet.make(1, 2, 3) + * const thatIterable = HashSet.make(3, 4, 5) + * + * // Compute the difference using data-first API + * const result = HashSet.difference(thisSet, thatIterable) + * + * // The result contains only elements from thisSet that are not in thatIterable + * assert.deepStrictEqual(HashSet.toValues(result).sort(), [1, 2]) + * + * // The original sets are unchanged + * assert.deepStrictEqual(HashSet.toValues(thisSet).sort(), [1, 2, 3]) + * assert.deepStrictEqual( + * HashSet.toValues(thatIterable).sort(), + * [3, 4, 5] + * ) + * + * // You can also compute the difference in the other direction + * const reverseResult = HashSet.difference(thatIterable, thisSet) + * assert.deepStrictEqual(HashSet.toValues(reverseResult).sort(), [4, 5]) + * ``` + */ + (self: HashSet, that: Iterable): HashSet; +}; +/** + * Returns a `HashSet` of values which are present in both this set and that + * `Iterable`. Computes set intersection (A ∩ B) + * + * Time complexity: **`O(n)`** where n is the number of elements in the smaller + * set + * + * **NOTE**: the hash and equal of the values in both the set and the iterable + * must be the same. + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with data-last, a.k.a. pipeable API + * pipe(HashSet.make(1, 2, 3), HashSet.intersection(HashSet.make(2, 3, 4))) + * + * // or piped with the pipe function + * HashSet.make(1, 2, 3).pipe(HashSet.intersection(HashSet.make(2, 3, 4))) + * + * // or with data-first API + * HashSet.intersection(HashSet.make(1, 2, 3), HashSet.make(2, 3, 4)) + * ``` + * + * @see Other `HashSet` operations are {@link module:HashSet.difference} {@link module:HashSet.union} + */ +export declare const intersection: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * // Create two sets with some overlapping elements + * const set1 = HashSet.make(1, 2, 3) + * const set2 = HashSet.make(2, 3, 4) + * + * // Compute the intersection (elements that are in both sets) + * const result = pipe(set1, HashSet.intersection(set2)) + * + * // The result contains only elements that are in both sets + * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3]) + * + * // The original sets are unchanged + * assert.deepStrictEqual(HashSet.toValues(set1).sort(), [1, 2, 3]) + * assert.deepStrictEqual(HashSet.toValues(set2).sort(), [2, 3, 4]) + * + * // You can also use arrays or other iterables + * const intersectWithArray = pipe(set1, HashSet.intersection([2, 3, 5])) + * assert.deepStrictEqual( + * HashSet.toValues(intersectWithArray).sort(), + * [2, 3] + * ) + * ``` + */ + (that: Iterable): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * // `data-first` API + * import { HashSet } from "effect" + * import * as assert from "node:assert/strict" + * + * // Create two sets with some overlapping elements + * const set1 = HashSet.make(1, 2, 3) + * const set2 = HashSet.make(2, 3, 4) + * + * // Compute the intersection using data-first API + * const result = HashSet.intersection(set1, set2) + * + * // The result contains only elements that are in both sets + * assert.deepStrictEqual(HashSet.toValues(result).sort(), [2, 3]) + * + * // The original sets are unchanged + * assert.deepStrictEqual(HashSet.toValues(set1).sort(), [1, 2, 3]) + * assert.deepStrictEqual(HashSet.toValues(set2).sort(), [2, 3, 4]) + * + * // You can also use arrays or other iterables + * const intersectWithArray = HashSet.intersection(set1, [2, 3, 5]) + * assert.deepStrictEqual( + * HashSet.toValues(intersectWithArray).sort(), + * [2, 3] + * ) + * ``` + */ + (self: HashSet, that: Iterable): HashSet; +}; +/** + * Computes the set union `( self ∪ that )` between this `HashSet` and the + * specified `Iterable`. + * + * Time complexity: **`O(n)`** where n is the number of elements in the set + * + * **NOTE**: the hash and equal of the values in both the set and the iterable + * must be the same. + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with data-last, a.k.a. pipeable API + * pipe(HashSet.make(1, 2, 3), HashSet.union(HashSet.make(3, 4, 5))) + * + * // or piped with the pipe function + * HashSet.make(1, 2, 3).pipe(HashSet.union(HashSet.make(3, 4, 5))) + * + * // or with data-first API + * HashSet.union(HashSet.make(1, 2, 3), HashSet.make(3, 4, 5)) + * ``` + * + * @see Other `HashSet` operations are {@link module:HashSet.difference} {@link module:HashSet.intersection} + */ +export declare const union: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * // Create two sets with some overlapping elements + * const selfSet = HashSet.make(1, 2, 3) + * const thatIterable = HashSet.make(3, 4, 5) + * + * // Compute the union (all elements from both sets) + * const result = pipe(selfSet, HashSet.union(thatIterable)) + * + * // The result contains all elements from both sets (without duplicates) + * assert.deepStrictEqual( + * HashSet.toValues(result).sort(), + * [1, 2, 3, 4, 5] + * ) + * + * // The original sets are unchanged + * assert.deepStrictEqual(HashSet.toValues(selfSet).sort(), [1, 2, 3]) + * assert.deepStrictEqual( + * HashSet.toValues(thatIterable).sort(), + * [3, 4, 5] + * ) + * + * // You can also use arrays or other iterables + * const unionWithArray = pipe(selfSet, HashSet.union([4, 5, 6])) + * assert.deepStrictEqual( + * HashSet.toValues(unionWithArray).sort(), + * [1, 2, 3, 4, 5, 6] + * ) + * ``` + */ + (that: Iterable): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * // `data-first` API + * import { HashSet } from "effect" + * import * as assert from "node:assert/strict" + * + * // Create two sets with some overlapping elements + * const selfSet = HashSet.make(1, 2, 3) + * const thatIterable = HashSet.make(3, 4, 5) + * + * // Compute the union using data-first API + * const result = HashSet.union(selfSet, thatIterable) + * + * // The result contains all elements from both sets (without duplicates) + * assert.deepStrictEqual( + * HashSet.toValues(result).sort(), + * [1, 2, 3, 4, 5] + * ) + * + * // The original sets are unchanged + * assert.deepStrictEqual(HashSet.toValues(selfSet).sort(), [1, 2, 3]) + * assert.deepStrictEqual( + * HashSet.toValues(thatIterable).sort(), + * [3, 4, 5] + * ) + * + * // You can also use arrays or other iterables + * const unionWithArray = HashSet.union(selfSet, [4, 5, 6]) + * assert.deepStrictEqual( + * HashSet.toValues(unionWithArray).sort(), + * [1, 2, 3, 4, 5, 6] + * ) + * ``` + */ + (self: HashSet, that: Iterable): HashSet; +}; +/** + * Checks if a value is present in the `HashSet`. If it is present, the value + * will be removed from the `HashSet`, otherwise the value will be added to the + * `HashSet`. + * + * Time complexity: **`O(1)`** average + * + * @memberof HashSet + * @since 2.0.0 + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe(HashSet.make(0, 1, 2), HashSet.toggle(0)) + * + * // or piped with the pipe function + * HashSet.make(0, 1, 2).pipe(HashSet.toggle(0)) + * + * // or with `data-first` API + * HashSet.toggle(HashSet.make(0, 1, 2), 0) + * ``` + * + * @returns A new `HashSet` where the toggled value is being either added or + * removed based on the initial `HashSet` state. + * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.remove} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate} + */ +export declare const toggle: { + /** + * @example + * + * ```ts + * // `data-last` a.k.a. `pipeable` API + * import { HashSet, pipe } from "effect" + * import assert from "node:assert/strict" + * + * // arrange + * let set = HashSet.make(0, 1, 2) + * + * // assert 1: 0 is in the set + * assert.equal(pipe(set, HashSet.has(0)), true) + * + * // act 2: toggle 0 once on the set + * set = pipe(set, HashSet.toggle(0)) + * + * // assert 2: 0 is not in the set any longer + * assert.equal(pipe(set, HashSet.has(0)), false) + * + * // act 3: toggle 0 once again on the set + * set = pipe(set, HashSet.toggle(0)) + * + * // assert 3: 0 in now back in the set + * assert.equal(pipe(set, HashSet.has(0)), true) + * ``` + */ + (value: A): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * // `data-first` API + * import { HashSet, pipe } from "effect" + * import assert from "node:assert/strict" + * + * // arrange + * let set = HashSet.make(0, 1, 2) + * + * // assert 1: 0 is in the set + * assert.equal(HashSet.has(set, 0), true) + * + * // act 2: toggle 0 once on the set + * set = HashSet.toggle(set, 0) + * + * // assert 2: 0 is not in the set any longer + * assert.equal(HashSet.has(set, 0), false) + * + * // act 3: toggle 0 once again on the set + * set = HashSet.toggle(set, 0) + * + * // assert 3: 0 in now back in the set + * assert.equal(HashSet.has(set, 0), true) + * ``` + */ + (self: HashSet, value: A): HashSet; +}; +/** + * Maps over the values of the `HashSet` using the specified function. + * + * The time complexity is of **`O(n)`**. + * + * @memberof HashSet + * @since 2.0.0 + * @category mapping + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * HashSet.make(0, 1, 2), // HashSet.HashSet + * HashSet.map(String) // HashSet.HashSet + * ) + * + * // or piped with the pipe method + * HashSet.make(0, 1, 2).pipe(HashSet.map(String)) + * + * // or with `data-first` API + * HashSet.map(HashSet.make(0, 1, 2), String) + * ``` + */ +export declare const map: { + /** + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.deepStrictEqual( + * pipe( + * HashSet.make(0, 1, 2), // HashSet.HashSet + * HashSet.map((n) => String(n + 1)) // HashSet.HashSet + * ), + * HashSet.make("1", "2", "3") + * ) + * ``` + */ + (f: (a: A) => B): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.deepStrictEqual( + * HashSet.map( + * HashSet.make(0, 1, 2), // HashSet.HashSet + * (n) => String(n + 1) + * ), // HashSet.HashSet + * HashSet.make("1", "2", "3") + * ) + * ``` + */ + (self: HashSet, f: (a: A) => B): HashSet; +}; +/** + * Chains over the values of the `HashSet` using the specified function. + * + * The time complexity is of **`O(n)`**. + * + * @memberof HashSet + * @since 2.0.0 + * @category sequencing + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * HashSet.make(0, 1, 2), // HashSet.HashSet + * HashSet.flatMap((n) => Array.of(String(n))) // HashSet.HashSet + * ) + * + * // or piped with the pipe method + * HashSet.make(0, 1, 2) // HashSet.HashSet + * .pipe( + * HashSet.flatMap((n) => Array.of(String(n))) // HashSet.HashSet + * ) + * + * // or with `data-first` API + * HashSet.flatMap(HashSet.make(0, 1, 2), (n) => Array.of(String(n))) + * ``` + */ +export declare const flatMap: { + /** + * @example + * + * ```ts + * import { HashSet, pipe, List } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.deepStrictEqual( + * pipe( + * HashSet.make(0, 1, 2), + * HashSet.flatMap((n) => List.of(String(n * n))) // needs to return an Iterable + * ), + * HashSet.make("0", "1", "4") + * ) + * ``` + */ + (f: (a: A) => Iterable): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * import { HashSet, pipe, List } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.deepStrictEqual( + * HashSet.flatMap(HashSet.make(0, 1, 2), (n) => + * List.of(String(n * n * n)) + * ), // needs to return an Iterable + * HashSet.make("0", "1", "8") + * ) + * ``` + */ + (self: HashSet, f: (a: A) => Iterable): HashSet; +}; +/** + * Applies the specified function to the values of the `HashSet`. + * + * The time complexity is of **`O(n)`**. + * + * @memberof HashSet + * @since 2.0.0 + * @category traversing + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe(HashSet.make(0, 1, 2), HashSet.forEach(console.log)) // logs: 0 1 2 + * + * // or piped with the pipe method + * HashSet.make(0, 1, 2).pipe(HashSet.forEach(console.log)) // logs: 0 1 2 + * + * // or with `data-first` API + * HashSet.forEach(HashSet.make(0, 1, 2), console.log) // logs: 0 1 2 + * ``` + */ +export declare const forEach: { + /** + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * const result: Array = [] + * + * pipe( + * HashSet.make(0, 1, 2), + * HashSet.forEach((n): void => { + * result.push(n) + * }) + * ) + * + * assert.deepStrictEqual(result, [0, 1, 2]) + * ``` + */ + (f: (value: A) => void): (self: HashSet) => void; + /** + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * const result: Array = [] + * + * HashSet.forEach(HashSet.make(0, 1, 2), (n): void => { + * result.push(n) + * }) + * + * assert.deepStrictEqual(result, [0, 1, 2]) + * ``` + */ + (self: HashSet, f: (value: A) => void): void; +}; +/** + * Reduces the specified state over the values of the `HashSet`. + * + * The time complexity is of **`O(n)`**. + * + * @memberof HashSet + * @since 2.0.0 + * @category folding + * @example + * + * ```ts + * // Syntax + * import { HashSet, pipe } from "effect" + * + * const sum = (a: number, b: number): number => a + b + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe(HashSet.make(0, 1, 2), HashSet.reduce(0, sum)) + * + * // or with the pipe method + * HashSet.make(0, 1, 2).pipe(HashSet.reduce(0, sum)) + * + * // or with `data-first` API + * HashSet.reduce(HashSet.make(0, 1, 2), 0, sum) + * ``` + */ +export declare const reduce: { + /** + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.equal( + * pipe( + * HashSet.make(0, 1, 2), + * HashSet.reduce(10, (accumulator, value) => accumulator + value) + * ), + * 13 + * ) + * ``` + */ + (zero: Z, f: (accumulator: Z, value: A) => Z): (self: HashSet) => Z; + /** + * @example + * + * ```ts + * import { HashSet } from "effect" + * import * as assert from "node:assert/strict" + * + * assert.equal( + * HashSet.reduce( + * HashSet.make(0, 1, 2), + * -3, + * (accumulator, value) => accumulator + value + * ), + * 0 + * ) + * ``` + */ + (self: HashSet, zero: Z, f: (accumulator: Z, value: A) => Z): Z; +}; +/** + * Filters values out of a `HashSet` using the specified predicate. + * + * The time complexity is of **`O(n)`**. + * + * @memberof HashSet + * @since 2.0.0 + * @category filtering + * @example + * + * ```ts + * // Syntax with Predicate + * import { HashSet, type Predicate, pipe } from "effect" + * + * const filterPositiveNumbers: Predicate.Predicate = (n) => n > 0 + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * HashSet.make(-2, -1, 0, 1, 2), + * HashSet.filter(filterPositiveNumbers) + * ) + * + * // or with the pipe method + * HashSet.make(-2, -1, 0, 1, 2).pipe(HashSet.filter(filterPositiveNumbers)) + * + * // or with `data-first` API + * HashSet.filter(HashSet.make(-2, -1, 0, 1, 2), filterPositiveNumbers) + * ``` + * + * @example + * + * ```ts + * /// Syntax with Refinement + * import { HashSet, pipe } from "effect" + * + * const stringRefinement = (value: unknown): value is string => + * typeof value === "string" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"), // // HashSet.HashSet + * HashSet.filter(stringRefinement) + * ) // HashSet.HashSet + * + * // or with the pipe method + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") // HashSet.HashSet + * .pipe(HashSet.filter(stringRefinement)) // HashSet.HashSet + * + * // or with `data-first` API + * HashSet.filter( + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"), // HashSet.HashSet + * stringRefinement + * ) // HashSet.HashSet + * ``` + */ +export declare const filter: { + /** + * @example + * + * ```ts + * import { HashSet, pipe, Predicate } from "effect" + * import * as assert from "node:assert/strict" + * + * const numbersAndStringsHashSet: HashSet.HashSet = + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") + * + * const stringRefinement: Predicate.Refinement< + * string | number, + * string + * > = (value) => typeof value === "string" + * + * const stringHashSet: HashSet.HashSet = pipe( + * numbersAndStringsHashSet, + * HashSet.filter(stringRefinement) + * ) + * + * assert.equal( + * pipe(stringHashSet, HashSet.every(Predicate.isString)), + * true + * ) + * ``` + */ + (refinement: Refinement, B>): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * import { HashSet, pipe, type Predicate } from "effect" + * import * as assert from "node:assert/strict" + * + * const filterPositiveNumbers: Predicate.Predicate = (n) => n > 0 + * + * assert.deepStrictEqual( + * pipe( + * HashSet.make(-2, -1, 0, 1, 2), + * HashSet.filter(filterPositiveNumbers) + * ), + * HashSet.make(1, 2) + * ) + * ``` + */ + (predicate: Predicate>): (self: HashSet) => HashSet; + /** + * @example + * + * ```ts + * import { HashSet, Predicate } from "effect" + * import * as assert from "node:assert/strict" + * + * const numbersAndStringsHashSet: HashSet.HashSet = + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") + * + * const stringRefinement: Predicate.Refinement< + * string | number, + * string + * > = (value) => typeof value === "string" + * + * const stringHashSet: HashSet.HashSet = HashSet.filter( + * numbersAndStringsHashSet, + * stringRefinement + * ) + * + * assert.equal(HashSet.every(stringHashSet, Predicate.isString), true) + * ``` + */ + (self: HashSet, refinement: Refinement): HashSet; + /** + * @example + * + * ```ts + * import { HashSet, pipe, type Predicate } from "effect" + * import * as assert from "node:assert/strict" + * + * const filterPositiveNumbers: Predicate.Predicate = (n) => n > 0 + * + * assert.deepStrictEqual( + * HashSet.filter(HashSet.make(-2, -1, 0, 1, 2), filterPositiveNumbers), + * HashSet.make(1, 2) + * ) + * ``` + */ + (self: HashSet, predicate: Predicate): HashSet; +}; +/** + * Partition the values of a `HashSet` using the specified predicate. + * + * If a value matches the predicate, it will be placed into the `HashSet` on the + * right side of the resulting `Tuple`, otherwise the value will be placed into + * the left side. + * + * Time complexity is of **`O(n)`**. + * + * @memberof HashSet + * @since 2.0.0 + * @category partitioning + * @example + * + * ```ts + * // Syntax with Predicate + * import { HashSet, pipe, Predicate } from "effect" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * HashSet.make(0, 1, 2, 3, 4, 5), + * HashSet.partition((n) => n % 2 === 0) + * ) + * + * // or with the pipe method + * HashSet.make(0, 1, 2, 3, 4, 5).pipe( + * HashSet.partition((n) => n % 2 === 0) + * ) + * + * // or with `data-first` API + * HashSet.partition(HashSet.make(0, 1, 2, 3, 4, 5), (n) => n % 2 === 0) + * ``` + * + * @example + * + * ```ts + * // Syntax with Refinement + * import { HashSet, pipe, Predicate } from "effect" + * + * const stringRefinement: Predicate.Refinement = ( + * value + * ) => typeof value === "string" + * + * // with `data-last`, a.k.a. `pipeable` API + * pipe( + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"), + * HashSet.partition(stringRefinement) + * ) + * + * // or with the pipe method + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier").pipe( + * HashSet.partition(stringRefinement) + * ) + * + * // or with `data-first` API + * HashSet.partition( + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier"), + * stringRefinement + * ) + * ``` + */ +export declare const partition: { + /** + * @example + * + * ```ts + * import { HashSet, pipe, Predicate } from "effect" + * import * as assert from "node:assert/strict" + * + * const numbersAndStringsHashSet: HashSet.HashSet = + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") + * + * const stringRefinement: Predicate.Refinement< + * string | number, + * string + * > = (value) => typeof value === "string" + * + * const [ + * excluded, // HashSet.HashSet + * satisfying // HashSet.HashSet + * ] = pipe(numbersAndStringsHashSet, HashSet.partition(stringRefinement)) + * + * assert.equal(pipe(satisfying, HashSet.every(Predicate.isString)), true) + * assert.equal(pipe(excluded, HashSet.every(Predicate.isNumber)), true) + * + * assert.deepStrictEqual(excluded, HashSet.make(1, 2, 3, 4)) + * assert.deepStrictEqual( + * satisfying, + * HashSet.make("unos", "two", "trois", "vier") + * ) + * ``` + */ + (refinement: Refinement, B>): (self: HashSet) => [excluded: HashSet>, satisfying: HashSet]; + /** + * @example + * + * ```ts + * import { HashSet, pipe } from "effect" + * import * as assert from "node:assert/strict" + * + * const [excluded, satisfying] = pipe( + * HashSet.make(0, 1, 2, 3, 4, 5), + * HashSet.partition((n) => n % 2 === 0) + * ) + * + * assert.deepStrictEqual(excluded, HashSet.make(1, 3, 5)) + * assert.deepStrictEqual(satisfying, HashSet.make(0, 2, 4)) + * ``` + */ + (predicate: Predicate>): (self: HashSet) => [excluded: HashSet, satisfying: HashSet]; + /** + * @example + * + * ```ts + * import { HashSet, pipe, Predicate } from "effect" + * import * as assert from "node:assert/strict" + * + * const numbersAndStringsHashSet: HashSet.HashSet = + * HashSet.make(1, "unos", 2, "two", 3, "trois", 4, "vier") + * + * const stringRefinement: Predicate.Refinement< + * string | number, + * string + * > = (value) => typeof value === "string" + * + * const [ + * excluded, // HashSet.HashSet + * satisfying // HashSet.HashSet + * ] = HashSet.partition(numbersAndStringsHashSet, stringRefinement) + * + * assert.equal(HashSet.every(satisfying, Predicate.isString), true) + * assert.equal(HashSet.every(excluded, Predicate.isNumber), true) + * + * assert.deepStrictEqual(excluded, HashSet.make(1, 2, 3, 4)) + * assert.deepStrictEqual( + * satisfying, + * HashSet.make("unos", "two", "trois", "vier") + * ) + * ``` + */ + (self: HashSet, refinement: Refinement): [excluded: HashSet>, satisfying: HashSet]; + /** + * @example + * + * ```ts + * import { HashSet } from "effect" + * import * as assert from "node:assert/strict" + * + * const [excluded, satisfying] = HashSet.partition( + * HashSet.make(0, 1, 2, 3, 4, 5), + * (n) => n % 2 === 0 + * ) + * + * assert.deepStrictEqual(excluded, HashSet.make(1, 3, 5)) + * assert.deepStrictEqual(satisfying, HashSet.make(0, 2, 4)) + * ``` + */ + (self: HashSet, predicate: Predicate): [excluded: HashSet, satisfying: HashSet]; +}; +export {}; +//# sourceMappingURL=HashSet.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/HashSet.d.ts.map b/backend/node_modules/effect/dist/dts/HashSet.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..a792952aa2e22ee485ff402b9874bef51328ec47 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/HashSet.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"HashSet.d.ts","sourceRoot":"","sources":["../../src/HashSet.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Inspectable.d.ts b/backend/node_modules/effect/dist/dts/Inspectable.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1d0910c7359c3a73a32a28c9ab11ed78e7b611d8 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Inspectable.d.ts @@ -0,0 +1,88 @@ +/** + * @since 2.0.0 + */ +import type * as FiberRefs from "./FiberRefs.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const NodeInspectSymbol: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type NodeInspectSymbol = typeof NodeInspectSymbol; +/** + * @since 2.0.0 + * @category models + */ +export interface Inspectable { + toString(): string; + toJSON(): unknown; + [NodeInspectSymbol](): unknown; +} +/** + * @since 2.0.0 + */ +export declare const toJSON: (x: unknown) => unknown; +/** + * @since 2.0.0 + */ +export declare const format: (x: unknown) => string; +/** + * @since 2.0.0 + */ +export declare const BaseProto: Inspectable; +/** + * @since 2.0.0 + */ +export declare abstract class Class { + /** + * @since 2.0.0 + */ + abstract toJSON(): unknown; + /** + * @since 2.0.0 + */ + [NodeInspectSymbol](): unknown; + /** + * @since 2.0.0 + */ + toString(): string; +} +/** + * @since 2.0.0 + */ +export declare const toStringUnknown: (u: unknown, whitespace?: number | string | undefined) => string; +/** + * @since 2.0.0 + */ +export declare const stringifyCircular: (obj: unknown, whitespace?: number | string | undefined) => string; +/** + * @since 3.10.0 + * @category redactable + */ +export interface Redactable { + readonly [symbolRedactable]: (fiberRefs: FiberRefs.FiberRefs) => unknown; +} +/** + * @since 3.10.0 + * @category redactable + */ +export declare const symbolRedactable: unique symbol; +/** + * @since 3.10.0 + * @category redactable + */ +export declare const isRedactable: (u: unknown) => u is Redactable; +/** + * @since 3.10.0 + * @category redactable + */ +export declare const withRedactableContext: (context: FiberRefs.FiberRefs, f: () => A) => A; +/** + * @since 3.10.0 + * @category redactable + */ +export declare const redact: (u: unknown) => unknown; +//# sourceMappingURL=Inspectable.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Iterable.d.ts b/backend/node_modules/effect/dist/dts/Iterable.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b7b08841fcc277b2dcb459904a4081985594f544 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Iterable.d.ts @@ -0,0 +1,1047 @@ +/** + * This module provides utility functions for working with Iterables in TypeScript. + * + * @since 2.0.0 + */ +import type { NonEmptyArray } from "./Array.js"; +import type { Either } from "./Either.js"; +import type { Option } from "./Option.js"; +import type * as Record from "./Record.js"; +import type { NoInfer } from "./Types.js"; +/** + * Return a `Iterable` with element `i` initialized with `f(i)`. + * + * If the `length` is not specified, the `Iterable` will be infinite. + * + * **Note**. `length` is normalized to an integer >= 1. + * + * @example + * ```ts + * import * as assert from "node:assert" + * 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 + */ +export declare const makeBy: (f: (i: number) => A, options?: { + readonly length?: number; +}) => Iterable; +/** + * Return a `Iterable` containing a range of integers, including both endpoints. + * + * If `end` is omitted, the range will not have an upper bound. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { range } from "effect/Iterable" + * + * assert.deepStrictEqual(Array.from(range(1, 3)), [1, 2, 3]) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const range: (start: number, end?: number) => Iterable; +/** + * Return a `Iterable` containing a value repeated the specified number of times. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { replicate } from "effect/Iterable" + * + * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"]) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const replicate: { + /** + * Return a `Iterable` containing a value repeated the specified number of times. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { replicate } from "effect/Iterable" + * + * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"]) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (n: number): (a: A) => Iterable; + /** + * Return a `Iterable` containing a value repeated the specified number of times. + * + * **Note**. `n` is normalized to an integer >= 1. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { replicate } from "effect/Iterable" + * + * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"]) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (a: A, n: number): Iterable; +}; +/** + * Takes a record and returns an Iterable of tuples containing its keys and values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * 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 + */ +export declare const fromRecord: (self: Readonly>) => Iterable<[K, A]>; +/** + * Prepend an element to the front of an `Iterable`, creating a new `Iterable`. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prepend: { + /** + * Prepend an element to the front of an `Iterable`, creating a new `Iterable`. + * + * @category concatenating + * @since 2.0.0 + */ + (head: B): (self: Iterable) => Iterable; + /** + * Prepend an element to the front of an `Iterable`, creating a new `Iterable`. + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, head: B): Iterable; +}; +/** + * Prepends the specified prefix iterable to the beginning of the specified iterable. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Iterable } from "effect" + * + * assert.deepStrictEqual( + * Array.from(Iterable.prependAll([1, 2], ["a", "b"])), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prependAll: { + /** + * Prepends the specified prefix iterable to the beginning of the specified iterable. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Iterable } from "effect" + * + * assert.deepStrictEqual( + * Array.from(Iterable.prependAll([1, 2], ["a", "b"])), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (that: Iterable): (self: Iterable) => Iterable; + /** + * Prepends the specified prefix iterable to the beginning of the specified iterable. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Iterable } from "effect" + * + * assert.deepStrictEqual( + * Array.from(Iterable.prependAll([1, 2], ["a", "b"])), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Iterable; +}; +/** + * Append an element to the end of an `Iterable`, creating a new `Iterable`. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const append: { + /** + * Append an element to the end of an `Iterable`, creating a new `Iterable`. + * + * @category concatenating + * @since 2.0.0 + */ + (last: B): (self: Iterable) => Iterable; + /** + * Append an element to the end of an `Iterable`, creating a new `Iterable`. + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, last: B): Iterable; +}; +/** + * Concatenates two iterables, combining their elements. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const appendAll: { + /** + * Concatenates two iterables, combining their elements. + * + * @category concatenating + * @since 2.0.0 + */ + (that: Iterable): (self: Iterable) => Iterable; + /** + * Concatenates two iterables, combining their elements. + * + * @category concatenating + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Iterable; +}; +/** + * Reduce an `Iterable` from the left, keeping all intermediate results instead of only the final result. + * + * @category folding + * @since 2.0.0 + */ +export declare const scan: { + /** + * Reduce an `Iterable` from the left, keeping all intermediate results instead of only the final result. + * + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A) => B): (self: Iterable) => Iterable; + /** + * Reduce an `Iterable` from the left, keeping all intermediate results instead of only the final result. + * + * @category folding + * @since 2.0.0 + */ + (self: Iterable, b: B, f: (b: B, a: A) => B): Iterable; +}; +/** + * Determine if an `Iterable` is empty + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isEmpty } from "effect/Iterable" + * + * assert.deepStrictEqual(isEmpty([]), true); + * assert.deepStrictEqual(isEmpty([1, 2, 3]), false); + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isEmpty: (self: Iterable) => self is Iterable; +/** + * Return the number of elements in a `Iterable`. + * + * @category getters + * @since 2.0.0 + */ +export declare const size: (self: Iterable) => number; +/** + * Get the first element of a `Iterable`, or `None` if the `Iterable` is empty. + * + * @category getters + * @since 2.0.0 + */ +export declare const head: (self: Iterable) => Option; +/** + * Get the first element of a `Iterable`, or throw an error if the `Iterable` is empty. + * + * @category getters + * @since 3.3.0 + */ +export declare const unsafeHead: (self: Iterable) => A; +/** + * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * @category getters + * @since 2.0.0 + */ +export declare const take: { + /** + * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * @category getters + * @since 2.0.0 + */ + (n: number): (self: Iterable) => Iterable; + /** + * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`. + * + * **Note**. `n` is normalized to a non negative integer. + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, n: number): Iterable; +}; +/** + * Calculate the longest initial Iterable for which all element satisfy the specified predicate, creating a new `Iterable`. + * + * @category getters + * @since 2.0.0 + */ +export declare const takeWhile: { + /** + * Calculate the longest initial Iterable for which all element satisfy the specified predicate, creating a new `Iterable`. + * + * @category getters + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Iterable; + /** + * Calculate the longest initial Iterable for which all element satisfy the specified predicate, creating a new `Iterable`. + * + * @category getters + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Iterable; + /** + * Calculate the longest initial Iterable for which all element satisfy the specified predicate, creating a new `Iterable`. + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Iterable; + /** + * Calculate the longest initial Iterable for which all element satisfy the specified predicate, creating a new `Iterable`. + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Iterable; +}; +/** + * Drop a max number of elements from the start of an `Iterable` + * + * **Note**. `n` is normalized to a non negative integer. + * + * @category getters + * @since 2.0.0 + */ +export declare const drop: { + /** + * Drop a max number of elements from the start of an `Iterable` + * + * **Note**. `n` is normalized to a non negative integer. + * + * @category getters + * @since 2.0.0 + */ + (n: number): (self: Iterable) => Iterable; + /** + * Drop a max number of elements from the start of an `Iterable` + * + * **Note**. `n` is normalized to a non negative integer. + * + * @category getters + * @since 2.0.0 + */ + (self: Iterable, n: number): Iterable; +}; +/** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirst: { + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (f: (a: NoInfer, i: number) => Option): (self: Iterable) => Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option): Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Option; +}; +/** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ +export declare const findLast: { + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (f: (a: NoInfer, i: number) => Option): (self: Iterable) => Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option): Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Option; + /** + * Find the last element for which a predicate holds. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Option; +}; +/** + * Takes two `Iterable`s and returns an `Iterable` of corresponding pairs. + * + * @category zipping + * @since 2.0.0 + */ +export declare const zip: { + /** + * Takes two `Iterable`s and returns an `Iterable` of corresponding pairs. + * + * @category zipping + * @since 2.0.0 + */ + (that: Iterable): (self: Iterable) => Iterable<[A, B]>; + /** + * Takes two `Iterable`s and returns an `Iterable` of corresponding pairs. + * + * @category zipping + * @since 2.0.0 + */ + (self: Iterable, that: Iterable): Iterable<[A, B]>; +}; +/** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * @category zipping + * @since 2.0.0 + */ +export declare const zipWith: { + /** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * @category zipping + * @since 2.0.0 + */ + (that: Iterable, f: (a: A, b: B) => C): (self: Iterable) => Iterable; + /** + * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results. If one + * input `Iterable` is short, excess elements of the longer `Iterable` are discarded. + * + * @category zipping + * @since 2.0.0 + */ + (self: Iterable, that: Iterable, f: (a: A, b: B) => C): Iterable; +}; +/** + * Places an element in between members of an `Iterable`. + * If the input is a non-empty array, the result is also a non-empty array. + * + * @since 2.0.0 + */ +export declare const intersperse: { + /** + * Places an element in between members of an `Iterable`. + * If the input is a non-empty array, the result is also a non-empty array. + * + * @since 2.0.0 + */ + (middle: B): (self: Iterable) => Iterable; + /** + * Places an element in between members of an `Iterable`. + * If the input is a non-empty array, the result is also a non-empty array. + * + * @since 2.0.0 + */ + (self: Iterable, middle: B): Iterable; +}; +/** + * Returns a function that checks if an `Iterable` contains a given value using a provided `isEquivalent` function. + * + * @category elements + * @since 2.0.0 + */ +export declare const containsWith: (isEquivalent: (self: A, that: A) => boolean) => { + (a: A): (self: Iterable) => boolean; + (self: Iterable, a: A): boolean; +}; +/** + * Returns a function that checks if a `Iterable` contains a given value using the default `Equivalence`. + * + * @category elements + * @since 2.0.0 + */ +export declare const contains: { + /** + * Returns a function that checks if a `Iterable` contains a given value using the default `Equivalence`. + * + * @category elements + * @since 2.0.0 + */ + (a: A): (self: Iterable) => boolean; + /** + * Returns a function that checks if a `Iterable` contains a given value using the default `Equivalence`. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, a: A): boolean; +}; +/** + * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of + * the `Iterable`. + * + * @category splitting + * @since 2.0.0 + */ +export declare const chunksOf: { + /** + * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of + * the `Iterable`. + * + * @category splitting + * @since 2.0.0 + */ + (n: number): (self: Iterable) => Iterable>; + /** + * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of + * the `Iterable`. + * + * @category splitting + * @since 2.0.0 + */ + (self: Iterable, n: number): Iterable>; +}; +/** + * Group equal, consecutive elements of an `Iterable` into `NonEmptyArray`s using the provided `isEquivalent` function. + * + * @category grouping + * @since 2.0.0 + */ +export declare const groupWith: { + /** + * Group equal, consecutive elements of an `Iterable` into `NonEmptyArray`s using the provided `isEquivalent` function. + * + * @category grouping + * @since 2.0.0 + */ + (isEquivalent: (self: A, that: A) => boolean): (self: Iterable) => Iterable>; + /** + * Group equal, consecutive elements of an `Iterable` into `NonEmptyArray`s using the provided `isEquivalent` function. + * + * @category grouping + * @since 2.0.0 + */ + (self: Iterable, isEquivalent: (self: A, that: A) => boolean): Iterable>; +}; +/** + * Group equal, consecutive elements of an `Iterable` into `NonEmptyArray`s. + * + * @category grouping + * @since 2.0.0 + */ +export declare const group: (self: Iterable) => Iterable>; +/** + * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning + * function on each element, and grouping the results according to values returned + * + * @category grouping + * @since 2.0.0 + */ +export declare const groupBy: { + /** + * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning + * function on each element, and grouping the results according to values returned + * + * @category grouping + * @since 2.0.0 + */ + (f: (a: A) => K): (self: Iterable) => Record, NonEmptyArray>; + /** + * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning + * function on each element, and grouping the results according to values returned + * + * @category grouping + * @since 2.0.0 + */ + (self: Iterable, f: (a: A) => K): Record, NonEmptyArray>; +}; +/** + * @category constructors + * @since 2.0.0 + */ +export declare const empty: () => Iterable; +/** + * Constructs a new `Iterable` from the specified value. + * + * @category constructors + * @since 2.0.0 + */ +export declare const of: (a: A) => Iterable; +/** + * @category mapping + * @since 2.0.0 + */ +export declare const map: { + /** + * @category mapping + * @since 2.0.0 + */ + (f: (a: NoInfer, i: number) => B): (self: Iterable) => Iterable; + /** + * @category mapping + * @since 2.0.0 + */ + (self: Iterable, f: (a: NoInfer, i: number) => B): Iterable; +}; +/** + * Applies a function to each element in an Iterable and returns a new Iterable containing the concatenated mapped elements. + * + * @category sequencing + * @since 2.0.0 + */ +export declare const flatMap: { + /** + * Applies a function to each element in an Iterable and returns a new Iterable containing the concatenated mapped elements. + * + * @category sequencing + * @since 2.0.0 + */ + (f: (a: NoInfer, i: number) => Iterable): (self: Iterable) => Iterable; + /** + * Applies a function to each element in an Iterable and returns a new Iterable containing the concatenated mapped elements. + * + * @category sequencing + * @since 2.0.0 + */ + (self: Iterable, f: (a: NoInfer, i: number) => Iterable): Iterable; +}; +/** + * Flattens an Iterable of Iterables into a single Iterable + * + * @category sequencing + * @since 2.0.0 + */ +export declare const flatten: (self: Iterable>) => Iterable; +/** + * @category filtering + * @since 2.0.0 + */ +export declare const filterMap: { + /** + * @category filtering + * @since 2.0.0 + */ + (f: (a: A, i: number) => Option): (self: Iterable) => Iterable; + /** + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option): Iterable; +}; +/** + * Transforms all elements of the `Iterable` for as long as the specified function returns some value + * + * @category filtering + * @since 2.0.0 + */ +export declare const filterMapWhile: { + /** + * Transforms all elements of the `Iterable` for as long as the specified function returns some value + * + * @category filtering + * @since 2.0.0 + */ + (f: (a: A, i: number) => Option): (self: Iterable) => Iterable; + /** + * Transforms all elements of the `Iterable` for as long as the specified function returns some value + * + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => Option): Iterable; +}; +/** + * Retrieves the `Some` values from an `Iterable` of `Option`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * 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 + */ +export declare const getSomes: (self: Iterable>) => Iterable; +/** + * Retrieves the `Left` values from an `Iterable` of `Either`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * 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 + */ +export declare const getLefts: (self: Iterable>) => Iterable; +/** + * Retrieves the `Right` values from an `Iterable` of `Either`s. + * + * @example + * ```ts + * import * as assert from "node:assert" + * 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 + */ +export declare const getRights: (self: Iterable>) => Iterable; +/** + * @category filtering + * @since 2.0.0 + */ +export declare const filter: { + /** + * @category filtering + * @since 2.0.0 + */ + (refinement: (a: NoInfer, i: number) => a is B): (self: Iterable) => Iterable; + /** + * @category filtering + * @since 2.0.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => Iterable; + /** + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, refinement: (a: A, i: number) => a is B): Iterable; + /** + * @category filtering + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): Iterable; +}; +/** + * @category sequencing + * @since 2.0.0 + */ +export declare const flatMapNullable: { + /** + * @category sequencing + * @since 2.0.0 + */ + (f: (a: A) => B | null | undefined): (self: Iterable) => Iterable>; + /** + * @category sequencing + * @since 2.0.0 + */ + (self: Iterable, f: (a: A) => B | null | undefined): Iterable>; +}; +/** + * Check if a predicate holds true for some `Iterable` element. + * + * @category elements + * @since 2.0.0 + */ +export declare const some: { + /** + * Check if a predicate holds true for some `Iterable` element. + * + * @category elements + * @since 2.0.0 + */ + (predicate: (a: A, i: number) => boolean): (self: Iterable) => boolean; + /** + * Check if a predicate holds true for some `Iterable` element. + * + * @category elements + * @since 2.0.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): boolean; +}; +/** + * @category constructors + * @since 2.0.0 + */ +export declare const unfold: (b: B, f: (b: B) => Option) => Iterable; +/** + * Iterate over the `Iterable` applying `f`. + * + * @since 2.0.0 + */ +export declare const forEach: { + /** + * Iterate over the `Iterable` applying `f`. + * + * @since 2.0.0 + */ + (f: (a: A, i: number) => void): (self: Iterable) => void; + /** + * Iterate over the `Iterable` applying `f`. + * + * @since 2.0.0 + */ + (self: Iterable, f: (a: A, i: number) => void): void; +}; +/** + * @category folding + * @since 2.0.0 + */ +export declare const reduce: { + /** + * @category folding + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A, i: number) => B): (self: Iterable) => B; + /** + * @category folding + * @since 2.0.0 + */ + (self: Iterable, b: B, f: (b: B, a: A, i: number) => B): B; +}; +/** + * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function. + * + * @since 2.0.0 + */ +export declare const dedupeAdjacentWith: { + /** + * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function. + * + * @since 2.0.0 + */ + (isEquivalent: (self: A, that: A) => boolean): (self: Iterable) => Iterable; + /** + * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function. + * + * @since 2.0.0 + */ + (self: Iterable, isEquivalent: (self: A, that: A) => boolean): Iterable; +}; +/** + * Deduplicates adjacent elements that are identical. + * + * @since 2.0.0 + */ +export declare const dedupeAdjacent: (self: Iterable) => Iterable; +/** + * Zips this Iterable crosswise with the specified Iterable using the specified combiner. + * + * @since 2.0.0 + * @category elements + */ +export declare const cartesianWith: { + /** + * Zips this Iterable crosswise with the specified Iterable using the specified combiner. + * + * @since 2.0.0 + * @category elements + */ + (that: Iterable, f: (a: A, b: B) => C): (self: Iterable) => Iterable; + /** + * Zips this Iterable crosswise with the specified Iterable using the specified combiner. + * + * @since 2.0.0 + * @category elements + */ + (self: Iterable, that: Iterable, f: (a: A, b: B) => C): Iterable; +}; +/** + * Zips this Iterable crosswise with the specified Iterable. + * + * @since 2.0.0 + * @category elements + */ +export declare const cartesian: { + /** + * Zips this Iterable crosswise with the specified Iterable. + * + * @since 2.0.0 + * @category elements + */ + (that: Iterable): (self: Iterable) => Iterable<[A, B]>; + /** + * Zips this Iterable crosswise with the specified Iterable. + * + * @since 2.0.0 + * @category elements + */ + (self: Iterable, that: Iterable): Iterable<[A, B]>; +}; +/** + * Counts all the element of the given iterable that pass the given predicate + * + * **Example** + * + * ```ts + * import { Iterable } from "effect" + * + * const result = Iterable.countBy([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // 2 + * ``` + * + * @category folding + * @since 3.16.0 + */ +export declare const countBy: { + /** + * Counts all the element of the given iterable that pass the given predicate + * + * **Example** + * + * ```ts + * import { Iterable } from "effect" + * + * const result = Iterable.countBy([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // 2 + * ``` + * + * @category folding + * @since 3.16.0 + */ + (predicate: (a: NoInfer, i: number) => boolean): (self: Iterable) => number; + /** + * Counts all the element of the given iterable that pass the given predicate + * + * **Example** + * + * ```ts + * import { Iterable } from "effect" + * + * const result = Iterable.countBy([1, 2, 3, 4, 5], n => n % 2 === 0) + * console.log(result) // 2 + * ``` + * + * @category folding + * @since 3.16.0 + */ + (self: Iterable, predicate: (a: A, i: number) => boolean): number; +}; +//# sourceMappingURL=Iterable.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Iterable.d.ts.map b/backend/node_modules/effect/dist/dts/Iterable.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..fb6823d25e1b6ad5fbd1ff5f4560c416ac72177d --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Iterable.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Iterable.d.ts","sourceRoot":"","sources":["../../src/Iterable.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/JSONSchema.d.ts b/backend/node_modules/effect/dist/dts/JSONSchema.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..06ccef97f6db4b903287c3b4bf8fb6e8eb07399f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/JSONSchema.d.ts @@ -0,0 +1,268 @@ +/** + * @since 3.10.0 + */ +import type * as Schema from "./Schema.js"; +import * as AST from "./SchemaAST.js"; +type JsonValue = string | number | boolean | null | Array | { + [key: string]: JsonValue; +}; +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchemaAnnotations { + title?: string; + description?: string; + default?: JsonValue; + examples?: Array; +} +/** + * @category model + * @since 3.11.5 + */ +export interface JsonSchema7Never extends JsonSchemaAnnotations { + $id: "/schemas/never"; + not: {}; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Any extends JsonSchemaAnnotations { + $id: "/schemas/any"; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Unknown extends JsonSchemaAnnotations { + $id: "/schemas/unknown"; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Void extends JsonSchemaAnnotations { + $id: "/schemas/void"; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7object extends JsonSchemaAnnotations { + $id: "/schemas/object"; + anyOf: [ + { + type: "object"; + }, + { + type: "array"; + } + ]; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7empty extends JsonSchemaAnnotations { + $id: "/schemas/%7B%7D"; + anyOf: [ + { + type: "object"; + }, + { + type: "array"; + } + ]; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Ref extends JsonSchemaAnnotations { + $ref: string; +} +/** + * @category model + * @since 3.11.7 + */ +export interface JsonSchema7Null extends JsonSchemaAnnotations { + type: "null"; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7String extends JsonSchemaAnnotations { + type: "string"; + minLength?: number; + maxLength?: number; + pattern?: string; + format?: string; + contentMediaType?: string; + allOf?: Array<{ + minLength?: number; + maxLength?: number; + pattern?: string; + }>; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Numeric extends JsonSchemaAnnotations { + minimum?: number; + exclusiveMinimum?: number; + maximum?: number; + exclusiveMaximum?: number; + multipleOf?: number; + allOf?: Array<{ + minimum?: number; + exclusiveMinimum?: number; + maximum?: number; + exclusiveMaximum?: number; + multipleOf?: number; + }>; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Number extends JsonSchema7Numeric { + type: "number"; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Integer extends JsonSchema7Numeric { + type: "integer"; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Boolean extends JsonSchemaAnnotations { + type: "boolean"; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Array extends JsonSchemaAnnotations { + type: "array"; + items?: JsonSchema7 | Array | false; + prefixItems?: Array; + minItems?: number; + maxItems?: number; + additionalItems?: JsonSchema7 | boolean; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Enum extends JsonSchemaAnnotations { + type?: "string" | "number" | "boolean"; + enum: Array; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Enums extends JsonSchemaAnnotations { + $comment: "/schemas/enums"; + anyOf: Array<{ + type: "string" | "number"; + title: string; + enum: [string | number]; + }>; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7AnyOf extends JsonSchemaAnnotations { + anyOf: Array; +} +/** + * @category model + * @since 3.10.0 + */ +export interface JsonSchema7Object extends JsonSchemaAnnotations { + type: "object"; + required: Array; + properties: Record; + additionalProperties?: boolean | JsonSchema7; + patternProperties?: Record; + propertyNames?: JsonSchema7; +} +/** + * @category model + * @since 3.10.0 + */ +export type JsonSchema7 = JsonSchema7Never | JsonSchema7Any | JsonSchema7Unknown | JsonSchema7Void | JsonSchema7object | JsonSchema7empty | JsonSchema7Ref | JsonSchema7Null | JsonSchema7String | JsonSchema7Number | JsonSchema7Integer | JsonSchema7Boolean | JsonSchema7Array | JsonSchema7Enum | JsonSchema7Enums | JsonSchema7AnyOf | JsonSchema7Object; +/** + * @category model + * @since 3.10.0 + */ +export type JsonSchema7Root = JsonSchema7 & { + $schema?: string; + $defs?: Record; +}; +/** + * Generates a JSON Schema from a schema. + * + * **Options** + * + * - `target`: The target JSON Schema version. Possible values are: + * - `"jsonSchema7"`: JSON Schema draft-07 (default behavior). + * - `"jsonSchema2019-09"`: JSON Schema draft-2019-09. + * - `"jsonSchema2020-12"`: JSON Schema draft-2020-12. + * - `"openApi3.1"`: OpenAPI 3.1. + * + * @category encoding + * @since 3.10.0 + */ +export declare const make: (schema: Schema.Schema, options?: { + readonly target?: Target | undefined; +}) => JsonSchema7Root; +type Target = "jsonSchema7" | "jsonSchema2019-09" | "openApi3.1" | "jsonSchema2020-12"; +type TopLevelReferenceStrategy = "skip" | "keep"; +type AdditionalPropertiesStrategy = "allow" | "strict"; +/** + * Returns a JSON Schema with additional options and definitions. + * + * **Warning** + * + * This function is experimental and subject to change. + * + * **Options** + * + * - `definitions`: A record of definitions that are included in the schema. + * - `definitionPath`: The path to the definitions within the schema (defaults + * to "#/$defs/"). + * - `target`: Which spec to target. Possible values are: + * - `'jsonSchema7'`: JSON Schema draft-07 (default behavior). + * - `'jsonSchema2019-09'`: JSON Schema draft-2019-09. + * - `'openApi3.1'`: OpenAPI 3.1. + * - `topLevelReferenceStrategy`: Controls the handling of the top-level + * reference. Possible values are: + * - `"keep"`: Keep the top-level reference (default behavior). + * - `"skip"`: Skip the top-level reference. + * - `additionalPropertiesStrategy`: Controls the handling of additional properties. Possible values are: + * - `"strict"`: Disallow additional properties (default behavior). + * - `"allow"`: Allow additional properties. + * + * @category encoding + * @since 3.11.5 + * @experimental + */ +export declare const fromAST: (ast: AST.AST, options: { + readonly definitions: Record; + readonly definitionPath?: string | undefined; + readonly target?: Target | undefined; + readonly topLevelReferenceStrategy?: TopLevelReferenceStrategy | undefined; + readonly additionalPropertiesStrategy?: AdditionalPropertiesStrategy | undefined; +}) => JsonSchema7; +export {}; +//# sourceMappingURL=JSONSchema.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/JSONSchema.d.ts.map b/backend/node_modules/effect/dist/dts/JSONSchema.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6387afc7638e6b90674029d7179f9d96d2ca8593 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/JSONSchema.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"JSONSchema.d.ts","sourceRoot":"","sources":["../../src/JSONSchema.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/KeyedPool.d.ts b/backend/node_modules/effect/dist/dts/KeyedPool.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..930968e6ae9ab2ed6bbabc398292f7abc36ab2d3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/KeyedPool.d.ts @@ -0,0 +1,182 @@ +/** + * @since 2.0.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Scope from "./Scope.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const KeyedPoolTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type KeyedPoolTypeId = typeof KeyedPoolTypeId; +/** + * A `KeyedPool` is a pool of `Pool`s of items of type `A`. Each pool + * in the `KeyedPool` is associated with a key of type `K`. + * + * @since 2.0.0 + * @category models + */ +export interface KeyedPool extends KeyedPool.Variance, Pipeable { + /** + * Retrieves an item from the pool belonging to the given key in a scoped + * effect. Note that if acquisition fails, then the returned effect will fail + * for that same reason. Retrying a failed acquisition attempt will repeat the + * acquisition attempt. + */ + get(key: K): Effect.Effect; + /** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + */ + invalidate(item: A): Effect.Effect; +} +/** + * @since 2.0.0 + */ +export declare namespace KeyedPool { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [KeyedPoolTypeId]: { + readonly _K: Types.Contravariant; + readonly _A: Types.Invariant; + readonly _E: Types.Covariant; + }; + } +} +/** + * Makes a new pool of the specified fixed size. The pool is returned in a + * `Scope`, which governs the lifetime of the pool. When the pool is shutdown + * because the `Scope` is closed, the individual items allocated by the pool + * will be released in some unspecified order. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (options: { + readonly acquire: (key: K) => Effect.Effect; + readonly size: number; +}) => Effect.Effect, never, Scope.Scope | R>; +/** + * Makes a new pool of the specified fixed size. The pool is returned in a + * `Scope`, which governs the lifetime of the pool. When the pool is shutdown + * because the `Scope` is closed, the individual items allocated by the pool + * will be released in some unspecified order. + * + * The size of the underlying pools can be configured per key. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeWith: (options: { + readonly acquire: (key: K) => Effect.Effect; + readonly size: (key: K) => number; +}) => Effect.Effect, never, Scope.Scope | R>; +/** + * Makes a new pool with the specified minimum and maximum sizes and time to + * live before a pool whose excess items are not being used will be shrunk + * down to the minimum size. The pool is returned in a `Scope`, which governs + * the lifetime of the pool. When the pool is shutdown because the `Scope` is + * used, the individual items allocated by the pool will be released in some + * unspecified order. + * + * The size of the underlying pools can be configured per key. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeWithTTL: (options: { + readonly acquire: (key: K) => Effect.Effect; + readonly min: (key: K) => number; + readonly max: (key: K) => number; + readonly timeToLive: Duration.DurationInput; +}) => Effect.Effect, never, Scope.Scope | R>; +/** + * Makes a new pool with the specified minimum and maximum sizes and time to + * live before a pool whose excess items are not being used will be shrunk + * down to the minimum size. The pool is returned in a `Scope`, which governs + * the lifetime of the pool. When the pool is shutdown because the `Scope` is + * used, the individual items allocated by the pool will be released in some + * unspecified order. + * + * The size of the underlying pools can be configured per key. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeWithTTLBy: (options: { + readonly acquire: (key: K) => Effect.Effect; + readonly min: (key: K) => number; + readonly max: (key: K) => number; + readonly timeToLive: (key: K) => Duration.DurationInput; +}) => Effect.Effect, never, Scope.Scope | R>; +/** + * Retrieves an item from the pool belonging to the given key in a scoped + * effect. Note that if acquisition fails, then the returned effect will fail + * for that same reason. Retrying a failed acquisition attempt will repeat the + * acquisition attempt. + * + * @since 2.0.0 + * @category combinators + */ +export declare const get: { + /** + * Retrieves an item from the pool belonging to the given key in a scoped + * effect. Note that if acquisition fails, then the returned effect will fail + * for that same reason. Retrying a failed acquisition attempt will repeat the + * acquisition attempt. + * + * @since 2.0.0 + * @category combinators + */ + (key: K): (self: KeyedPool) => Effect.Effect; + /** + * Retrieves an item from the pool belonging to the given key in a scoped + * effect. Note that if acquisition fails, then the returned effect will fail + * for that same reason. Retrying a failed acquisition attempt will repeat the + * acquisition attempt. + * + * @since 2.0.0 + * @category combinators + */ + (self: KeyedPool, key: K): Effect.Effect; +}; +/** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + * + * @since 2.0.0 + * @category combinators + */ +export declare const invalidate: { + /** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + * + * @since 2.0.0 + * @category combinators + */ + (item: A): (self: KeyedPool) => Effect.Effect; + /** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + * + * @since 2.0.0 + * @category combinators + */ + (self: KeyedPool, item: A): Effect.Effect; +}; +//# sourceMappingURL=KeyedPool.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/KeyedPool.d.ts.map b/backend/node_modules/effect/dist/dts/KeyedPool.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..127796be915e51e7c99653e7c1f1f41d46e07ef5 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/KeyedPool.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"KeyedPool.d.ts","sourceRoot":"","sources":["../../src/KeyedPool.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Layer.d.ts.map b/backend/node_modules/effect/dist/dts/Layer.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..45c34fb54ffe637fbb1c25d3ab55b4c7eba3815b --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Layer.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../src/Layer.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/LayerMap.d.ts b/backend/node_modules/effect/dist/dts/LayerMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a24c43c463f4cd0f40454a91eab2ad4f304f251 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/LayerMap.d.ts @@ -0,0 +1,265 @@ +/** + * @since 3.14.0 + * @experimental + */ +import * as Context from "./Context.js"; +import type * as Duration from "./Duration.js"; +import * as Effect from "./Effect.js"; +import * as Layer from "./Layer.js"; +import * as RcMap from "./RcMap.js"; +import * as Runtime from "./Runtime.js"; +import * as Scope from "./Scope.js"; +import type { NoExcessProperties } from "./Types.js"; +/** + * @since 3.14.0 + * @category Symbols + */ +export declare const TypeId: unique symbol; +/** + * @since 3.14.0 + * @category Symbols + */ +export type TypeId = typeof TypeId; +/** + * @since 3.14.0 + * @category Models + * @experimental + */ +export interface LayerMap { + readonly [TypeId]: TypeId; + /** + * The internal RcMap that stores the resources. + */ + readonly rcMap: RcMap.RcMap; + readonly runtimeEffect: Effect.Effect, E, Scope.Scope>; + }, E>; + /** + * Retrieves a Layer for the resources associated with the key. + */ + get(key: K): Layer.Layer; + /** + * Retrieves a Runtime for the resources associated with the key. + */ + runtime(key: K): Effect.Effect, E, Scope.Scope>; + /** + * Invalidates the resource associated with the key. + */ + invalidate(key: K): Effect.Effect; +} +/** + * @since 3.14.0 + * @category Constructors + * @experimental + * + * A `LayerMap` allows you to create a map of Layer's that can be used to + * dynamically access resources based on a key. + * + * ```ts + * import { NodeRuntime } from "@effect/platform-node" + * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect" + * + * class Greeter extends Context.Tag("Greeter") + * }>() {} + * + * // create a service that wraps a LayerMap + * class GreeterMap extends LayerMap.Service()("GreeterMap", { + * // define the lookup function for the layer map + * // + * // The returned Layer will be used to provide the Greeter service for the + * // given name. + * lookup: (name: string) => + * Layer.succeed(Greeter, { + * greet: Effect.succeed(`Hello, ${name}!`) + * }).pipe( + * Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123)) + * ), + * + * // If a layer is not used for a certain amount of time, it can be removed + * idleTimeToLive: "5 seconds", + * + * // Supply the dependencies for the layers in the LayerMap + * dependencies: [] + * }) {} + * + * // usage + * const program: Effect.Effect = Effect.gen(function*() { + * // access and use the Greeter service + * const greeter = yield* Greeter + * yield* Effect.log(yield* greeter.greet) + * }).pipe( + * // use the GreeterMap service to provide a variant of the Greeter service + * Effect.provide(GreeterMap.get("John")) + * ) + * + * // run the program + * program.pipe( + * Effect.provide(GreeterMap.Default), + * NodeRuntime.runMain + * ) + * ``` + */ +export declare const make: , PreloadKeys extends Iterable | undefined = undefined>(lookup: (key: K) => L, options?: { + readonly idleTimeToLive?: Duration.DurationInput | undefined; + readonly preloadKeys?: PreloadKeys; +} | undefined) => Effect.Effect ? _A : never, L extends Layer.Layer ? _E : never>, PreloadKeys extends undefined ? never : L extends Layer.Layer ? _E : never, Scope.Scope | (L extends Layer.Layer ? _R : never)>; +/** + * @since 3.14.0 + * @category Constructors + * @experimental + */ +export declare const fromRecord: >, const Preload extends boolean = false>(layers: Layers, options?: { + readonly idleTimeToLive?: Duration.DurationInput | undefined; + readonly preload?: Preload | undefined; +} | undefined) => Effect.Effect ? _A : never, Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer ? _E_1 : never>, Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer ? _E_2 : never, Scope.Scope | (Layers[keyof Layers] extends Layer.Layer ? _R_3 : never)>; +/** + * @since 3.14.0 + * @category Service + */ +export interface TagClass> extends Context.TagClass> { + /** + * A default layer for the `LayerMap` service. + */ + readonly Default: Layer.Layer ? _E : never) | LE, Exclude ? _A : never)> | (Deps extends Layer.Layer ? _R : never)>; + /** + * A default layer for the `LayerMap` service without the dependencies provided. + */ + readonly DefaultWithoutDependencies: Layer.Layer; + /** + * Retrieves a Layer for the resources associated with the key. + */ + readonly get: (key: K) => Layer.Layer; + /** + * Retrieves a Runtime for the resources associated with the key. + */ + readonly runtime: (key: K) => Effect.Effect, E, Scope.Scope | Self>; + /** + * Invalidates the resource associated with the key. + */ + readonly invalidate: (key: K) => Effect.Effect; +} +/** + * @since 3.14.0 + * @category Service + * @experimental + * + * Create a `LayerMap` service that provides a dynamic set of resources based on + * a key. + * + * ```ts + * import { NodeRuntime } from "@effect/platform-node" + * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect" + * + * class Greeter extends Context.Tag("Greeter") + * }>() {} + * + * // create a service that wraps a LayerMap + * class GreeterMap extends LayerMap.Service()("GreeterMap", { + * // define the lookup function for the layer map + * // + * // The returned Layer will be used to provide the Greeter service for the + * // given name. + * lookup: (name: string) => + * Layer.succeed(Greeter, { + * greet: Effect.succeed(`Hello, ${name}!`) + * }).pipe( + * Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123)) + * ), + * + * // If a layer is not used for a certain amount of time, it can be removed + * idleTimeToLive: "5 seconds", + * + * // Supply the dependencies for the layers in the LayerMap + * dependencies: [] + * }) {} + * + * // usage + * const program: Effect.Effect = Effect.gen(function*() { + * // access and use the Greeter service + * const greeter = yield* Greeter + * yield* Effect.log(yield* greeter.greet) + * }).pipe( + * // use the GreeterMap service to provide a variant of the Greeter service + * Effect.provide(GreeterMap.get("John")) + * ) + * + * // run the program + * program.pipe( + * Effect.provide(GreeterMap.Default), + * NodeRuntime.runMain + * ) + * ``` + */ +export declare const Service: () => Layer.Layer; + readonly dependencies?: ReadonlyArray>; + readonly idleTimeToLive?: Duration.DurationInput | undefined; + readonly preloadKeys?: Iterable any; + } ? K : never> | undefined; +}, Options> | NoExcessProperties<{ + readonly layers: Record>; + readonly dependencies?: ReadonlyArray>; + readonly idleTimeToLive?: Duration.DurationInput | undefined; + readonly preload?: boolean; +}, Options>>(id: Id, options: Options) => TagClass any; +} ? K : Options extends { + readonly layers: infer Layers; +} ? keyof Layers : never, Service.Success, Options extends { + readonly preload: true; +} ? never : Service.Error, Service.Context, Options extends { + readonly preload: true; +} ? Service.Error : Options extends { + readonly preloadKey: Iterable; +} ? Service.Error : never, Options extends { + readonly dependencies: ReadonlyArray; +} ? Options["dependencies"][number] : never>; +/** + * @since 3.14.0 + * @category Service + * @experimental + */ +export declare namespace Service { + /** + * @since 3.14.0 + * @category Service + * @experimental + */ + type Key = Options extends { + readonly lookup: (key: infer K) => any; + } ? K : Options extends { + readonly layers: infer Layers; + } ? keyof Layers : never; + /** + * @since 3.14.0 + * @category Service + * @experimental + */ + type Layers = Options extends { + readonly lookup: (key: infer _K) => infer Layers; + } ? Layers : Options extends { + readonly layers: infer Layers; + } ? Layers[keyof Layers] : never; + /** + * @since 3.14.0 + * @category Service + * @experimental + */ + type Success = Layers extends Layer.Layer ? _A : never; + /** + * @since 3.14.0 + * @category Service + * @experimental + */ + type Error = Layers extends Layer.Layer ? _E : never; + /** + * @since 3.14.0 + * @category Service + * @experimental + */ + type Context = Layers extends Layer.Layer ? _R : never; +} +//# sourceMappingURL=LayerMap.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/LayerMap.d.ts.map b/backend/node_modules/effect/dist/dts/LayerMap.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e9516ce80339bbe45dfec0b74d973488637ebe72 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/LayerMap.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"LayerMap.d.ts","sourceRoot":"","sources":["../../src/LayerMap.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/List.d.ts b/backend/node_modules/effect/dist/dts/List.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..05e7e5f1c3520e80b056e384272153d8b8d913af --- /dev/null +++ b/backend/node_modules/effect/dist/dts/List.d.ts @@ -0,0 +1,937 @@ +/** + * A data type for immutable linked lists representing ordered collections of elements of type `A`. + * + * This data type is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access pattern, for example, random access or FIFO, consider using a collection more suited to this than `List`. + * + * **Performance** + * + * - Time: `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list. This includes the index-based lookup of elements, `length`, `append` and `reverse`. + * - Space: `List` implements structural sharing of the tail list. This means that many operations are either zero- or constant-memory cost. + * + * @since 2.0.0 + */ +import * as Chunk from "./Chunk.js"; +import * as Either from "./Either.js"; +import * as Equal from "./Equal.js"; +import * as Equivalence from "./Equivalence.js"; +import { type Inspectable } from "./Inspectable.js"; +import type { NonEmptyIterable } from "./NonEmptyIterable.js"; +import * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import { type Predicate, type Refinement } from "./Predicate.js"; +import type { NoInfer } from "./Types.js"; +/** + * Represents an immutable linked list of elements of type `A`. + * + * A `List` is optimal for last-in-first-out (LIFO), stack-like access patterns. + * If you need another access pattern, for example, random access or FIFO, + * consider using a collection more suited for that other than `List`. + * + * @since 2.0.0 + * @category models + */ +export type List = Cons | Nil; +/** + * @since 2.0.0 + * @category symbol + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface Nil extends Iterable, Equal.Equal, Pipeable, Inspectable { + readonly [TypeId]: TypeId; + readonly _tag: "Nil"; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Cons extends NonEmptyIterable, Equal.Equal, Pipeable, Inspectable { + readonly [TypeId]: TypeId; + readonly _tag: "Cons"; + readonly head: A; + readonly tail: List; +} +/** + * Converts the specified `List` to an `Array`. + * + * @category conversions + * @since 2.0.0 + */ +export declare const toArray: (self: List) => Array; +/** + * @category equivalence + * @since 2.0.0 + */ +export declare const getEquivalence: (isEquivalent: Equivalence.Equivalence) => Equivalence.Equivalence>; +/** + * Returns `true` if the specified value is a `List`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isList: { + /** + * Returns `true` if the specified value is a `List`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ + (u: Iterable): u is List; + /** + * Returns `true` if the specified value is a `List`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ + (u: unknown): u is List; +}; +/** + * Returns `true` if the specified value is a `List.Nil`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isNil: (self: List) => self is Nil; +/** + * Returns `true` if the specified value is a `List.Cons`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isCons: (self: List) => self is Cons; +/** + * Returns the number of elements contained in the specified `List` + * + * @since 2.0.0 + * @category getters + */ +export declare const size: (self: List) => number; +/** + * Constructs a new empty `List`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const nil: () => List; +/** + * Constructs a new `List.Cons` from the specified `head` and `tail` values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const cons: (head: A, tail: List) => Cons; +/** + * Constructs a new empty `List`. + * + * Alias of {@link nil}. + * + * @since 2.0.0 + * @category constructors + */ +export declare const empty: () => List; +/** + * Constructs a new `List` from the specified value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const of: (value: A) => Cons; +/** + * Creates a new `List` from an iterable collection of values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromIterable: (prefix: Iterable) => List; +/** + * Constructs a new `List` from the specified values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: ]>(...elements: Elements) => Cons; +/** + * Appends the specified element to the end of the `List`, creating a new `Cons`. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const append: { + /** + * Appends the specified element to the end of the `List`, creating a new `Cons`. + * + * @category concatenating + * @since 2.0.0 + */ + (element: B): (self: List) => Cons; + /** + * Appends the specified element to the end of the `List`, creating a new `Cons`. + * + * @category concatenating + * @since 2.0.0 + */ + (self: List, element: B): Cons; +}; +/** + * Concatenates two lists, combining their elements. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray), + * [1, 2, "a", "b"] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const appendAll: { + /** + * Concatenates two lists, combining their elements. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray), + * [1, 2, "a", "b"] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + , T extends List>(that: T): (self: S) => List.OrNonEmpty | List.Infer>; + /** + * Concatenates two lists, combining their elements. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray), + * [1, 2, "a", "b"] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: List, that: Cons): Cons; + /** + * Concatenates two lists, combining their elements. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray), + * [1, 2, "a", "b"] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Cons, that: List): Cons; + /** + * Concatenates two lists, combining their elements. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray), + * [1, 2, "a", "b"] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: List, that: List): List; +}; +/** + * Prepends the specified element to the beginning of the list. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prepend: { + /** + * Prepends the specified element to the beginning of the list. + * + * @category concatenating + * @since 2.0.0 + */ + (element: B): (self: List) => Cons; + /** + * Prepends the specified element to the beginning of the list. + * + * @category concatenating + * @since 2.0.0 + */ + (self: List, element: B): Cons; +}; +/** + * Prepends the specified prefix list to the beginning of the specified list. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prependAll: { + /** + * Prepends the specified prefix list to the beginning of the specified list. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + , T extends List>(that: T): (self: S) => List.OrNonEmpty | List.Infer>; + /** + * Prepends the specified prefix list to the beginning of the specified list. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: List, that: Cons): Cons; + /** + * Prepends the specified prefix list to the beginning of the specified list. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: Cons, that: List): Cons; + /** + * Prepends the specified prefix list to the beginning of the specified list. + * If either list is non-empty, the result is also a non-empty list. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { List } from "effect" + * + * assert.deepStrictEqual( + * List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray), + * ["a", "b", 1, 2] + * ) + * ``` + * + * @category concatenating + * @since 2.0.0 + */ + (self: List, that: List): List; +}; +/** + * Prepends the specified prefix list (in reverse order) to the beginning of the + * specified list. + * + * @category concatenating + * @since 2.0.0 + */ +export declare const prependAllReversed: { + /** + * Prepends the specified prefix list (in reverse order) to the beginning of the + * specified list. + * + * @category concatenating + * @since 2.0.0 + */ + (prefix: List): (self: List) => List; + /** + * Prepends the specified prefix list (in reverse order) to the beginning of the + * specified list. + * + * @category concatenating + * @since 2.0.0 + */ + (self: List, prefix: List): List; +}; +/** + * Drops the first `n` elements from the specified list. + * + * @since 2.0.0 + * @category combinators + */ +export declare const drop: { + /** + * Drops the first `n` elements from the specified list. + * + * @since 2.0.0 + * @category combinators + */ + (n: number): (self: List) => List; + /** + * Drops the first `n` elements from the specified list. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, n: number): List; +}; +/** + * Check if a predicate holds true for every `List` element. + * + * @since 2.0.0 + * @category elements + */ +export declare const every: { + /** + * Check if a predicate holds true for every `List` element. + * + * @since 2.0.0 + * @category elements + */ + (refinement: Refinement, B>): (self: List) => self is List; + /** + * Check if a predicate holds true for every `List` element. + * + * @since 2.0.0 + * @category elements + */ + (predicate: Predicate): (self: List) => boolean; + /** + * Check if a predicate holds true for every `List` element. + * + * @since 2.0.0 + * @category elements + */ + (self: List, refinement: Refinement): self is List; + /** + * Check if a predicate holds true for every `List` element. + * + * @since 2.0.0 + * @category elements + */ + (self: List, predicate: Predicate): boolean; +}; +/** + * Check if a predicate holds true for some `List` element. + * + * @since 2.0.0 + * @category elements + */ +export declare const some: { + /** + * Check if a predicate holds true for some `List` element. + * + * @since 2.0.0 + * @category elements + */ + (predicate: Predicate>): (self: List) => self is Cons; + /** + * Check if a predicate holds true for some `List` element. + * + * @since 2.0.0 + * @category elements + */ + (self: List, predicate: Predicate): self is Cons; +}; +/** + * Filters a list using the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ +export declare const filter: { + /** + * Filters a list using the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (refinement: Refinement, B>): (self: List) => List; + /** + * Filters a list using the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (predicate: Predicate>): (self: List) => List; + /** + * Filters a list using the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, refinement: Refinement): List; + /** + * Filters a list using the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, predicate: Predicate): List; +}; +/** + * Filters and maps a list using the specified partial function. The resulting + * list may be smaller than the input list due to the possibility of the partial + * function not being defined for some elements. + * + * @since 2.0.0 + * @category combinators + */ +export declare const filterMap: { + /** + * Filters and maps a list using the specified partial function. The resulting + * list may be smaller than the input list due to the possibility of the partial + * function not being defined for some elements. + * + * @since 2.0.0 + * @category combinators + */ + (f: (a: A) => Option.Option): (self: List) => List; + /** + * Filters and maps a list using the specified partial function. The resulting + * list may be smaller than the input list due to the possibility of the partial + * function not being defined for some elements. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, f: (a: A) => Option.Option): List; +}; +/** + * Removes all `None` values from the specified list. + * + * @since 2.0.0 + * @category combinators + */ +export declare const compact: (self: List>) => List; +/** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirst: { + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (refinement: Refinement, B>): (self: List) => Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (predicate: Predicate>): (self: List) => Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: List, refinement: Refinement): Option.Option; + /** + * Returns the first element that satisfies the specified + * predicate, or `None` if no such element exists. + * + * @category elements + * @since 2.0.0 + */ + (self: List, predicate: Predicate): Option.Option; +}; +/** + * Applies a function to each element in a list and returns a new list containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatMap: { + /** + * Applies a function to each element in a list and returns a new list containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ + , T extends List>(f: (a: List.Infer, i: number) => T): (self: S) => List.AndNonEmpty>; + /** + * Applies a function to each element in a list and returns a new list containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ + (self: Cons, f: (a: A, i: number) => Cons): Cons; + /** + * Applies a function to each element in a list and returns a new list containing the concatenated mapped elements. + * + * @since 2.0.0 + * @category sequencing + */ + (self: List, f: (a: A, i: number) => List): List; +}; +/** + * Applies the specified function to each element of the `List`. + * + * @since 2.0.0 + * @category combinators + */ +export declare const forEach: { + /** + * Applies the specified function to each element of the `List`. + * + * @since 2.0.0 + * @category combinators + */ + (f: (a: A) => B): (self: List) => void; + /** + * Applies the specified function to each element of the `List`. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, f: (a: A) => B): void; +}; +/** + * Returns the first element of the specified list, or `None` if the list is + * empty. + * + * @since 2.0.0 + * @category getters + */ +export declare const head: (self: List) => Option.Option; +/** + * Returns the last element of the specified list, or `None` if the list is + * empty. + * + * @since 2.0.0 + * @category getters + */ +export declare const last: (self: List) => Option.Option; +/** + * @since 2.0.0 + */ +export declare namespace List { + /** + * @since 2.0.0 + */ + type Infer> = S extends List ? A : never; + /** + * @since 2.0.0 + */ + type With, A> = S extends Cons ? Cons : List; + /** + * @since 2.0.0 + */ + type OrNonEmpty, T extends List, A> = S extends Cons ? Cons : T extends Cons ? Cons : List; + /** + * @since 2.0.0 + */ + type AndNonEmpty, T extends List, A> = S extends Cons ? T extends Cons ? Cons : List : List; +} +/** + * Applies the specified mapping function to each element of the list. + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Applies the specified mapping function to each element of the list. + * + * @since 2.0.0 + * @category mapping + */ + , B>(f: (a: List.Infer, i: number) => B): (self: S) => List.With; + /** + * Applies the specified mapping function to each element of the list. + * + * @since 2.0.0 + * @category mapping + */ + , B>(self: S, f: (a: List.Infer, i: number) => B): List.With; +}; +/** + * Partition a list into two lists, where the first list contains all elements + * that did not satisfy the specified predicate, and the second list contains + * all elements that did satisfy the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ +export declare const partition: { + /** + * Partition a list into two lists, where the first list contains all elements + * that did not satisfy the specified predicate, and the second list contains + * all elements that did satisfy the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (refinement: Refinement, B>): (self: List) => [excluded: List>, satisfying: List]; + /** + * Partition a list into two lists, where the first list contains all elements + * that did not satisfy the specified predicate, and the second list contains + * all elements that did satisfy the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (predicate: Predicate>): (self: List) => [excluded: List, satisfying: List]; + /** + * Partition a list into two lists, where the first list contains all elements + * that did not satisfy the specified predicate, and the second list contains + * all elements that did satisfy the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, refinement: Refinement): [excluded: List>, satisfying: List]; + /** + * Partition a list into two lists, where the first list contains all elements + * that did not satisfy the specified predicate, and the second list contains + * all elements that did satisfy the specified predicate. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, predicate: Predicate): [excluded: List, satisfying: List]; +}; +/** + * Partition a list into two lists, where the first list contains all elements + * for which the specified function returned a `Left`, and the second list + * contains all elements for which the specified function returned a `Right`. + * + * @since 2.0.0 + * @category combinators + */ +export declare const partitionMap: { + /** + * Partition a list into two lists, where the first list contains all elements + * for which the specified function returned a `Left`, and the second list + * contains all elements for which the specified function returned a `Right`. + * + * @since 2.0.0 + * @category combinators + */ + (f: (a: A) => Either.Either): (self: List) => [left: List, right: List]; + /** + * Partition a list into two lists, where the first list contains all elements + * for which the specified function returned a `Left`, and the second list + * contains all elements for which the specified function returned a `Right`. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, f: (a: A) => Either.Either): [left: List, right: List]; +}; +/** + * Folds over the elements of the list using the specified function, using the + * specified initial value. + * + * @since 2.0.0 + * @category folding + */ +export declare const reduce: { + /** + * Folds over the elements of the list using the specified function, using the + * specified initial value. + * + * @since 2.0.0 + * @category folding + */ + (zero: Z, f: (b: Z, a: A) => Z): (self: List) => Z; + /** + * Folds over the elements of the list using the specified function, using the + * specified initial value. + * + * @since 2.0.0 + * @category folding + */ + (self: List, zero: Z, f: (b: Z, a: A) => Z): Z; +}; +/** + * Folds over the elements of the list using the specified function, beginning + * with the last element of the list, using the specified initial value. + * + * @since 2.0.0 + * @category folding + */ +export declare const reduceRight: { + /** + * Folds over the elements of the list using the specified function, beginning + * with the last element of the list, using the specified initial value. + * + * @since 2.0.0 + * @category folding + */ + (zero: Z, f: (accumulator: Z, value: A) => Z): (self: List) => Z; + /** + * Folds over the elements of the list using the specified function, beginning + * with the last element of the list, using the specified initial value. + * + * @since 2.0.0 + * @category folding + */ + (self: List, zero: Z, f: (accumulator: Z, value: A) => Z): Z; +}; +/** + * Returns a new list with the elements of the specified list in reverse order. + * + * @since 2.0.0 + * @category elements + */ +export declare const reverse: (self: List) => List; +/** + * Splits the specified list into two lists at the specified index. + * + * @since 2.0.0 + * @category combinators + */ +export declare const splitAt: { + /** + * Splits the specified list into two lists at the specified index. + * + * @since 2.0.0 + * @category combinators + */ + (n: number): (self: List) => [beforeIndex: List, fromIndex: List]; + /** + * Splits the specified list into two lists at the specified index. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, n: number): [beforeIndex: List, fromIndex: List]; +}; +/** + * Returns the tail of the specified list, or `None` if the list is empty. + * + * @since 2.0.0 + * @category getters + */ +export declare const tail: (self: List) => Option.Option>; +/** + * Takes the specified number of elements from the beginning of the specified + * list. + * + * @since 2.0.0 + * @category combinators + */ +export declare const take: { + /** + * Takes the specified number of elements from the beginning of the specified + * list. + * + * @since 2.0.0 + * @category combinators + */ + (n: number): (self: List) => List; + /** + * Takes the specified number of elements from the beginning of the specified + * list. + * + * @since 2.0.0 + * @category combinators + */ + (self: List, n: number): List; +}; +/** + * Converts the specified `List` to a `Chunk`. + * + * @since 2.0.0 + * @category conversions + */ +export declare const toChunk: (self: List) => Chunk.Chunk; +/** + * Unsafely returns the first element of the specified `List`. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeHead: (self: List) => A; +/** + * Unsafely returns the last element of the specified `List`. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeLast: (self: List) => A; +/** + * Unsafely returns the tail of the specified `List`. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeTail: (self: List) => List; +//# sourceMappingURL=List.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/LogLevel.d.ts b/backend/node_modules/effect/dist/dts/LogLevel.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a4d1914ae5d66e91e6fc788f2bf5d04fd7905bde --- /dev/null +++ b/backend/node_modules/effect/dist/dts/LogLevel.d.ts @@ -0,0 +1,333 @@ +/** + * @since 2.0.0 + */ +import type * as Effect from "./Effect.js"; +import * as order from "./Order.js"; +import type { Pipeable } from "./Pipeable.js"; +/** + * A `LogLevel` represents the log level associated with an individual logging + * operation. Log levels are used both to describe the granularity (or + * importance) of individual log statements, as well as to enable tuning + * verbosity of log output. + * + * @since 2.0.0 + * @category model + * @property ordinal - The priority of the log message. Larger values indicate higher priority. + * @property label - A label associated with the log level. + * @property syslog -The syslog severity level of the log level. + */ +export type LogLevel = All | Fatal | Error | Warning | Info | Debug | Trace | None; +/** + * @since 2.0.0 + * @category model + */ +export type Literal = LogLevel["_tag"]; +/** + * @since 2.0.0 + * @category model + */ +export interface All extends Pipeable { + readonly _tag: "All"; + readonly label: "ALL"; + readonly syslog: 0; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category model + */ +export interface Fatal extends Pipeable { + readonly _tag: "Fatal"; + readonly label: "FATAL"; + readonly syslog: 2; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category model + */ +export interface Error extends Pipeable { + readonly _tag: "Error"; + readonly label: "ERROR"; + readonly syslog: 3; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category model + */ +export interface Warning extends Pipeable { + readonly _tag: "Warning"; + readonly label: "WARN"; + readonly syslog: 4; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category model + */ +export interface Info extends Pipeable { + readonly _tag: "Info"; + readonly label: "INFO"; + readonly syslog: 6; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category model + */ +export interface Debug extends Pipeable { + readonly _tag: "Debug"; + readonly label: "DEBUG"; + readonly syslog: 7; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category model + */ +export interface Trace extends Pipeable { + readonly _tag: "Trace"; + readonly label: "TRACE"; + readonly syslog: 7; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category model + */ +export interface None extends Pipeable { + readonly _tag: "None"; + readonly label: "OFF"; + readonly syslog: 7; + readonly ordinal: number; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const All: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Fatal: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Error: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Warning: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Info: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Debug: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Trace: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const None: LogLevel; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const allLevels: readonly LogLevel[]; +/** + * Temporarily sets a `LogLevel` for an `Effect` workflow. + * + * **Details** + * + * This function allows you to apply a specific `LogLevel` locally to an + * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its + * previous state. + * + * **When to Use** + * + * This is particularly useful when you want to adjust the verbosity of logging + * for specific parts of your program without affecting the global log level. + * + * @example + * ```ts + * import { Effect, LogLevel } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.gen(function*() { + * yield* Effect.log("message2") + * yield* Effect.log("message3") + * }).pipe(LogLevel.locally(LogLevel.Warning)) + * }) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 + * // timestamp=... level=WARN fiber=#0 message=message2 + * // timestamp=... level=WARN fiber=#0 message=message3 + * ``` + * + * @since 2.0.0 + * @category utils + */ +export declare const locally: { + /** + * Temporarily sets a `LogLevel` for an `Effect` workflow. + * + * **Details** + * + * This function allows you to apply a specific `LogLevel` locally to an + * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its + * previous state. + * + * **When to Use** + * + * This is particularly useful when you want to adjust the verbosity of logging + * for specific parts of your program without affecting the global log level. + * + * @example + * ```ts + * import { Effect, LogLevel } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.gen(function*() { + * yield* Effect.log("message2") + * yield* Effect.log("message3") + * }).pipe(LogLevel.locally(LogLevel.Warning)) + * }) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 + * // timestamp=... level=WARN fiber=#0 message=message2 + * // timestamp=... level=WARN fiber=#0 message=message3 + * ``` + * + * @since 2.0.0 + * @category utils + */ + (self: LogLevel): (use: Effect.Effect) => Effect.Effect; + /** + * Temporarily sets a `LogLevel` for an `Effect` workflow. + * + * **Details** + * + * This function allows you to apply a specific `LogLevel` locally to an + * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its + * previous state. + * + * **When to Use** + * + * This is particularly useful when you want to adjust the verbosity of logging + * for specific parts of your program without affecting the global log level. + * + * @example + * ```ts + * import { Effect, LogLevel } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("message1") + * yield* Effect.gen(function*() { + * yield* Effect.log("message2") + * yield* Effect.log("message3") + * }).pipe(LogLevel.locally(LogLevel.Warning)) + * }) + * + * Effect.runFork(program) + * // timestamp=... level=INFO fiber=#0 message=message1 + * // timestamp=... level=WARN fiber=#0 message=message2 + * // timestamp=... level=WARN fiber=#0 message=message3 + * ``` + * + * @since 2.0.0 + * @category utils + */ + (use: Effect.Effect, self: LogLevel): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category instances + */ +export declare const Order: order.Order; +/** + * @since 2.0.0 + * @category ordering + */ +export declare const lessThan: { + /** + * @since 2.0.0 + * @category ordering + */ + (that: LogLevel): (self: LogLevel) => boolean; + /** + * @since 2.0.0 + * @category ordering + */ + (self: LogLevel, that: LogLevel): boolean; +}; +/** + * @since 2.0.0 + * @category ordering + */ +export declare const lessThanEqual: { + /** + * @since 2.0.0 + * @category ordering + */ + (that: LogLevel): (self: LogLevel) => boolean; + /** + * @since 2.0.0 + * @category ordering + */ + (self: LogLevel, that: LogLevel): boolean; +}; +/** + * @since 2.0.0 + * @category ordering + */ +export declare const greaterThan: { + /** + * @since 2.0.0 + * @category ordering + */ + (that: LogLevel): (self: LogLevel) => boolean; + /** + * @since 2.0.0 + * @category ordering + */ + (self: LogLevel, that: LogLevel): boolean; +}; +/** + * @since 2.0.0 + * @category ordering + */ +export declare const greaterThanEqual: { + /** + * @since 2.0.0 + * @category ordering + */ + (that: LogLevel): (self: LogLevel) => boolean; + /** + * @since 2.0.0 + * @category ordering + */ + (self: LogLevel, that: LogLevel): boolean; +}; +/** + * @since 2.0.0 + * @category conversions + */ +export declare const fromLiteral: (literal: Literal) => LogLevel; +//# sourceMappingURL=LogLevel.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/LogLevel.d.ts.map b/backend/node_modules/effect/dist/dts/LogLevel.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..dc9f21ce36b295a9a3996490aeae38ae2bbb4415 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/LogLevel.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"LogLevel.d.ts","sourceRoot":"","sources":["../../src/LogLevel.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAI1C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,QAAQ,GAAG,GAAG,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,CAAA;AAElF;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAA;AAEtC;;;GAGG;AACH,MAAM,WAAW,GAAI,SAAQ,QAAQ;IACnC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,KAAM,SAAQ,QAAQ;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,KAAM,SAAQ,QAAQ;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,OAAQ,SAAQ,QAAQ;IACvC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,IAAK,SAAQ,QAAQ;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,KAAM,SAAQ,QAAQ;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,KAAM,SAAQ,QAAQ;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,IAAK,SAAQ,QAAQ;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,QAA2B,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,QAA6B,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,QAA6B,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,QAA+B,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,QAA4B,CAAA;AAE/C;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,QAA6B,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,QAA6B,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,QAA4B,CAAA;AAE/C;;;GAGG;AACH,eAAO,MAAM,SAAS,qBAAoB,CAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IAClF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAK/E,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,CAGvC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAA;IAC7C;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;CAClB,CAAA;AAEzB;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAA;IAC7C;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;CACT,CAAA;AAElC;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAA;IAC7C;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;CACf,CAAA;AAE5B;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAC7B;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAA;IAC7C;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;CACN,CAAA;AAErC;;;GAGG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,OAAO,KAAG,QAmB9C,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/LogSpan.d.ts b/backend/node_modules/effect/dist/dts/LogSpan.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..730c92cb8d9195dbcd469c17bd34e326049a51bc --- /dev/null +++ b/backend/node_modules/effect/dist/dts/LogSpan.d.ts @@ -0,0 +1,19 @@ +/** + * @since 2.0.0 + * @category models + */ +export interface LogSpan { + readonly label: string; + readonly startTime: number; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (label: string, startTime: number) => LogSpan; +/** + * @since 2.0.0 + * @category destructors + */ +export declare const render: (now: number) => (self: LogSpan) => string; +//# sourceMappingURL=LogSpan.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/LogSpan.d.ts.map b/backend/node_modules/effect/dist/dts/LogSpan.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..ea727ad769169d35e919547a4795f626e62d9791 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/LogSpan.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"LogSpan.d.ts","sourceRoot":"","sources":["../../src/LogSpan.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAuB,CAAA;AAEhF;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,IAAI,EAAE,OAAO,KAAK,MAAwB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Logger.d.ts b/backend/node_modules/effect/dist/dts/Logger.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8c54f3248b1072e1c9dd3e10d054859c2f3221d3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Logger.d.ts @@ -0,0 +1,795 @@ +/** + * @since 2.0.0 + */ +import type * as Cause from "./Cause.js"; +import type { DurationInput } from "./Duration.js"; +import type { Effect } from "./Effect.js"; +import type * as FiberId from "./FiberId.js"; +import type * as FiberRefs from "./FiberRefs.js"; +import type { LazyArg } from "./Function.js"; +import type * as HashMap from "./HashMap.js"; +import type * as Layer from "./Layer.js"; +import type * as List from "./List.js"; +import type * as LogLevel from "./LogLevel.js"; +import type * as LogSpan from "./LogSpan.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Scope } from "./Scope.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const LoggerTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type LoggerTypeId = typeof LoggerTypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface Logger extends Logger.Variance, Pipeable { + log(options: Logger.Options): Output; +} +/** + * @since 2.0.0 + */ +export declare namespace Logger { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [LoggerTypeId]: { + readonly _Message: Types.Contravariant; + readonly _Output: Types.Covariant; + }; + } + /** + * @since 2.0.0 + * @category models + */ + interface Options { + readonly fiberId: FiberId.FiberId; + readonly logLevel: LogLevel.LogLevel; + readonly message: Message; + readonly cause: Cause.Cause; + readonly context: FiberRefs.FiberRefs; + readonly spans: List.List; + readonly annotations: HashMap.HashMap; + readonly date: Date; + } +} +/** + * Creates a custom logger that formats log messages according to the provided + * function. + * + * @example + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const logger = Logger.make(({ logLevel, message }) => { + * globalThis.console.log(`[${logLevel.label}] ${message}`) + * }) + * + * const task1 = Effect.logDebug("task1 done") + * const task2 = Effect.logDebug("task2 done") + * + * const program = Effect.gen(function*() { + * yield* Effect.log("start") + * yield* task1 + * yield* task2 + * yield* Effect.log("done") + * }).pipe( + * Logger.withMinimumLogLevel(LogLevel.Debug), + * Effect.provide(Logger.replace(Logger.defaultLogger, logger)) + * ) + * + * Effect.runFork(program) + * // [INFO] start + * // [DEBUG] task1 done + * // [DEBUG] task2 done + * // [INFO] done + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const make: (log: (options: Logger.Options) => Output) => Logger; +/** + * @since 2.0.0 + * @category context + */ +export declare const add: (logger: Logger) => Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const addEffect: (effect: Effect, E, R>) => Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const addScoped: (effect: Effect, E, R>) => Layer.Layer>; +/** + * @since 2.0.0 + * @category mapping + */ +export declare const mapInput: { + /** + * @since 2.0.0 + * @category mapping + */ + (f: (message: Message2) => Message): (self: Logger) => Logger; + /** + * @since 2.0.0 + * @category mapping + */ + (self: Logger, f: (message: Message2) => Message): Logger; +}; +/** + * @since 2.0.0 + * @category mapping + */ +export declare const mapInputOptions: { + /** + * @since 2.0.0 + * @category mapping + */ + (f: (options: Logger.Options) => Logger.Options): (self: Logger) => Logger; + /** + * @since 2.0.0 + * @category mapping + */ + (self: Logger, f: (options: Logger.Options) => Logger.Options): Logger; +}; +/** + * Returns a version of this logger that only logs messages when the log level + * satisfies the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterLogLevel: { + /** + * Returns a version of this logger that only logs messages when the log level + * satisfies the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ + (f: (logLevel: LogLevel.LogLevel) => boolean): (self: Logger) => Logger>; + /** + * Returns a version of this logger that only logs messages when the log level + * satisfies the specified predicate. + * + * @since 2.0.0 + * @category filtering + */ + (self: Logger, f: (logLevel: LogLevel.LogLevel) => boolean): Logger>; +}; +/** + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * @since 2.0.0 + * @category mapping + */ + (f: (output: Output) => Output2): (self: Logger) => Logger; + /** + * @since 2.0.0 + * @category mapping + */ + (self: Logger, f: (output: Output) => Output2): Logger; +}; +/** + * Creates a batched logger that groups log messages together and processes them + * in intervals. + * + * @example + * ```ts + * import { Console, Effect, Logger } from "effect" + * + * const LoggerLive = Logger.replaceScoped( + * Logger.defaultLogger, + * Logger.logfmtLogger.pipe( + * Logger.batched("500 millis", (messages) => Console.log("BATCH", `[\n${messages.join("\n")}\n]`)) + * ) + * ) + * + * const program = Effect.gen(function*() { + * yield* Effect.log("one") + * yield* Effect.log("two") + * yield* Effect.log("three") + * }).pipe(Effect.provide(LoggerLive)) + * + * Effect.runFork(program) + * // BATCH [ + * // timestamp=... level=INFO fiber=#0 message=one + * // timestamp=... level=INFO fiber=#0 message=two + * // timestamp=... level=INFO fiber=#0 message=three + * // ] + * ``` + * + * @since 2.0.0 + * @category mapping + */ +export declare const batched: { + /** + * Creates a batched logger that groups log messages together and processes them + * in intervals. + * + * @example + * ```ts + * import { Console, Effect, Logger } from "effect" + * + * const LoggerLive = Logger.replaceScoped( + * Logger.defaultLogger, + * Logger.logfmtLogger.pipe( + * Logger.batched("500 millis", (messages) => Console.log("BATCH", `[\n${messages.join("\n")}\n]`)) + * ) + * ) + * + * const program = Effect.gen(function*() { + * yield* Effect.log("one") + * yield* Effect.log("two") + * yield* Effect.log("three") + * }).pipe(Effect.provide(LoggerLive)) + * + * Effect.runFork(program) + * // BATCH [ + * // timestamp=... level=INFO fiber=#0 message=one + * // timestamp=... level=INFO fiber=#0 message=two + * // timestamp=... level=INFO fiber=#0 message=three + * // ] + * ``` + * + * @since 2.0.0 + * @category mapping + */ + (window: DurationInput, f: (messages: Array>) => Effect): (self: Logger) => Effect, never, R | Scope>; + /** + * Creates a batched logger that groups log messages together and processes them + * in intervals. + * + * @example + * ```ts + * import { Console, Effect, Logger } from "effect" + * + * const LoggerLive = Logger.replaceScoped( + * Logger.defaultLogger, + * Logger.logfmtLogger.pipe( + * Logger.batched("500 millis", (messages) => Console.log("BATCH", `[\n${messages.join("\n")}\n]`)) + * ) + * ) + * + * const program = Effect.gen(function*() { + * yield* Effect.log("one") + * yield* Effect.log("two") + * yield* Effect.log("three") + * }).pipe(Effect.provide(LoggerLive)) + * + * Effect.runFork(program) + * // BATCH [ + * // timestamp=... level=INFO fiber=#0 message=one + * // timestamp=... level=INFO fiber=#0 message=two + * // timestamp=... level=INFO fiber=#0 message=three + * // ] + * ``` + * + * @since 2.0.0 + * @category mapping + */ + (self: Logger, window: DurationInput, f: (messages: Array>) => Effect): Effect, never, Scope | R>; +}; +/** + * @since 2.0.0 + * @category console + */ +export declare const withConsoleLog: (self: Logger) => Logger; +/** + * Takes a `Logger` and returns a logger that calls the respective `Console` method + * based on the log level. + * + * @example + * ```ts + * import { Logger, Effect } from "effect" + * + * const loggerLayer = Logger.replace( + * Logger.defaultLogger, + * Logger.withLeveledConsole(Logger.stringLogger), + * ) + * + * Effect.gen(function* () { + * yield* Effect.logError("an error") + * yield* Effect.logInfo("an info") + * }).pipe(Effect.provide(loggerLayer)) + * ``` + * + * @since 3.8.0 + * @category console + */ +export declare const withLeveledConsole: (self: Logger) => Logger; +/** + * @since 2.0.0 + * @category console + */ +export declare const withConsoleError: (self: Logger) => Logger; +/** + * A logger that does nothing in response to logging events. + * + * @since 2.0.0 + * @category constructors + */ +export declare const none: Logger; +/** + * @since 2.0.0 + * @category context + */ +export declare const remove: (logger: Logger) => Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const replace: { + /** + * @since 2.0.0 + * @category context + */ + (that: Logger): (self: Logger) => Layer.Layer; + /** + * @since 2.0.0 + * @category context + */ + (self: Logger, that: Logger): Layer.Layer; +}; +/** + * @since 2.0.0 + * @category context + */ +export declare const replaceEffect: { + /** + * @since 2.0.0 + * @category context + */ + (that: Effect, E, R>): (self: Logger) => Layer.Layer; + /** + * @since 2.0.0 + * @category context + */ + (self: Logger, that: Effect, E, R>): Layer.Layer; +}; +/** + * @since 2.0.0 + * @category context + */ +export declare const replaceScoped: { + /** + * @since 2.0.0 + * @category context + */ + (that: Effect, E, R>): (self: Logger) => Layer.Layer>; + /** + * @since 2.0.0 + * @category context + */ + (self: Logger, that: Effect, E, R>): Layer.Layer>; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const simple: (log: (a: A) => B) => Logger; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const succeed: (value: A) => Logger; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const sync: (evaluate: LazyArg) => Logger; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const test: { + /** + * @since 2.0.0 + * @category constructors + */ + (input: Message): (self: Logger) => Output; + /** + * @since 2.0.0 + * @category constructors + */ + (self: Logger, input: Message): Output; +}; +/** + * Sets the minimum log level for subsequent logging operations, allowing + * control over which log messages are displayed based on their severity. + * + * @example + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug)) + * + * Effect.runFork(program) + * // timestamp=... level=DEBUG fiber=#0 message=message1 + * ``` + * + * @since 2.0.0 + * @category context + */ +export declare const withMinimumLogLevel: { + /** + * Sets the minimum log level for subsequent logging operations, allowing + * control over which log messages are displayed based on their severity. + * + * @example + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug)) + * + * Effect.runFork(program) + * // timestamp=... level=DEBUG fiber=#0 message=message1 + * ``` + * + * @since 2.0.0 + * @category context + */ + (level: LogLevel.LogLevel): (self: Effect) => Effect; + /** + * Sets the minimum log level for subsequent logging operations, allowing + * control over which log messages are displayed based on their severity. + * + * @example + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug)) + * + * Effect.runFork(program) + * // timestamp=... level=DEBUG fiber=#0 message=message1 + * ``` + * + * @since 2.0.0 + * @category context + */ + (self: Effect, level: LogLevel.LogLevel): Effect; +}; +/** + * @since 2.0.0 + * @category tracing + */ +export declare const withSpanAnnotations: (self: Logger) => Logger; +/** + * Combines this logger with the specified logger to produce a new logger that + * logs to both this logger and that logger. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zip: { + /** + * Combines this logger with the specified logger to produce a new logger that + * logs to both this logger and that logger. + * + * @since 2.0.0 + * @category zipping + */ + (that: Logger): (self: Logger) => Logger; + /** + * Combines this logger with the specified logger to produce a new logger that + * logs to both this logger and that logger. + * + * @since 2.0.0 + * @category zipping + */ + (self: Logger, that: Logger): Logger; +}; +/** + * @since 2.0.0 + * @category zipping + */ +export declare const zipLeft: { + /** + * @since 2.0.0 + * @category zipping + */ + (that: Logger): (self: Logger) => Logger; + /** + * @since 2.0.0 + * @category zipping + */ + (self: Logger, that: Logger): Logger; +}; +/** + * @since 2.0.0 + * @category zipping + */ +export declare const zipRight: { + /** + * @since 2.0.0 + * @category zipping + */ + (that: Logger): (self: Logger) => Logger; + /** + * @since 2.0.0 + * @category zipping + */ + (self: Logger, that: Logger): Logger; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const defaultLogger: Logger; +/** + * The `jsonLogger` logger formats log entries as JSON objects, making them easy to + * integrate with logging systems that consume JSON data. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.json))) + * // {"message":["message1","message2"],"logLevel":"INFO","timestamp":"...","annotations":{"key2":"value2","key1":"value1"},"spans":{"myspan":0},"fiberId":"#0"} + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const jsonLogger: Logger; +/** + * This logger outputs logs in a human-readable format that is easy to read + * during development or in a production console. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.logFmt))) + * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 myspan=0ms key2=value2 key1=value1 + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const logfmtLogger: Logger; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const stringLogger: Logger; +/** + * The pretty logger utilizes the capabilities of the console API to generate + * visually engaging and color-enhanced log outputs. This feature is + * particularly useful for improving the readability of log messages during + * development and debugging processes. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.pretty))) + * // green --v v-- bold and cyan + * // [07:51:54.434] INFO (#0) myspan=1ms: message1 + * // message2 + * // v-- bold + * // key2: value2 + * // key1: value1 + * ``` + * + * @since 3.5.0 + * @category constructors + */ +export declare const prettyLogger: (options?: { + readonly colors?: "auto" | boolean | undefined; + readonly stderr?: boolean | undefined; + readonly formatDate?: ((date: Date) => string) | undefined; + readonly mode?: "browser" | "tty" | "auto" | undefined; +}) => Logger; +/** + * A default version of the pretty logger. + * + * @since 3.8.0 + * @category constructors + */ +export declare const prettyLoggerDefault: Logger; +/** + * The structured logger provides detailed log outputs, structured in a way that + * retains comprehensive traceability of the events, suitable for deeper + * analysis and troubleshooting. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.structured))) + * // { + * // message: [ 'message1', 'message2' ], + * // logLevel: 'INFO', + * // timestamp: '2024-07-09T14:05:41.623Z', + * // cause: undefined, + * // annotations: { key2: 'value2', key1: 'value1' }, + * // spans: { myspan: 0 }, + * // fiberId: '#0' + * // } + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const structuredLogger: Logger; + readonly spans: Record; +}>; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const tracerLogger: Logger; +/** + * The `json` logger formats log entries as JSON objects, making them easy to + * integrate with logging systems that consume JSON data. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.json))) + * // {"message":["message1","message2"],"logLevel":"INFO","timestamp":"...","annotations":{"key2":"value2","key1":"value1"},"spans":{"myspan":0},"fiberId":"#0"} + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const json: Layer.Layer; +/** + * This logger outputs logs in a human-readable format that is easy to read + * during development or in a production console. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.logFmt))) + * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 myspan=0ms key2=value2 key1=value1 + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const logFmt: Layer.Layer; +/** + * The pretty logger utilizes the capabilities of the console API to generate + * visually engaging and color-enhanced log outputs. This feature is + * particularly useful for improving the readability of log messages during + * development and debugging processes. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.pretty))) + * // green --v v-- bold and cyan + * // [07:51:54.434] INFO (#0) myspan=1ms: message1 + * // message2 + * // v-- bold + * // key2: value2 + * // key1: value1 + * ``` + * + * @since 3.5.0 + * @category constructors + */ +export declare const pretty: Layer.Layer; +/** + * The structured logger provides detailed log outputs, structured in a way that + * retains comprehensive traceability of the events, suitable for deeper + * analysis and troubleshooting. + * + * @example + * ```ts + * import { Effect, Logger } from "effect" + * + * const program = Effect.log("message1", "message2").pipe( + * Effect.annotateLogs({ key1: "value1", key2: "value2" }), + * Effect.withLogSpan("myspan") + * ) + * + * Effect.runFork(program.pipe(Effect.provide(Logger.structured))) + * // { + * // message: [ 'message1', 'message2' ], + * // logLevel: 'INFO', + * // timestamp: '2024-07-09T14:05:41.623Z', + * // cause: undefined, + * // annotations: { key2: 'value2', key1: 'value1' }, + * // spans: { myspan: 0 }, + * // fiberId: '#0' + * // } + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const structured: Layer.Layer; +/** + * Sets the minimum log level for logging operations, allowing control over + * which log messages are displayed based on their severity. + * + * @example + * ```ts + * import { Effect, Logger, LogLevel } from "effect" + * + * const program = Effect.gen(function*() { + * yield* Effect.log("Executing task...") + * yield* Effect.sleep("100 millis") + * console.log("task done") + * }) + * + * // Logging disabled using a layer + * Effect.runFork(program.pipe(Effect.provide(Logger.minimumLogLevel(LogLevel.None)))) + * // task done + * ``` + * + * @since 2.0.0 + * @category context + */ +export declare const minimumLogLevel: (level: LogLevel.LogLevel) => Layer.Layer; +/** + * Returns `true` if the specified value is a `Logger`, otherwise returns `false`. + * + * @since 1.0.0 + * @category guards + */ +export declare const isLogger: (u: unknown) => u is Logger; +//# sourceMappingURL=Logger.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Mailbox.d.ts.map b/backend/node_modules/effect/dist/dts/Mailbox.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..5f0422c4ba0e375d8c4f80e96a6aac1c7e831e71 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Mailbox.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Mailbox.d.ts","sourceRoot":"","sources":["../../src/Mailbox.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ManagedRuntime.d.ts b/backend/node_modules/effect/dist/dts/ManagedRuntime.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..02e2041896f860ded0bfb93f7de2eed8afe6474c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ManagedRuntime.d.ts @@ -0,0 +1,154 @@ +/** + * @since 2.0.0 + */ +import type * as Effect from "./Effect.js"; +import type * as Exit from "./Exit.js"; +import type * as Fiber from "./Fiber.js"; +import type * as Layer from "./Layer.js"; +import type * as Runtime from "./Runtime.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 3.9.0 + * @category symbol + */ +export declare const TypeId: unique symbol; +/** + * @since 3.9.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * Checks if the provided argument is a `ManagedRuntime`. + * + * @since 3.9.0 + * @category guards + */ +export declare const isManagedRuntime: (input: unknown) => input is ManagedRuntime; +/** + * @since 3.4.0 + */ +export declare namespace ManagedRuntime { + /** + * @category type-level + * @since 3.4.0 + */ + type Context> = [T] extends [ManagedRuntime] ? R : never; + /** + * @category type-level + * @since 3.4.0 + */ + type Error> = [T] extends [ManagedRuntime] ? E : never; +} +/** + * @since 2.0.0 + * @category models + */ +export interface ManagedRuntime extends Effect.Effect, ER> { + readonly [TypeId]: TypeId; + readonly memoMap: Layer.MemoMap; + readonly runtimeEffect: Effect.Effect, ER>; + readonly runtime: () => Promise>; + /** + * Executes the effect using the provided Scheduler or using the global + * Scheduler if not provided + */ + readonly runFork: (self: Effect.Effect, options?: Runtime.RunForkOptions) => Fiber.RuntimeFiber; + /** + * Executes the effect synchronously returning the exit. + * + * This method is effectful and should only be invoked at the edges of your + * program. + */ + readonly runSyncExit: (effect: Effect.Effect) => Exit.Exit; + /** + * Executes the effect synchronously throwing in case of errors or async boundaries. + * + * This method is effectful and should only be invoked at the edges of your + * program. + */ + readonly runSync: (effect: Effect.Effect) => A; + /** + * Executes the effect asynchronously, eventually passing the exit value to + * the specified callback. + * + * This method is effectful and should only be invoked at the edges of your + * program. + */ + readonly runCallback: (effect: Effect.Effect, options?: Runtime.RunCallbackOptions | undefined) => Runtime.Cancel; + /** + * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved + * with the value of the effect once the effect has been executed, or will be + * rejected with the first error or exception throw by the effect. + * + * This method is effectful and should only be used at the edges of your + * program. + */ + readonly runPromise: (effect: Effect.Effect, options?: { + readonly signal?: AbortSignal | undefined; + }) => Promise; + /** + * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved + * with the `Exit` state of the effect once the effect has been executed. + * + * This method is effectful and should only be used at the edges of your + * program. + */ + readonly runPromiseExit: (effect: Effect.Effect, options?: { + readonly signal?: AbortSignal | undefined; + }) => Promise>; + /** + * Dispose of the resources associated with the runtime. + */ + readonly dispose: () => Promise; + /** + * Dispose of the resources associated with the runtime. + */ + readonly disposeEffect: Effect.Effect; + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: ManagedRuntimeUnify; + readonly [Unify.ignoreSymbol]?: ManagedRuntimeUnifyIgnore; +} +/** + * @category models + * @since 3.9.0 + */ +export interface ManagedRuntimeUnify extends Effect.EffectUnify { + ManagedRuntime?: () => Extract>; +} +/** + * @category models + * @since 3.9.0 + */ +export interface ManagedRuntimeUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * Convert a Layer into an ManagedRuntime, that can be used to run Effect's using + * your services. + * + * @since 2.0.0 + * @category runtime class + * @example + * ```ts + * import { Console, Effect, Layer, ManagedRuntime } from "effect" + * + * class Notifications extends Effect.Tag("Notifications")< + * Notifications, + * { readonly notify: (message: string) => Effect.Effect } + * >() { + * static Live = Layer.succeed(this, { notify: (message) => Console.log(message) }) + * } + * + * async function main() { + * const runtime = ManagedRuntime.make(Notifications.Live) + * await runtime.runPromise(Notifications.notify("Hello, world!")) + * await runtime.dispose() + * } + * + * main() + * ``` + */ +export declare const make: (layer: Layer.Layer, memoMap?: Layer.MemoMap | undefined) => ManagedRuntime; +//# sourceMappingURL=ManagedRuntime.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Match.d.ts b/backend/node_modules/effect/dist/dts/Match.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3f7e9d2ef7076ec7c6e5acbe7853b0e3b4ce543f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Match.d.ts @@ -0,0 +1,1140 @@ +/** + * The `effect/match` module provides a type-safe pattern matching system for + * TypeScript. Inspired by functional programming, it simplifies conditional + * logic by replacing verbose if/else or switch statements with a structured and + * expressive API. + * + * This module supports matching against types, values, and discriminated unions + * while enforcing exhaustiveness checking to ensure all cases are handled. + * + * Although pattern matching is not yet a native JavaScript feature, + * `effect/match` offers a reliable implementation that is available today. + * + * **How Pattern Matching Works** + * + * Pattern matching follows a structured process: + * + * - **Creating a matcher**: Define a `Matcher` that operates on either a + * specific `Match.type` or `Match.value`. + * + * - **Defining patterns**: Use combinators such as `Match.when`, `Match.not`, + * and `Match.tag` to specify matching conditions. + * + * - **Completing the match**: Apply a finalizer such as `Match.exhaustive`, + * `Match.orElse`, or `Match.option` to determine how unmatched cases should + * be handled. + * + * @since 1.0.0 + */ +import type * as Either from "./Either.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import * as Predicate from "./Predicate.js"; +import type * as T from "./Types.js"; +import type { Unify } from "./Unify.js"; +/** + * @category Symbols + * @since 1.0.0 + */ +export declare const MatcherTypeId: unique symbol; +/** + * @category Symbols + * @since 1.0.0 + */ +export type MatcherTypeId = typeof MatcherTypeId; +/** + * Pattern matching follows a structured process: + * + * - **Creating a matcher**: Define a `Matcher` that operates on either a + * specific `Match.type` or `Match.value`. + * + * - **Defining patterns**: Use combinators such as `Match.when`, `Match.not`, + * and `Match.tag` to specify matching conditions. + * + * - **Completing the match**: Apply a finalizer such as `Match.exhaustive`, + * `Match.orElse`, or `Match.option` to determine how unmatched cases should + * be handled. + * + * @example + * ```ts + * import { Match } from "effect" + * + * // Simulated dynamic input that can be a string or a number + * const input: string | number = "some input" + * + * // ┌─── string + * // ▼ + * const result = Match.value(input).pipe( + * // Match if the value is a number + * Match.when(Match.number, (n) => `number: ${n}`), + * // Match if the value is a string + * Match.when(Match.string, (s) => `string: ${s}`), + * // Ensure all possible cases are covered + * Match.exhaustive + * ) + * + * console.log(result) + * // Output: "string: some input" + * ``` + * + * @category Model + * @since 1.0.0 + */ +export type Matcher = TypeMatcher | ValueMatcher; +/** + * @category Model + * @since 1.0.0 + */ +export interface TypeMatcher extends Pipeable { + readonly _tag: "TypeMatcher"; + readonly [MatcherTypeId]: { + readonly _input: T.Contravariant; + readonly _filters: T.Covariant; + readonly _remaining: T.Covariant; + readonly _result: T.Covariant; + readonly _return: T.Covariant; + }; + readonly cases: ReadonlyArray; + add(_case: Case): TypeMatcher; +} +/** + * @category Model + * @since 1.0.0 + */ +export interface ValueMatcher extends Pipeable { + readonly _tag: "ValueMatcher"; + readonly [MatcherTypeId]: { + readonly _input: T.Contravariant; + readonly _filters: T.Covariant; + readonly _remaining: T.Covariant; + readonly _result: T.Covariant; + readonly _provided: T.Covariant; + readonly _return: T.Covariant; + }; + readonly provided: Provided; + readonly value: Either.Either; + add(_case: Case): ValueMatcher; +} +/** + * @category Model + * @since 1.0.0 + */ +export type Case = When | Not; +/** + * @category Model + * @since 1.0.0 + */ +export interface When { + readonly _tag: "When"; + guard(u: unknown): boolean; + evaluate(input: unknown): any; +} +/** + * @category Model + * @since 1.0.0 + */ +export interface Not { + readonly _tag: "Not"; + guard(u: unknown): boolean; + evaluate(input: unknown): any; +} +/** + * Creates a matcher for a specific type. + * + * **Details** + * + * This function defines a `Matcher` that operates on a given type, allowing you + * to specify conditions for handling different cases. Once the matcher is + * created, you can use pattern-matching functions like {@link when} to define + * how different values should be processed. + * + * **Example** (Matching Numbers and Strings) + * + * ```ts + * import { Match } from "effect" + * + * // Create a matcher for values that are either strings or numbers + * // + * // ┌─── (u: string | number) => string + * // ▼ + * const match = Match.type().pipe( + * // Match when the value is a number + * Match.when(Match.number, (n) => `number: ${n}`), + * // Match when the value is a string + * Match.when(Match.string, (s) => `string: ${s}`), + * // Ensure all possible cases are handled + * Match.exhaustive + * ) + * + * console.log(match(0)) + * // Output: "number: 0" + * + * console.log(match("hello")) + * // Output: "string: hello" + * ``` + * + * @see {@link value} for creating a matcher from a specific value. + * + * @category Creating a matcher + * @since 1.0.0 + */ +export declare const type: () => Matcher, I, never, never>; +/** + * Creates a matcher from a specific value. + * + * **Details** + * + * This function allows you to define a `Matcher` directly from a given value, + * rather than from a type. This is useful when working with known values, + * enabling structured pattern matching on objects, primitives, or any data + * structure. + * + * Once the matcher is created, you can use pattern-matching functions like + * {@link when} to define how different cases should be handled. + * + * **Example** (Matching an Object by Property) + * + * ```ts + * import { Match } from "effect" + * + * const input = { name: "John", age: 30 } + * + * // Create a matcher for the specific object + * const result = Match.value(input).pipe( + * // Match when the 'name' property is "John" + * Match.when( + * { name: "John" }, + * (user) => `${user.name} is ${user.age} years old` + * ), + * // Provide a fallback if no match is found + * Match.orElse(() => "Oh, not John") + * ) + * + * console.log(result) + * // Output: "John is 30 years old" + * ``` + * + * @see {@link type} for creating a matcher from a specific type. + * + * @category Creating a matcher + * @since 1.0.0 + */ +export declare const value: (i: I) => Matcher, I, never, I>; +/** + * @category Creating a matcher + * @since 1.0.0 + */ +export declare const valueTags: { + /** + * @category Creating a matcher + * @since 1.0.0 + */ + & string]: (_: Extract) => any; + } & { + readonly [Tag in Exclude>]: never; + }>(fields: P): (input: I) => Unify>; + /** + * @category Creating a matcher + * @since 1.0.0 + */ + & string]: (_: Extract) => any; + } & { + readonly [Tag in Exclude>]: never; + }>(input: I, fields: P): Unify>; +}; +/** + * @category Creating a matcher + * @since 1.0.0 + */ +export declare const typeTags: { + /** + * @category Creating a matcher + * @since 1.0.0 + */ + ():

& string]: (_: Extract) => Ret; + } & { + readonly [Tag in Exclude>]: never; + }>(fields: P) => (input: I) => Ret; + /** + * @category Creating a matcher + * @since 1.0.0 + */ + ():

& string]: (_: Extract) => any; + } & { + readonly [Tag in Exclude>]: never; + }>(fields: P) => (input: I) => Unify>; +}; +/** + * Ensures that all branches of a matcher return a specific type. + * + * **Details** + * + * This function enforces a consistent return type across all pattern-matching + * branches. By specifying a return type, TypeScript will check that every + * matching condition produces a value of the expected type. + * + * **Important:** This function must be the first step in the matcher pipeline. + * If used later, TypeScript will not enforce type consistency correctly. + * + * **Example** (Validating Return Type Consistency) + * + * ```ts + * import { Match } from "effect" + * + * const match = Match.type<{ a: number } | { b: string }>().pipe( + * // Ensure all branches return a string + * Match.withReturnType(), + * // ❌ Type error: 'number' is not assignable to type 'string' + * // @ts-expect-error + * Match.when({ a: Match.number }, (_) => _.a), + * // ✅ Correct: returns a string + * Match.when({ b: Match.string }, (_) => _.b), + * Match.exhaustive + * ) + * ``` + * + * @since 1.0.0 + */ +export declare const withReturnType: () => (self: Matcher) => [Ret] extends [[A] extends [never] ? any : A] ? Matcher : "withReturnType constraint does not extend Result type"; +/** + * Defines a condition for matching values. + * + * **Details** + * + * This function enables pattern matching by checking whether a given value + * satisfies a condition. It supports both direct value comparisons and + * predicate functions. If the condition is met, the associated function is + * executed. + * + * This function is useful when defining matchers that need to check for + * specific values or apply logical conditions to determine a match. It works + * well with structured objects and primitive types. + * + * **Example** (Matching with Values and Predicates) + * + * ```ts + * import { Match } from "effect" + * + * // Create a matcher for objects with an "age" property + * const match = Match.type<{ age: number }>().pipe( + * // Match when age is greater than 18 + * Match.when({ age: (age) => age > 18 }, (user) => `Age: ${user.age}`), + * // Match when age is exactly 18 + * Match.when({ age: 18 }, () => "You can vote"), + * // Fallback case for all other ages + * Match.orElse((user) => `${user.age} is too young`) + * ) + * + * console.log(match({ age: 20 })) + * // Output: "Age: 20" + * + * console.log(match({ age: 18 })) + * // Output: "You can vote" + * + * console.log(match({ age: 4 })) + * // Output: "4 is too young" + * ``` + * + * @see {@link whenOr} Use this when multiple patterns should match in a single + * condition. + * @see {@link whenAnd} Use this when a value must match all provided patterns. + * @see {@link orElse} Provides a fallback when no patterns match. + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const when: | Types.PatternBase, Ret, Fn extends (_: Types.WhenMatch) => Ret>(pattern: P, f: Fn) => (self: Matcher) => Matcher>, Types.ApplyFilters>>, A | ReturnType, Pr, Ret>; +/** + * Matches one of multiple patterns in a single condition. + * + * **Details** + * + * This function allows defining a condition where a value matches any of the + * provided patterns. If a match is found, the associated function is executed. + * It simplifies cases where multiple patterns share the same handling logic. + * + * Unlike {@link when}, which requires separate conditions for each pattern, + * this function enables combining them into a single statement, making the + * matcher more concise. + * + * @example + * ```ts + * import { Match } from "effect" + * + * type ErrorType = + * | { readonly _tag: "NetworkError"; readonly message: string } + * | { readonly _tag: "TimeoutError"; readonly duration: number } + * | { readonly _tag: "ValidationError"; readonly field: string } + * + * const handleError = Match.type().pipe( + * Match.whenOr( + * { _tag: "NetworkError" }, + * { _tag: "TimeoutError" }, + * () => "Retry the request" + * ), + * Match.when({ _tag: "ValidationError" }, (_) => `Invalid field: ${_.field}`), + * Match.exhaustive + * ) + * + * console.log(handleError({ _tag: "NetworkError", message: "No connection" })) + * // Output: "Retry the request" + * + * console.log(handleError({ _tag: "ValidationError", field: "email" })) + * // Output: "Invalid field: email" + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const whenOr: | Types.PatternBase>, Ret, Fn extends (_: Types.WhenMatch) => Ret>(...args: [...patterns: P, f: Fn]) => (self: Matcher) => Matcher>, Types.ApplyFilters>>, A | ReturnType, Pr, Ret>; +/** + * Matches a value that satisfies all provided patterns. + * + * **Details** + * + * This function allows defining a condition where a value must match all the + * given patterns simultaneously. If the value satisfies every pattern, the + * associated function is executed. + * + * Unlike {@link when}, which matches a single pattern at a time, this function + * ensures that multiple conditions are met before executing the callback. It is + * useful when checking for values that need to fulfill multiple criteria at + * once. + * + * @example + * ```ts + * import { Match } from "effect" + * + * type User = { readonly age: number; readonly role: "admin" | "user" } + * + * const checkUser = Match.type().pipe( + * Match.whenAnd( + * { age: (n) => n >= 18 }, + * { role: "admin" }, + * () => "Admin access granted" + * ), + * Match.orElse(() => "Access denied") + * ) + * + * console.log(checkUser({ age: 20, role: "admin" })) + * // Output: "Admin access granted" + * + * console.log(checkUser({ age: 20, role: "user" })) + * // Output: "Access denied" + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const whenAnd: | Types.PatternBase>, Ret, Fn extends (_: Types.WhenMatch>) => Ret>(...args: [...patterns: P, f: Fn]) => (self: Matcher) => Matcher>>, Types.ApplyFilters>>>, A | ReturnType, Pr>; +/** + * Matches values based on a specified discriminant field. + * + * **Details** + * + * This function is used to define pattern matching on objects that follow a + * **discriminated union** structure, where a specific field (e.g., `type`, + * `kind`, `_tag`) determines the variant of the object. It allows matching + * multiple values of the discriminant and provides a function to handle the + * matched cases. + * + * @example + * ```ts + * import { Match, pipe } from "effect" + * + * const match = pipe( + * Match.type<{ type: "A"; a: string } | { type: "B"; b: number } | { type: "C"; c: boolean }>(), + * Match.discriminator("type")("A", "B", (_) => `A or B: ${_.type}`), + * Match.discriminator("type")("C", (_) => `C(${_.c})`), + * Match.exhaustive + * ) + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const discriminator: (field: D) => & string, Ret, Fn extends (_: Extract>) => Ret>(...pattern: [first: P, ...values: Array

, f: Fn]) => (self: Matcher) => Matcher>>, Types.ApplyFilters>>>, ReturnType | A, Pr, Ret>; +/** + * Matches values where the `_tag` field starts with a given prefix. + * + * **Details** + * + * This function allows you to match on values in a **discriminated union** + * based on whether the `_tag` field starts with a specified prefix. It is + * useful for handling hierarchical or namespaced tags, where multiple related + * cases share a common prefix. + * + * @example + * ```ts + * import { Match, pipe } from "effect" + * + * const match = pipe( + * Match.type<{ _tag: "A" } | { _tag: "B" } | { _tag: "A.A" } | {}>(), + * Match.tagStartsWith("A", (_) => 1 as const), + * Match.tagStartsWith("B", (_) => 2 as const), + * Match.orElse((_) => 3 as const) + * ) + * + * console.log(match({ _tag: "A" })) // 1 + * console.log(match({ _tag: "B" })) // 2 + * console.log(match({ _tag: "A.A" })) // 1 + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const tagStartsWith: >) => Ret>(pattern: P, f: Fn) => (self: Matcher) => Matcher>>, Types.ApplyFilters>>>, ReturnType | A, Pr, Ret>; +/** + * Matches values based on their `_tag` field, mapping each tag to a + * corresponding handler. + * + * **Details** + * + * This function provides a way to handle discriminated unions by mapping `_tag` + * values to specific functions. Each handler receives the matched value and + * returns a transformed result. If all possible tags are handled, you can + * enforce exhaustiveness using `Match.exhaustive` to ensure no case is missed. + * + * @example + * ```ts + * import { Match, pipe } from "effect" + * + * const match = pipe( + * Match.type<{ _tag: "A"; a: string } | { _tag: "B"; b: number } | { _tag: "C"; c: boolean }>(), + * Match.tags({ + * A: (a) => a.a, + * B: (b) => b.b, + * C: (c) => c.c + * }), + * Match.exhaustive + * ) + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const tags: & string]?: ((_: Extract>) => Ret) | undefined; +} & { + readonly [Tag in Exclude>]: never; +}>(fields: P) => (self: Matcher) => Matcher>>, Types.ApplyFilters>>>, A | ReturnType, Pr, Ret>; +/** + * Matches values based on their `_tag` field and requires handling of all + * possible cases. + * + * **Details** + * + * This function is designed for **discriminated unions** where every possible + * `_tag` value must have a corresponding handler. Unlike {@link tags}, this + * function ensures **exhaustiveness**, meaning all cases must be explicitly + * handled. If a `_tag` value is missing from the mapping, TypeScript will + * report an error. + * + * @example + * ```ts + * import { Match, pipe } from "effect" + * + * const match = pipe( + * Match.type<{ _tag: "A"; a: string } | { _tag: "B"; b: number } | { _tag: "C"; c: boolean }>(), + * Match.tagsExhaustive({ + * A: (a) => a.a, + * B: (b) => b.b, + * C: (c) => c.c + * }) + * ) + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const tagsExhaustive: & string]: (_: Extract>) => Ret; +} & { + readonly [Tag in Exclude>]: never; +}>(fields: P) => (self: Matcher) => [Pr] extends [never] ? (u: I) => Unify> : Unify>; +/** + * Excludes a specific value from matching while allowing all others. + * + * **Details** + * + * This function is useful when you need to **handle all values except one or + * more specific cases**. Instead of listing all possible matches manually, this + * function simplifies the logic by allowing you to specify values to exclude. + * Any excluded value will bypass the provided function and continue matching + * through other cases. + * + * **Example** (Ignoring a Specific Value) + * + * ```ts + * import { Match } from "effect" + * + * // Create a matcher for string or number values + * const match = Match.type().pipe( + * // Match any value except "hi", returning "ok" + * Match.not("hi", () => "ok"), + * // Fallback case for when the value is "hi" + * Match.orElse(() => "fallback") + * ) + * + * console.log(match("hello")) + * // Output: "ok" + * + * console.log(match("hi")) + * // Output: "fallback" + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const not: | Types.PatternBase, Ret, Fn extends (_: Types.NotMatch) => Ret>(pattern: P, f: Fn) => (self: Matcher) => Matcher>, Types.ApplyFilters>>, A | ReturnType, Pr, Ret>; +/** + * Matches non-empty strings. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const nonEmptyString: SafeRefinement; +/** + * Matches a specific set of literal values (e.g., `Match.is("a", 42, true)`). + * + * @category Predicates + * @since 1.0.0 + */ +export declare const is: >(...literals: Literals) => SafeRefinement; +/** + * Matches values of type `string`. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const string: Predicate.Refinement; +/** + * Matches values of type `number`. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const number: Predicate.Refinement; +/** + * Matches any value without restrictions. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const any: SafeRefinement; +/** + * Matches any defined (non-null and non-undefined) value. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const defined: (u: A) => u is A & {}; +/** + * Matches values of type `boolean`. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const boolean: Predicate.Refinement; +declare const _undefined: Predicate.Refinement; +export { +/** + * Matches the value `undefined`. + * + * @category Predicates + * @since 1.0.0 + */ +_undefined as undefined }; +declare const _null: Predicate.Refinement; +export { +/** + * Matches the value `null`. + * + * @category Predicates + * @since 1.0.0 + */ +_null as null }; +/** + * Matches values of type `bigint`. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const bigint: Predicate.Refinement; +/** + * Matches values of type `symbol`. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const symbol: Predicate.Refinement; +/** + * Matches values that are instances of `Date`. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const date: Predicate.Refinement; +/** + * Matches objects where keys are `string` or `symbol` and values are `unknown`. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const record: Predicate.Refinement; +/** + * Matches instances of a given class. + * + * @category Predicates + * @since 1.0.0 + */ +export declare const instanceOf: any>(constructor: A) => SafeRefinement, never>; +/** + * @category Predicates + * @since 1.0.0 + */ +export declare const instanceOfUnsafe: any>(constructor: A) => SafeRefinement, InstanceType>; +/** + * Provides a fallback value when no patterns match. + * + * **Details** + * + * This function ensures that a matcher always returns a valid result, even if + * no defined patterns match. It acts as a default case, similar to the + * `default` clause in a `switch` statement or the final `else` in an `if-else` + * chain. + * + * **Example** (Providing a Default Value When No Patterns Match) + * + * ```ts + * import { Match } from "effect" + * + * // Create a matcher for string or number values + * const match = Match.type().pipe( + * // Match when the value is "a" + * Match.when("a", () => "ok"), + * // Fallback when no patterns match + * Match.orElse(() => "fallback") + * ) + * + * console.log(match("a")) + * // Output: "ok" + * + * console.log(match("b")) + * // Output: "fallback" + * ``` + * + * @category Completion + * @since 1.0.0 + */ +export declare const orElse: Ret>(f: F) => (self: Matcher) => [Pr] extends [never] ? (input: I) => Unify | A> : Unify | A>; +/** + * Throws an error if no pattern matches. + * + * **Details** + * + * This function finalizes a matcher by ensuring that if no patterns match, an + * error is thrown. It is useful when all cases should be covered, and any + * unexpected input should trigger an error instead of returning a default + * value. + * + * When used, this function removes the need for an explicit fallback case and + * ensures that an unmatched value is never silently ignored. + * + * @category Completion + * @since 1.0.0 + */ +export declare const orElseAbsurd: (self: Matcher) => [Pr] extends [never] ? (input: I) => Unify : Unify; +/** + * Wraps the match result in an `Either`, distinguishing matched and unmatched + * cases. + * + * **Details** + * + * This function ensures that the result of a matcher is always wrapped in an + * `Either`, allowing clear differentiation between successful matches + * (`Right(value)`) and cases where no pattern matched (`Left(unmatched + * value)`). + * + * This approach is particularly useful when handling optional values or when an + * unmatched case should be explicitly handled rather than returning a default + * value or throwing an error. + * + * **Example** (Extracting a User Role with `Match.either`) + * + * ```ts + * import { Match } from "effect" + * + * type User = { readonly role: "admin" | "editor" | "viewer" } + * + * // Create a matcher to extract user roles + * const getRole = Match.type().pipe( + * Match.when({ role: "admin" }, () => "Has full access"), + * Match.when({ role: "editor" }, () => "Can edit content"), + * Match.either // Wrap the result in an Either + * ) + * + * console.log(getRole({ role: "admin" })) + * // Output: { _id: 'Either', _tag: 'Right', right: 'Has full access' } + * + * console.log(getRole({ role: "viewer" })) + * // Output: { _id: 'Either', _tag: 'Left', left: { role: 'viewer' } } + * ``` + * + * @category Completion + * @since 1.0.0 + */ +export declare const either: (self: Matcher) => [Pr] extends [never] ? (input: I) => Either.Either, R> : Either.Either, R>; +/** + * Wraps the match result in an `Option`, representing an optional match. + * + * **Details** + * + * This function ensures that the result of a matcher is wrapped in an `Option`, + * making it easy to handle cases where no pattern matches. If a match is found, + * it returns `Some(value)`, otherwise, it returns `None`. + * + * This is useful in cases where a missing match is expected and should be + * handled explicitly rather than throwing an error or returning a default + * value. + * + * **Example** (Extracting a User Role with `Match.option`) + * + * ```ts + * import { Match } from "effect" + * + * type User = { readonly role: "admin" | "editor" | "viewer" } + * + * // Create a matcher to extract user roles + * const getRole = Match.type().pipe( + * Match.when({ role: "admin" }, () => "Has full access"), + * Match.when({ role: "editor" }, () => "Can edit content"), + * Match.option // Wrap the result in an Option + * ) + * + * console.log(getRole({ role: "admin" })) + * // Output: { _id: 'Option', _tag: 'Some', value: 'Has full access' } + * + * console.log(getRole({ role: "viewer" })) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Completion + * @since 1.0.0 + */ +export declare const option: (self: Matcher) => [Pr] extends [never] ? (input: I) => Option.Option> : Option.Option>; +/** + * The `Match.exhaustive` method finalizes the pattern matching process by + * ensuring that all possible cases are accounted for. If any case is missing, + * TypeScript will produce a type error. This is particularly useful when + * working with unions, as it helps prevent unintended gaps in pattern matching. + * + * **Example** (Ensuring All Cases Are Covered) + * + * ```ts + * import { Match } from "effect" + * + * // Create a matcher for string or number values + * const match = Match.type().pipe( + * // Match when the value is a number + * Match.when(Match.number, (n) => `number: ${n}`), + * // Mark the match as exhaustive, ensuring all cases are handled + * // TypeScript will throw an error if any case is missing + * // @ts-expect-error Type 'string' is not assignable to type 'never' + * Match.exhaustive + * ) + * ``` + * + * @category Completion + * @since 1.0.0 + */ +export declare const exhaustive: (self: Matcher) => [Pr] extends [never] ? (u: I) => Unify : Unify; +/** + * @since 1.0.0 + * @category Symbols + */ +export declare const SafeRefinementId: unique symbol; +/** + * @since 1.0.0 + * @category Symbols + */ +export type SafeRefinementId = typeof SafeRefinementId; +/** + * @category Model + * @since 1.0.0 + */ +export interface SafeRefinement { + readonly [SafeRefinementId]: (a: A) => R; +} +declare const Fail: unique symbol; +type Fail = typeof Fail; +/** + * @since 1.0.0 + */ +export declare namespace Types { + /** + * @since 1.0.0 + */ + type WhenMatch = [ + 0 + ] extends [1 & R] ? ResolvePred

: P extends SafeRefinement ? SP : P extends Predicate.Refinement ? [Extract] extends [infer X] ? [X] extends [never] ? RP : X : never : P extends PredicateA ? PP : ExtractMatch; + /** + * @since 1.0.0 + */ + type NotMatch = Exclude>>; + type PForNotMatch

= [ToInvertedRefinement

] extends [infer X] ? X : never; + /** + * @since 1.0.0 + */ + type PForMatch

= [ResolvePred

] extends [infer X] ? X : never; + /** + * @since 1.0.0 + */ + type PForExclude

= [SafeRefinementR>] extends [infer X] ? X : never; + type PredicateA = Predicate.Predicate | Predicate.Refinement; + type SafeRefinementR = A extends never ? never : A extends SafeRefinement ? R : A extends Function ? A : A extends Record ? { + [K in keyof A]: SafeRefinementR; + } : A; + type ResolvePred = A extends never ? never : A extends SafeRefinement ? _A : A extends Predicate.Refinement ? P : A extends Predicate.Predicate ? P : A extends Record ? { + [K in keyof A]: ResolvePred; + } : A; + type ToSafeRefinement = A extends never ? never : A extends Predicate.Refinement ? SafeRefinement : A extends Predicate.Predicate ? SafeRefinement : A extends SafeRefinement ? A : A extends Record ? { + [K in keyof A]: ToSafeRefinement; + } : NonLiteralsTo; + type ToInvertedRefinement = A extends never ? never : A extends Predicate.Refinement ? SafeRefinement

: A extends Predicate.Predicate ? SafeRefinement : A extends SafeRefinement ? SafeRefinement<_R> : A extends Record ? { + [K in keyof A]: ToInvertedRefinement; + } : NonLiteralsTo; + type NonLiteralsTo = [A] extends [string | number | boolean | bigint] ? [string] extends [A] ? T : [number] extends [A] ? T : [boolean] extends [A] ? T : [bigint] extends [A] ? T : A : A; + /** + * @since 1.0.0 + */ + type PatternBase = A extends ReadonlyArray ? ReadonlyArray | PatternPrimitive : A extends Record ? Partial<{ + [K in keyof A]: PatternPrimitive | PatternBase; + }> : never; + /** + * @since 1.0.0 + */ + type PatternPrimitive = PredicateA | A | SafeRefinement; + /** + * @since 1.0.0 + */ + interface Without { + readonly _tag: "Without"; + readonly _X: X; + } + /** + * @since 1.0.0 + */ + interface Only { + readonly _tag: "Only"; + readonly _X: X; + } + /** + * @since 1.0.0 + */ + type AddWithout = [A] extends [Without] ? Without : [A] extends [Only] ? Only> : never; + /** + * @since 1.0.0 + */ + type AddOnly = [A] extends [Without] ? [X] extends [WX] ? never : Only : [A] extends [Only] ? [X] extends [OX] ? Only : never : never; + /** + * @since 1.0.0 + */ + type ApplyFilters = A extends Only ? X : A extends Without ? Exclude : never; + /** + * @since 1.0.0 + */ + type Tags = P extends Record ? X : never; + /** + * @since 1.0.0 + */ + type ArrayToIntersection> = T.UnionToIntersection; + /** + * @since 1.0.0 + */ + type ExtractMatch = [ExtractAndNarrow] extends [infer EI] ? EI : never; + type Replace = A extends Function ? A : A extends Record ? { + [K in keyof A]: K extends keyof B ? Replace : A[K]; + } : [B] extends [A] ? B : A; + type MaybeReplace = [P] extends [I] ? P : [I] extends [P] ? Replace : Fail; + type BuiltInObjects = Function | Date | RegExp | Generator | { + readonly [Symbol.toStringTag]: string; + }; + type IsPlainObject = T extends BuiltInObjects ? false : T extends Record ? true : false; + type Simplify = { + [K in keyof A]: A[K]; + } & {}; + type ExtractAndNarrow = P extends Predicate.Refinement ? _Out extends Input ? Extract<_Out, Input> : Extract : P extends SafeRefinement ? [0] extends [1 & _R] ? Input : _In extends Input ? Extract<_In, Input> : Extract : P extends Predicate.Predicate ? Extract : Input extends infer I ? Exclude ? P extends ReadonlyArray ? { + readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow : I[K]; + } extends infer R ? Fail extends R[keyof R] ? never : R : never : never : IsPlainObject extends true ? string extends keyof I ? I extends P ? I : never : symbol extends keyof I ? I extends P ? I : never : Simplify<{ + [RK in Extract]-?: ExtractAndNarrow; + } & Omit> extends infer R ? keyof P extends NonFailKeys ? R : never : never : MaybeReplace extends infer R ? [I] extends [R] ? I : R : never, Fail> : never; + type NonFailKeys = keyof A & {} extends infer K ? K extends keyof A ? A[K] extends Fail ? never : K : never : never; +} +//# sourceMappingURL=Match.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Match.d.ts.map b/backend/node_modules/effect/dist/dts/Match.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..a9756e5615d4aed66aed66b16eb216e76dda89fe --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Match.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Match.d.ts","sourceRoot":"","sources":["../../src/Match.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MergeDecision.d.ts b/backend/node_modules/effect/dist/dts/MergeDecision.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..64ad60a722aedf2d250b854939b7b6d3c5d00437 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MergeDecision.d.ts @@ -0,0 +1,86 @@ +/** + * @since 2.0.0 + */ +import type * as Effect from "./Effect.js"; +import type * as Exit from "./Exit.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MergeDecisionTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MergeDecisionTypeId = typeof MergeDecisionTypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface MergeDecision extends MergeDecision.Variance { +} +/** + * @since 2.0.0 + */ +export declare namespace MergeDecision { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [MergeDecisionTypeId]: { + _R: Types.Covariant; + _E0: Types.Contravariant; + _Z0: Types.Contravariant; + _E: Types.Covariant; + _Z: Types.Covariant; + }; + } +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Done: (effect: Effect.Effect) => MergeDecision; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const Await: (f: (exit: Exit.Exit) => Effect.Effect) => MergeDecision; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const AwaitConst: (effect: Effect.Effect) => MergeDecision; +/** + * Returns `true` if the specified value is a `MergeDecision`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isMergeDecision: (u: unknown) => u is MergeDecision; +/** + * @since 2.0.0 + * @category folding + */ +export declare const match: { + /** + * @since 2.0.0 + * @category folding + */ + (options: { + readonly onDone: (effect: Effect.Effect) => Z2; + readonly onAwait: (f: (exit: Exit.Exit) => Effect.Effect) => Z2; + }): (self: MergeDecision) => Z2; + /** + * @since 2.0.0 + * @category folding + */ + (self: MergeDecision, options: { + readonly onDone: (effect: Effect.Effect) => Z2; + readonly onAwait: (f: (exit: Exit.Exit) => Effect.Effect) => Z2; + }): Z2; +}; +//# sourceMappingURL=MergeDecision.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MergeDecision.d.ts.map b/backend/node_modules/effect/dist/dts/MergeDecision.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..94228262784edeb9afe77cd21bcc30685c10518d --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MergeDecision.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MergeDecision.d.ts","sourceRoot":"","sources":["../../src/MergeDecision.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MergeState.d.ts b/backend/node_modules/effect/dist/dts/MergeState.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c72a900c130e660a41e618090a1041164c5bafc4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MergeState.d.ts @@ -0,0 +1,130 @@ +/** + * @since 2.0.0 + */ +import type * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type * as Exit from "./Exit.js"; +import type * as Fiber from "./Fiber.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MergeStateTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MergeStateTypeId = typeof MergeStateTypeId; +/** + * @since 2.0.0 + * @category models + */ +export type MergeState = BothRunning | LeftDone | RightDone; +/** + * @since 2.0.0 + */ +export declare namespace MergeState { + /** + * @since 2.0.0 + * @category models + */ + interface Proto { + readonly [MergeStateTypeId]: MergeStateTypeId; + } +} +/** + * @since 2.0.0 + * @category models + */ +export interface BothRunning<_Env, out Err, out Err1, _Err2, out Elem, out Done, out Done1, _Done2> extends MergeState.Proto { + readonly _tag: "BothRunning"; + readonly left: Fiber.Fiber, Err>; + readonly right: Fiber.Fiber, Err1>; +} +/** + * @since 2.0.0 + * @category models + */ +export interface LeftDone extends MergeState.Proto { + readonly _tag: "LeftDone"; + f(exit: Exit.Exit): Effect.Effect; +} +/** + * @since 2.0.0 + * @category models + */ +export interface RightDone extends MergeState.Proto { + readonly _tag: "RightDone"; + f(exit: Exit.Exit): Effect.Effect; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const BothRunning: (left: Fiber.Fiber, Err>, right: Fiber.Fiber, Err1>) => MergeState; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const LeftDone: (f: (exit: Exit.Exit) => Effect.Effect) => MergeState; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const RightDone: (f: (exit: Exit.Exit) => Effect.Effect) => MergeState; +/** + * Returns `true` if the specified value is a `MergeState`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isMergeState: (u: unknown) => u is MergeState; +/** + * Returns `true` if the specified `MergeState` is a `BothRunning`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isBothRunning: (self: MergeState) => self is BothRunning; +/** + * Returns `true` if the specified `MergeState` is a `LeftDone`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isLeftDone: (self: MergeState) => self is LeftDone; +/** + * Returns `true` if the specified `MergeState` is a `RightDone`, `false` + * otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isRightDone: (self: MergeState) => self is RightDone; +/** + * @since 2.0.0 + * @category folding + */ +export declare const match: { + /** + * @since 2.0.0 + * @category folding + */ + (options: { + readonly onBothRunning: (left: Fiber.Fiber, Err>, right: Fiber.Fiber, Err1>) => Z; + readonly onLeftDone: (f: (exit: Exit.Exit) => Effect.Effect) => Z; + readonly onRightDone: (f: (exit: Exit.Exit) => Effect.Effect) => Z; + }): (self: MergeState) => Z; + /** + * @since 2.0.0 + * @category folding + */ + (self: MergeState, options: { + readonly onBothRunning: (left: Fiber.Fiber, Err>, right: Fiber.Fiber, Err1>) => Z; + readonly onLeftDone: (f: (exit: Exit.Exit) => Effect.Effect) => Z; + readonly onRightDone: (f: (exit: Exit.Exit) => Effect.Effect) => Z; + }): Z; +}; +//# sourceMappingURL=MergeState.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MergeState.d.ts.map b/backend/node_modules/effect/dist/dts/MergeState.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..70a068c1ee626f942faab94ff8a2164bc8fa151f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MergeState.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MergeState.d.ts","sourceRoot":"","sources":["../../src/MergeState.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MergeStrategy.d.ts.map b/backend/node_modules/effect/dist/dts/MergeStrategy.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..7121f40092ace2a494003a608b2e89ed46c21c63 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MergeStrategy.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MergeStrategy.d.ts","sourceRoot":"","sources":["../../src/MergeStrategy.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAAqC,CAAA;AAE9E;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA;AAE5D;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,aAAa,CAAA;AAExD;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,aAAa,CAAC;IACrC;;;OAGG;IACH,UAAiB,KAAK;QACpB,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;KACpD;CACF;AAED;;;GAGG;AACH,MAAM,WAAW,YAAa,SAAQ,aAAa,CAAC,KAAK;IACvD,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,aAAc,SAAQ,aAAa,CAAC,KAAK;IACxD,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAC/B;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,aAAqC,CAAA;AAE7E;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,aAAsC,CAAA;AAE/E;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,aAAwC,CAAA;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,IAAI,YAAsC,CAAA;AAEpG;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,IAAI,aAAwC,CAAA;AAEvG;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;OAKG;IACH,CAAC,CAAC,EACD,OAAO,EAAE;QACP,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,CAAA;QAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,CAAA;KAClC,GACC,CAAC,IAAI,EAAE,aAAa,KAAK,CAAC,CAAA;IAC7B;;;;;OAKG;IACH,CAAC,CAAC,EACD,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE;QACP,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,CAAA;QAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,CAAA;KAClC,GACC,CAAC,CAAA;CACY,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Metric.d.ts b/backend/node_modules/effect/dist/dts/Metric.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9632b691d1416961e249d6d9fe17d73dd76378f8 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Metric.d.ts @@ -0,0 +1,1042 @@ +/** + * @since 2.0.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import type { LazyArg } from "./Function.js"; +import type * as MetricBoundaries from "./MetricBoundaries.js"; +import type * as MetricKey from "./MetricKey.js"; +import type * as MetricKeyType from "./MetricKeyType.js"; +import type * as MetricLabel from "./MetricLabel.js"; +import type * as MetricPair from "./MetricPair.js"; +import type * as MetricRegistry from "./MetricRegistry.js"; +import type * as MetricState from "./MetricState.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricTypeId = typeof MetricTypeId; +/** + * A `Metric` represents a concurrent metric which accepts + * updates of type `In` and are aggregated to a stateful value of type `Out`. + * + * For example, a counter metric would have type `Metric`, + * representing the fact that the metric can be updated with numbers (the amount + * to increment or decrement the counter by), and the state of the counter is a + * number. + * + * There are five primitive metric types supported by Effect: + * + * - Counters + * - Frequencies + * - Gauges + * - Histograms + * - Summaries + * + * @since 2.0.0 + * @category models + */ +export interface Metric extends Metric.Variance, Pipeable { + /** + * The type of the underlying primitive metric. For example, this could be + * `MetricKeyType.Counter` or `MetricKeyType.Gauge`. + */ + readonly keyType: Type; + unsafeUpdate(input: In, extraTags: ReadonlyArray): void; + unsafeValue(extraTags: ReadonlyArray): Out; + unsafeModify(input: In, extraTags: ReadonlyArray): void; + register(): this; + (effect: Effect.Effect): Effect.Effect; +} +/** + * @since 2.0.0 + * @category models + */ +export interface MetricApply { + (keyType: Type, unsafeUpdate: (input: In, extraTags: ReadonlyArray) => void, unsafeValue: (extraTags: ReadonlyArray) => Out, unsafeModify: (input: In, extraTags: ReadonlyArray) => void): Metric; +} +/** + * @since 2.0.0 + */ +export declare namespace Metric { + /** + * @since 2.0.0 + * @category models + */ + interface Counter extends Metric, In, MetricState.MetricState.Counter> { + } + /** + * @since 2.0.0 + * @category models + */ + interface Gauge extends Metric, In, MetricState.MetricState.Gauge> { + } + /** + * @since 2.0.0 + * @category models + */ + interface Frequency extends Metric { + } + /** + * @since 2.0.0 + * @category models + */ + interface Histogram extends Metric { + } + /** + * @since 2.0.0 + * @category models + */ + interface Summary extends Metric { + } + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [MetricTypeId]: { + readonly _Type: Types.Invariant; + readonly _In: Types.Contravariant; + readonly _Out: Types.Covariant; + }; + } +} +/** + * @since 2.0.0 + * @category globals + */ +export declare const globalMetricRegistry: MetricRegistry.MetricRegistry; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: MetricApply; +/** + * Returns a new metric that is powered by this one, but which accepts updates + * of the specified new type, which must be transformable to the input type of + * this metric. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapInput: { + /** + * Returns a new metric that is powered by this one, but which accepts updates + * of the specified new type, which must be transformable to the input type of + * this metric. + * + * @since 2.0.0 + * @category mapping + */ + (f: (input: In2) => In): (self: Metric) => Metric; + /** + * Returns a new metric that is powered by this one, but which accepts updates + * of the specified new type, which must be transformable to the input type of + * this metric. + * + * @since 2.0.0 + * @category mapping + */ + (self: Metric, f: (input: In2) => In): Metric; +}; +/** + * Represents a Counter metric that tracks cumulative numerical values over time. + * Counters can be incremented and decremented and provide a running total of changes. + * + * **Options** + * + * - description - A description of the counter. + * - bigint - Indicates if the counter uses 'bigint' data type. + * - incremental - Set to 'true' for a counter that only increases. With this configuration, Effect ensures that non-incremental updates have no impact on the counter, making it exclusively suitable for counting upwards. + * + * @example + * ```ts + * import { Metric } from "effect" + * + * const numberCounter = Metric.counter("count", { + * description: "A number counter" + * }); + * + * const bigintCounter = Metric.counter("count", { + * description: "A bigint counter", + * bigint: true + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const counter: { + /** + * Represents a Counter metric that tracks cumulative numerical values over time. + * Counters can be incremented and decremented and provide a running total of changes. + * + * **Options** + * + * - description - A description of the counter. + * - bigint - Indicates if the counter uses 'bigint' data type. + * - incremental - Set to 'true' for a counter that only increases. With this configuration, Effect ensures that non-incremental updates have no impact on the counter, making it exclusively suitable for counting upwards. + * + * @example + * ```ts + * import { Metric } from "effect" + * + * const numberCounter = Metric.counter("count", { + * description: "A number counter" + * }); + * + * const bigintCounter = Metric.counter("count", { + * description: "A bigint counter", + * bigint: true + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options?: { + readonly description?: string | undefined; + readonly bigint?: false | undefined; + readonly incremental?: boolean | undefined; + }): Metric.Counter; + /** + * Represents a Counter metric that tracks cumulative numerical values over time. + * Counters can be incremented and decremented and provide a running total of changes. + * + * **Options** + * + * - description - A description of the counter. + * - bigint - Indicates if the counter uses 'bigint' data type. + * - incremental - Set to 'true' for a counter that only increases. With this configuration, Effect ensures that non-incremental updates have no impact on the counter, making it exclusively suitable for counting upwards. + * + * @example + * ```ts + * import { Metric } from "effect" + * + * const numberCounter = Metric.counter("count", { + * description: "A number counter" + * }); + * + * const bigintCounter = Metric.counter("count", { + * description: "A bigint counter", + * bigint: true + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options: { + readonly description?: string | undefined; + readonly bigint: true; + readonly incremental?: boolean | undefined; + }): Metric.Counter; +}; +/** + * Creates a Frequency metric to count occurrences of events. + * Frequency metrics are used to count the number of times specific events or incidents occur. + * + * @example + * ```ts + * import { Metric } from "effect" + * + * const errorFrequency = Metric.frequency("error_frequency", { + * description: "Counts the occurrences of errors." + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const frequency: (name: string, options?: { + readonly description?: string | undefined; + readonly preregisteredWords?: ReadonlyArray | undefined; +} | undefined) => Metric.Frequency; +/** + * Returns a new metric that is powered by this one, but which accepts updates + * of any type, and translates them to updates with the specified constant + * update value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const withConstantInput: { + /** + * Returns a new metric that is powered by this one, but which accepts updates + * of any type, and translates them to updates with the specified constant + * update value. + * + * @since 2.0.0 + * @category constructors + */ + (input: In): (self: Metric) => Metric; + /** + * Returns a new metric that is powered by this one, but which accepts updates + * of any type, and translates them to updates with the specified constant + * update value. + * + * @since 2.0.0 + * @category constructors + */ + (self: Metric, input: In): Metric; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const fromMetricKey: >(key: MetricKey.MetricKey) => Metric, MetricKeyType.MetricKeyType.OutType>; +/** + * Represents a Gauge metric that tracks and reports a single numerical value at a specific moment. + * Gauges are suitable for metrics that represent instantaneous values, such as memory usage or CPU load. + * + * **Options** + * + * - description - A description of the gauge metric. + * - bigint - Indicates if the counter uses 'bigint' data type. + * + * @example + * ```ts + * import { Metric } from "effect" + * + * const numberGauge = Metric.gauge("memory_usage", { + * description: "A gauge for memory usage" + * }); + * + * const bigintGauge = Metric.gauge("cpu_load", { + * description: "A gauge for CPU load", + * bigint: true + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const gauge: { + /** + * Represents a Gauge metric that tracks and reports a single numerical value at a specific moment. + * Gauges are suitable for metrics that represent instantaneous values, such as memory usage or CPU load. + * + * **Options** + * + * - description - A description of the gauge metric. + * - bigint - Indicates if the counter uses 'bigint' data type. + * + * @example + * ```ts + * import { Metric } from "effect" + * + * const numberGauge = Metric.gauge("memory_usage", { + * description: "A gauge for memory usage" + * }); + * + * const bigintGauge = Metric.gauge("cpu_load", { + * description: "A gauge for CPU load", + * bigint: true + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options?: { + readonly description?: string | undefined; + readonly bigint?: false | undefined; + }): Metric.Gauge; + /** + * Represents a Gauge metric that tracks and reports a single numerical value at a specific moment. + * Gauges are suitable for metrics that represent instantaneous values, such as memory usage or CPU load. + * + * **Options** + * + * - description - A description of the gauge metric. + * - bigint - Indicates if the counter uses 'bigint' data type. + * + * @example + * ```ts + * import { Metric } from "effect" + * + * const numberGauge = Metric.gauge("memory_usage", { + * description: "A gauge for memory usage" + * }); + * + * const bigintGauge = Metric.gauge("cpu_load", { + * description: "A gauge for CPU load", + * bigint: true + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options: { + readonly description?: string | undefined; + readonly bigint: true; + }): Metric.Gauge; +}; +/** + * Represents a Histogram metric that records observations in specified value boundaries. + * Histogram metrics are useful for measuring the distribution of values within a range. + * + * @example + * ```ts + * import { Metric, MetricBoundaries } from "effect" + * + * const latencyHistogram = Metric.histogram("latency_histogram", + * MetricBoundaries.linear({ start: 0, width: 10, count: 11 }), + * "Measures the distribution of request latency." + * ); + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const histogram: (name: string, boundaries: MetricBoundaries.MetricBoundaries, description?: string) => Metric; +/** + * @since 2.0.0 + * @category combinators + */ +export declare const increment: (self: Metric.Counter | Metric.Counter | Metric.Gauge | Metric.Gauge) => Effect.Effect; +/** + * @since 2.0.0 + * @category combinators + */ +export declare const incrementBy: { + /** + * @since 2.0.0 + * @category combinators + */ + (amount: number): (self: Metric.Counter | Metric.Counter) => Effect.Effect; + /** + * @since 2.0.0 + * @category combinators + */ + (amount: bigint): (self: Metric.Counter | Metric.Gauge) => Effect.Effect; + /** + * @since 2.0.0 + * @category combinators + */ + (self: Metric.Counter | Metric.Gauge, amount: number): Effect.Effect; + /** + * @since 2.0.0 + * @category combinators + */ + (self: Metric.Counter | Metric.Gauge, amount: bigint): Effect.Effect; +}; +/** + * Returns a new metric that is powered by this one, but which outputs a new + * state type, determined by transforming the state type of this metric by the + * specified function. + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Returns a new metric that is powered by this one, but which outputs a new + * state type, determined by transforming the state type of this metric by the + * specified function. + * + * @since 2.0.0 + * @category mapping + */ + (f: (out: Out) => Out2): (self: Metric) => Metric; + /** + * Returns a new metric that is powered by this one, but which outputs a new + * state type, determined by transforming the state type of this metric by the + * specified function. + * + * @since 2.0.0 + * @category mapping + */ + (self: Metric, f: (out: Out) => Out2): Metric; +}; +/** + * @since 2.0.0 + * @category mapping + */ +export declare const mapType: { + /** + * @since 2.0.0 + * @category mapping + */ + (f: (type: Type) => Type2): (self: Metric) => Metric; + /** + * @since 2.0.0 + * @category mapping + */ + (self: Metric, f: (type: Type) => Type2): Metric; +}; +/** + * Modifies the metric with the specified update message. For example, if the + * metric were a gauge, the update would increment the method by the provided + * amount. + * + * @since 3.6.5 + * @category utils + */ +export declare const modify: { + /** + * Modifies the metric with the specified update message. For example, if the + * metric were a gauge, the update would increment the method by the provided + * amount. + * + * @since 3.6.5 + * @category utils + */ + (input: In): (self: Metric) => Effect.Effect; + /** + * Modifies the metric with the specified update message. For example, if the + * metric were a gauge, the update would increment the method by the provided + * amount. + * + * @since 3.6.5 + * @category utils + */ + (self: Metric, input: In): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category aspects + */ +export declare const set: { + /** + * @since 2.0.0 + * @category aspects + */ + (value: number): (self: Metric.Gauge) => Effect.Effect; + /** + * @since 2.0.0 + * @category aspects + */ + (value: bigint): (self: Metric.Gauge) => Effect.Effect; + /** + * @since 2.0.0 + * @category aspects + */ + (self: Metric.Gauge, value: number): Effect.Effect; + /** + * @since 2.0.0 + * @category aspects + */ + (self: Metric.Gauge, value: bigint): Effect.Effect; +}; +/** + * Captures a snapshot of all metrics recorded by the application. + * + * @since 2.0.0 + * @category getters + */ +export declare const snapshot: Effect.Effect>; +/** + * Creates a metric that ignores input and produces constant output. + * + * @since 2.0.0 + * @category constructors + */ +export declare const succeed: (out: Out) => Metric; +/** + * Creates a metric that ignores input and produces constant output. + * + * @since 2.0.0 + * @category constructors + */ +export declare const sync: (evaluate: LazyArg) => Metric; +/** + * Creates a Summary metric that records observations and calculates quantiles. + * Summary metrics provide statistical information about a set of values, including quantiles. + * + * **Options** + * + * - name - The name of the Summary metric. + * - maxAge - The maximum age of observations to retain. + * - maxSize - The maximum number of observations to keep. + * - error - The error percentage when calculating quantiles. + * - quantiles - An `Chunk` of quantiles to calculate (e.g., [0.5, 0.9]). + * - description - An optional description of the Summary metric. + * + * @example + * ```ts + * import { Metric, Chunk } from "effect" + * + * const responseTimesSummary = Metric.summary({ + * name: "response_times_summary", + * maxAge: "60 seconds", // Retain observations for 60 seconds. + * maxSize: 1000, // Keep a maximum of 1000 observations. + * error: 0.01, // Allow a 1% error when calculating quantiles. + * quantiles: [0.5, 0.9, 0.99], // Calculate 50th, 90th, and 99th percentiles. + * description: "Measures the distribution of response times." + * }); + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const summary: (options: { + readonly name: string; + readonly maxAge: Duration.DurationInput; + readonly maxSize: number; + readonly error: number; + readonly quantiles: ReadonlyArray; + readonly description?: string | undefined; +}) => Metric.Summary; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const summaryTimestamp: (options: { + readonly name: string; + readonly maxAge: Duration.DurationInput; + readonly maxSize: number; + readonly error: number; + readonly quantiles: ReadonlyArray; + readonly description?: string | undefined; +}) => Metric.Summary; +/** + * Returns a new metric, which is identical in every way to this one, except + * the specified tags have been added to the tags of this metric. + * + * @since 2.0.0 + * @category utils + */ +export declare const tagged: { + /** + * Returns a new metric, which is identical in every way to this one, except + * the specified tags have been added to the tags of this metric. + * + * @since 2.0.0 + * @category utils + */ + (key: string, value: string): (self: Metric) => Metric; + /** + * Returns a new metric, which is identical in every way to this one, except + * the specified tags have been added to the tags of this metric. + * + * @since 2.0.0 + * @category utils + */ + (self: Metric, key: string, value: string): Metric; +}; +/** + * Returns a new metric, which is identical in every way to this one, except + * dynamic tags are added based on the update values. Note that the metric + * returned by this method does not return any useful information, due to the + * dynamic nature of the added tags. + * + * @since 2.0.0 + * @category utils + */ +export declare const taggedWithLabelsInput: { + /** + * Returns a new metric, which is identical in every way to this one, except + * dynamic tags are added based on the update values. Note that the metric + * returned by this method does not return any useful information, due to the + * dynamic nature of the added tags. + * + * @since 2.0.0 + * @category utils + */ + (f: (input: In) => Iterable): (self: Metric) => Metric; + /** + * Returns a new metric, which is identical in every way to this one, except + * dynamic tags are added based on the update values. Note that the metric + * returned by this method does not return any useful information, due to the + * dynamic nature of the added tags. + * + * @since 2.0.0 + * @category utils + */ + (self: Metric, f: (input: In) => Iterable): Metric; +}; +/** + * Returns a new metric, which is identical in every way to this one, except + * the specified tags have been added to the tags of this metric. + * + * @since 2.0.0 + * @category utils + */ +export declare const taggedWithLabels: { + /** + * Returns a new metric, which is identical in every way to this one, except + * the specified tags have been added to the tags of this metric. + * + * @since 2.0.0 + * @category utils + */ + (extraTags: Iterable): (self: Metric) => Metric; + /** + * Returns a new metric, which is identical in every way to this one, except + * the specified tags have been added to the tags of this metric. + * + * @since 2.0.0 + * @category utils + */ + (self: Metric, extraTags: Iterable): Metric; +}; +/** + * Creates a timer metric, based on a histogram, which keeps track of + * durations in milliseconds. The unit of time will automatically be added to + * the metric as a tag (i.e. `"time_unit: milliseconds"`). + * + * @since 2.0.0 + * @category constructors + */ +export declare const timer: (name: string, description?: string) => Metric; +/** + * Creates a timer metric, based on a histogram created from the provided + * boundaries, which keeps track of durations in milliseconds. The unit of time + * will automatically be added to the metric as a tag (i.e. + * `"time_unit: milliseconds"`). + * + * @since 2.0.0 + * @category constructors + */ +export declare const timerWithBoundaries: (name: string, boundaries: ReadonlyArray, description?: string) => Metric; +/** + * Returns an aspect that will update this metric with the specified constant + * value every time the aspect is applied to an effect, regardless of whether + * that effect fails or succeeds. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackAll: { + /** + * Returns an aspect that will update this metric with the specified constant + * value every time the aspect is applied to an effect, regardless of whether + * that effect fails or succeeds. + * + * @since 2.0.0 + * @category aspects + */ + (input: In): (self: Metric) => (effect: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the specified constant + * value every time the aspect is applied to an effect, regardless of whether + * that effect fails or succeeds. + * + * @since 2.0.0 + * @category aspects + */ + (self: Metric, input: In): (effect: Effect.Effect) => Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the defects of the + * effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackDefect: { + /** + * Returns an aspect that will update this metric with the defects of the + * effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric): (self: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the defects of the + * effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric): Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the defect throwables of the effects that the + * aspect is applied to. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackDefectWith: { + /** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the defect throwables of the effects that the + * aspect is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric, f: (defect: unknown) => In): (self: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the defect throwables of the effects that the + * aspect is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric, f: (defect: unknown) => In): Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the duration that the + * effect takes to execute. To call this method, the input type of the metric + * must be `Duration`. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackDuration: { + /** + * Returns an aspect that will update this metric with the duration that the + * effect takes to execute. To call this method, the input type of the metric + * must be `Duration`. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric): (self: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the duration that the + * effect takes to execute. To call this method, the input type of the metric + * must be `Duration`. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric): Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the duration that the + * effect takes to execute. To call this method, you must supply a function + * that can convert the `Duration` to the input type of this metric. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackDurationWith: { + /** + * Returns an aspect that will update this metric with the duration that the + * effect takes to execute. To call this method, you must supply a function + * that can convert the `Duration` to the input type of this metric. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric, f: (duration: Duration.Duration) => In): (effect: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the duration that the + * effect takes to execute. To call this method, you must supply a function + * that can convert the `Duration` to the input type of this metric. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric, f: (duration: Duration.Duration) => In): Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the failure value of + * the effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackError: { + /** + * Returns an aspect that will update this metric with the failure value of + * the effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric): (self: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the failure value of + * the effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric): Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the error value of the effects that the aspect is + * applied to. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackErrorWith: { + /** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the error value of the effects that the aspect is + * applied to. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric, f: (error: In2) => In): (effect: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the error value of the effects that the aspect is + * applied to. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric, f: (error: In2) => In): Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the success value of + * the effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackSuccess: { + /** + * Returns an aspect that will update this metric with the success value of + * the effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric): (self: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the success value of + * the effects that it is applied to. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric): Effect.Effect; +}; +/** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the success value of the effects that the aspect is + * applied to. + * + * @since 2.0.0 + * @category aspects + */ +export declare const trackSuccessWith: { + /** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the success value of the effects that the aspect is + * applied to. + * + * @since 2.0.0 + * @category aspects + */ + (metric: Metric, f: (value: Types.NoInfer) => In): (self: Effect.Effect) => Effect.Effect; + /** + * Returns an aspect that will update this metric with the result of applying + * the specified function to the success value of the effects that the aspect is + * applied to. + * + * @since 2.0.0 + * @category aspects + */ + (self: Effect.Effect, metric: Metric, f: (value: Types.NoInfer) => In): Effect.Effect; +}; +/** + * Updates the metric with the specified update message. For example, if the + * metric were a counter, the update would increment the method by the + * provided amount. + * + * @since 2.0.0 + * @category utils + */ +export declare const update: { + /** + * Updates the metric with the specified update message. For example, if the + * metric were a counter, the update would increment the method by the + * provided amount. + * + * @since 2.0.0 + * @category utils + */ + (input: In): (self: Metric) => Effect.Effect; + /** + * Updates the metric with the specified update message. For example, if the + * metric were a counter, the update would increment the method by the + * provided amount. + * + * @since 2.0.0 + * @category utils + */ + (self: Metric, input: In): Effect.Effect; +}; +/** + * Retrieves a snapshot of the value of the metric at this moment in time. + * + * @since 2.0.0 + * @category getters + */ +export declare const value: (self: Metric) => Effect.Effect; +/** + * @since 2.0.0 + * @category utils + */ +export declare const withNow: (self: Metric) => Metric; +/** + * @since 2.0.0 + * @category zipping + */ +export declare const zip: { + /** + * @since 2.0.0 + * @category zipping + */ + (that: Metric): (self: Metric) => Metric; + /** + * @since 2.0.0 + * @category zipping + */ + (self: Metric, that: Metric): Metric; +}; +/** + * Unsafely captures a snapshot of all metrics recorded by the application. + * + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeSnapshot: (_: void) => ReadonlyArray; +/** + * @since 2.0.0 + * @category metrics + */ +export declare const fiberStarted: Metric.Counter; +/** + * @since 2.0.0 + * @category metrics + */ +export declare const fiberSuccesses: Metric.Counter; +/** + * @since 2.0.0 + * @category metrics + */ +export declare const fiberFailures: Metric.Counter; +/** + * @since 2.0.0 + * @category metrics + */ +export declare const fiberLifetimes: Metric; +/** + * @since 2.0.0 + * @category metrics + */ +export declare const fiberActive: Metric.Counter; +//# sourceMappingURL=Metric.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Metric.d.ts.map b/backend/node_modules/effect/dist/dts/Metric.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..0ffcf72c5899ba2d57713ca205c8531185a51760 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Metric.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Metric.d.ts","sourceRoot":"","sources":["../../src/Metric.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricBoundaries.d.ts b/backend/node_modules/effect/dist/dts/MetricBoundaries.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2fe18e98e78489907b7fc304273da05d7c916a6c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricBoundaries.d.ts @@ -0,0 +1,58 @@ +/** + * @since 2.0.0 + */ +import type * as Equal from "./Equal.js"; +import type { Pipeable } from "./Pipeable.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricBoundariesTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricBoundariesTypeId = typeof MetricBoundariesTypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface MetricBoundaries extends Equal.Equal, Pipeable { + readonly [MetricBoundariesTypeId]: MetricBoundariesTypeId; + readonly values: ReadonlyArray; +} +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isMetricBoundaries: (u: unknown) => u is MetricBoundaries; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const fromIterable: (iterable: Iterable) => MetricBoundaries; +/** + * A helper method to create histogram bucket boundaries for a histogram + * with linear increasing values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const linear: (options: { + readonly start: number; + readonly width: number; + readonly count: number; +}) => MetricBoundaries; +/** + * A helper method to create histogram bucket boundaries for a histogram + * with exponentially increasing values. + * + * @since 2.0.0 + * @category constructors + */ +export declare const exponential: (options: { + readonly start: number; + readonly factor: number; + readonly count: number; +}) => MetricBoundaries; +//# sourceMappingURL=MetricBoundaries.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricBoundaries.d.ts.map b/backend/node_modules/effect/dist/dts/MetricBoundaries.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6bd3ec2885380d61a9a5c3fe7bffa359c7d91160 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricBoundaries.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MetricBoundaries.d.ts","sourceRoot":"","sources":["../../src/MetricBoundaries.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,OAAO,MAAwC,CAAA;AAEpF;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA;AAElE;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,KAAK,CAAC,KAAK,EAAE,QAAQ;IAC7D,QAAQ,CAAC,CAAC,sBAAsB,CAAC,EAAE,sBAAsB,CAAA;IACzD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACvC;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,gBAA8C,CAAA;AAEpG;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,gBAAwC,CAAA;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,CACnB,OAAO,EAAE;IACP,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,KACE,gBAAkC,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,CACxB,OAAO,EAAE;IACP,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,KACE,gBAAuC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricHook.d.ts b/backend/node_modules/effect/dist/dts/MetricHook.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b034ff2d167775339e0a62759e097e05e5b024fe --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricHook.d.ts @@ -0,0 +1,155 @@ +/** + * @since 2.0.0 + */ +import type { LazyArg } from "./Function.js"; +import type * as MetricKey from "./MetricKey.js"; +import type * as MetricState from "./MetricState.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricHookTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricHookTypeId = typeof MetricHookTypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface MetricHook extends MetricHook.Variance, Pipeable { + get(): Out; + update(input: In): void; + modify(input: In): void; +} +/** + * @since 2.0.0 + */ +export declare namespace MetricHook { + /** + * @since 2.0.0 + * @category models + */ + type Root = MetricHook; + /** + * @since 2.0.0 + * @category models + */ + type Untyped = MetricHook; + /** + * @since 2.0.0 + * @category models + */ + type Counter = MetricHook>; + /** + * @since 2.0.0 + * @category models + */ + type Gauge = MetricHook>; + /** + * @since 2.0.0 + * @category models + */ + type Frequency = MetricHook; + /** + * @since 2.0.0 + * @category models + */ + type Histogram = MetricHook; + /** + * @since 2.0.0 + * @category models + */ + type Summary = MetricHook; + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [MetricHookTypeId]: { + readonly _In: Types.Contravariant; + readonly _Out: Types.Covariant; + }; + } +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (options: { + readonly get: LazyArg; + readonly update: (input: In) => void; + readonly modify: (input: In) => void; +}) => MetricHook; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const counter: (key: MetricKey.MetricKey.Counter) => MetricHook.Counter; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const frequency: (_key: MetricKey.MetricKey.Frequency) => MetricHook.Frequency; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const gauge: { + /** + * @since 2.0.0 + * @category constructors + */ + (key: MetricKey.MetricKey.Gauge, startAt: number): MetricHook.Gauge; + /** + * @since 2.0.0 + * @category constructors + */ + (key: MetricKey.MetricKey.Gauge, startAt: bigint): MetricHook.Gauge; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const histogram: (key: MetricKey.MetricKey.Histogram) => MetricHook.Histogram; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const summary: (key: MetricKey.MetricKey.Summary) => MetricHook.Summary; +/** + * @since 2.0.0 + * @category utils + */ +export declare const onUpdate: { + /** + * @since 2.0.0 + * @category utils + */ + (f: (input: In) => void): (self: MetricHook) => MetricHook; + /** + * @since 2.0.0 + * @category utils + */ + (self: MetricHook, f: (input: In) => void): MetricHook; +}; +/** + * @since 3.6.5 + * @category utils + */ +export declare const onModify: { + /** + * @since 3.6.5 + * @category utils + */ + (f: (input: In) => void): (self: MetricHook) => MetricHook; + /** + * @since 3.6.5 + * @category utils + */ + (self: MetricHook, f: (input: In) => void): MetricHook; +}; +//# sourceMappingURL=MetricHook.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricKey.d.ts b/backend/node_modules/effect/dist/dts/MetricKey.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..08b401aeb3322ff9d731fa4afb3c61f6b09ba1b8 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricKey.d.ts @@ -0,0 +1,222 @@ +/** + * @since 2.0.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Equal from "./Equal.js"; +import type * as MetricBoundaries from "./MetricBoundaries.js"; +import type * as MetricKeyType from "./MetricKeyType.js"; +import type * as MetricLabel from "./MetricLabel.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricKeyTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricKeyTypeId = typeof MetricKeyTypeId; +/** + * A `MetricKey` is a unique key associated with each metric. The key is based + * on a combination of the metric type, the name and tags associated with the + * metric, an optional description of the key, and any other information to + * describe a metric, such as the boundaries of a histogram. In this way, it is + * impossible to ever create different metrics with conflicting keys. + * + * @since 2.0.0 + * @category models + */ +export interface MetricKey> extends MetricKey.Variance, Equal.Equal, Pipeable { + readonly name: string; + readonly keyType: Type; + readonly description: Option.Option; + readonly tags: ReadonlyArray; +} +/** + * @since 2.0.0 + */ +export declare namespace MetricKey { + /** + * @since 2.0.0 + * @category models + */ + type Untyped = MetricKey; + /** + * @since 2.0.0 + * @category models + */ + type Counter = MetricKey>; + /** + * @since 2.0.0 + * @category models + */ + type Gauge = MetricKey>; + /** + * @since 2.0.0 + * @category models + */ + type Frequency = MetricKey; + /** + * @since 2.0.0 + * @category models + */ + type Histogram = MetricKey; + /** + * @since 2.0.0 + * @category models + */ + type Summary = MetricKey; + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [MetricKeyTypeId]: { + _Type: Types.Covariant; + }; + } +} +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isMetricKey: (u: unknown) => u is MetricKey>; +/** + * Creates a metric key for a counter, with the specified name. + * + * @since 2.0.0 + * @category constructors + */ +export declare const counter: { + /** + * Creates a metric key for a counter, with the specified name. + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options?: { + readonly description?: string | undefined; + readonly bigint?: false | undefined; + readonly incremental?: boolean | undefined; + }): MetricKey.Counter; + /** + * Creates a metric key for a counter, with the specified name. + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options: { + readonly description?: string | undefined; + readonly bigint: true; + readonly incremental?: boolean | undefined; + }): MetricKey.Counter; +}; +/** + * Creates a metric key for a categorical frequency table, with the specified + * name. + * + * @since 2.0.0 + * @category constructors + */ +export declare const frequency: (name: string, options?: { + readonly description?: string | undefined; + readonly preregisteredWords?: ReadonlyArray | undefined; +} | undefined) => MetricKey.Frequency; +/** + * Creates a metric key for a gauge, with the specified name. + * + * @since 2.0.0 + * @category constructors + */ +export declare const gauge: { + /** + * Creates a metric key for a gauge, with the specified name. + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options?: { + readonly description?: string | undefined; + readonly bigint?: false | undefined; + }): MetricKey.Gauge; + /** + * Creates a metric key for a gauge, with the specified name. + * + * @since 2.0.0 + * @category constructors + */ + (name: string, options: { + readonly description?: string | undefined; + readonly bigint: true; + }): MetricKey.Gauge; +}; +/** + * Creates a metric key for a histogram, with the specified name and boundaries. + * + * @since 2.0.0 + * @category constructors + */ +export declare const histogram: (name: string, boundaries: MetricBoundaries.MetricBoundaries, description?: string) => MetricKey.Histogram; +/** + * Creates a metric key for a summary, with the specified name, maxAge, + * maxSize, error, and quantiles. + * + * @since 2.0.0 + * @category constructors + */ +export declare const summary: (options: { + readonly name: string; + readonly maxAge: Duration.DurationInput; + readonly maxSize: number; + readonly error: number; + readonly quantiles: ReadonlyArray; + readonly description?: string | undefined; +}) => MetricKey.Summary; +/** + * Returns a new `MetricKey` with the specified tag appended. + * + * @since 2.0.0 + * @category constructors + */ +export declare const tagged: { + /** + * Returns a new `MetricKey` with the specified tag appended. + * + * @since 2.0.0 + * @category constructors + */ + (key: string, value: string): >(self: MetricKey) => MetricKey; + /** + * Returns a new `MetricKey` with the specified tag appended. + * + * @since 2.0.0 + * @category constructors + */ + >(self: MetricKey, key: string, value: string): MetricKey; +}; +/** + * Returns a new `MetricKey` with the specified tags appended. + * + * @since 2.0.0 + * @category constructors + */ +export declare const taggedWithLabels: { + /** + * Returns a new `MetricKey` with the specified tags appended. + * + * @since 2.0.0 + * @category constructors + */ + (extraTags: ReadonlyArray): >(self: MetricKey) => MetricKey; + /** + * Returns a new `MetricKey` with the specified tags appended. + * + * @since 2.0.0 + * @category constructors + */ + >(self: MetricKey, extraTags: ReadonlyArray): MetricKey; +}; +//# sourceMappingURL=MetricKey.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricKeyType.d.ts b/backend/node_modules/effect/dist/dts/MetricKeyType.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..40c65e2adfcd140216265c3f6b54314f76e050c4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricKeyType.d.ts @@ -0,0 +1,224 @@ +/** + * @since 2.0.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Equal from "./Equal.js"; +import type * as MetricBoundaries from "./MetricBoundaries.js"; +import type * as MetricState from "./MetricState.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricKeyTypeTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricKeyTypeTypeId = typeof MetricKeyTypeTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const CounterKeyTypeTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type CounterKeyTypeTypeId = typeof CounterKeyTypeTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FrequencyKeyTypeTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FrequencyKeyTypeTypeId = typeof FrequencyKeyTypeTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const GaugeKeyTypeTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type GaugeKeyTypeTypeId = typeof GaugeKeyTypeTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const HistogramKeyTypeTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type HistogramKeyTypeTypeId = typeof HistogramKeyTypeTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const SummaryKeyTypeTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type SummaryKeyTypeTypeId = typeof SummaryKeyTypeTypeId; +/** + * @since 2.0.0 + * @category modelz + */ +export interface MetricKeyType extends MetricKeyType.Variance, Equal.Equal, Pipeable { +} +/** + * @since 2.0.0 + */ +export declare namespace MetricKeyType { + /** + * @since 2.0.0 + * @category models + */ + type Untyped = MetricKeyType; + /** + * @since 2.0.0 + * @category models + */ + type Counter = MetricKeyType> & { + readonly [CounterKeyTypeTypeId]: CounterKeyTypeTypeId; + readonly incremental: boolean; + readonly bigint: boolean; + }; + /** + * @since 2.0.0 + * @category models + */ + type Frequency = MetricKeyType & { + readonly [FrequencyKeyTypeTypeId]: FrequencyKeyTypeTypeId; + readonly preregisteredWords: ReadonlyArray; + }; + /** + * @since 2.0.0 + * @category models + */ + type Gauge = MetricKeyType> & { + readonly [GaugeKeyTypeTypeId]: GaugeKeyTypeTypeId; + readonly bigint: boolean; + }; + /** + * @since 2.0.0 + * @category models + */ + type Histogram = MetricKeyType & { + readonly [HistogramKeyTypeTypeId]: HistogramKeyTypeTypeId; + readonly boundaries: MetricBoundaries.MetricBoundaries; + }; + /** + * @since 2.0.0 + * @category models + */ + type Summary = MetricKeyType & { + readonly [SummaryKeyTypeTypeId]: SummaryKeyTypeTypeId; + readonly maxAge: Duration.Duration; + readonly maxSize: number; + readonly error: number; + readonly quantiles: ReadonlyArray; + }; + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [MetricKeyTypeTypeId]: { + readonly _In: Types.Contravariant; + readonly _Out: Types.Covariant; + }; + } + /** + * @since 2.0.0 + * @category models + */ + type InType> = [Type] extends [ + { + readonly [MetricKeyTypeTypeId]: { + readonly _In: (_: infer In) => void; + }; + } + ] ? In : never; + /** + * @since 2.0.0 + * @category models + */ + type OutType> = [Type] extends [ + { + readonly [MetricKeyTypeTypeId]: { + readonly _Out: (_: never) => infer Out; + }; + } + ] ? Out : never; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const counter: () => MetricKeyType.Counter; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const frequency: (options?: { + readonly preregisteredWords?: ReadonlyArray | undefined; +} | undefined) => MetricKeyType.Frequency; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const gauge: () => MetricKeyType.Gauge; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const histogram: (boundaries: MetricBoundaries.MetricBoundaries) => MetricKeyType.Histogram; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const summary: (options: { + readonly maxAge: Duration.DurationInput; + readonly maxSize: number; + readonly error: number; + readonly quantiles: ReadonlyArray; +}) => MetricKeyType.Summary; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isMetricKeyType: (u: unknown) => u is MetricKeyType; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isCounterKey: (u: unknown) => u is MetricKeyType.Counter; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isFrequencyKey: (u: unknown) => u is MetricKeyType.Frequency; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isGaugeKey: (u: unknown) => u is MetricKeyType.Gauge; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isHistogramKey: (u: unknown) => u is MetricKeyType.Histogram; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isSummaryKey: (u: unknown) => u is MetricKeyType.Summary; +//# sourceMappingURL=MetricKeyType.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricKeyType.d.ts.map b/backend/node_modules/effect/dist/dts/MetricKeyType.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..f196228085d115551eaa8f515326c7d8fd912d4b --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricKeyType.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MetricKeyType.d.ts","sourceRoot":"","sources":["../../src/MetricKeyType.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricLabel.d.ts b/backend/node_modules/effect/dist/dts/MetricLabel.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6f18e1a536f1eb5efe2d187dbdb7f5c776f435eb --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricLabel.d.ts @@ -0,0 +1,42 @@ +/** + * @since 2.0.0 + */ +import type * as Equal from "./Equal.js"; +import type { Pipeable } from "./Pipeable.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricLabelTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricLabelTypeId = typeof MetricLabelTypeId; +/** + * A `MetricLabel` represents a key value pair that allows analyzing metrics at + * an additional level of granularity. + * + * For example if a metric tracks the response time of a service labels could + * be used to create separate versions that track response times for different + * clients. + * + * @since 2.0.0 + * @category models + */ +export interface MetricLabel extends Equal.Equal, Pipeable { + readonly [MetricLabelTypeId]: MetricLabelTypeId; + readonly key: string; + readonly value: string; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (key: string, value: string) => MetricLabel; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isMetricLabel: (u: unknown) => u is MetricLabel; +//# sourceMappingURL=MetricLabel.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricLabel.d.ts.map b/backend/node_modules/effect/dist/dts/MetricLabel.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..f661e196714a4f2e735ff6eb7b8082b766f6e58a --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricLabel.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MetricLabel.d.ts","sourceRoot":"","sources":["../../src/MetricLabel.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,OAAO,MAAmC,CAAA;AAE1E;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,KAAK,EAAE,QAAQ;IACxD,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,WAA2B,CAAA;AAE9E;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,WAAoC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricPair.d.ts b/backend/node_modules/effect/dist/dts/MetricPair.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9a2eda4d2a22f931d8c169f9163fa6310791c42 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricPair.d.ts @@ -0,0 +1,54 @@ +import type * as MetricKey from "./MetricKey.js"; +import type * as MetricKeyType from "./MetricKeyType.js"; +import type * as MetricState from "./MetricState.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricPairTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricPairTypeId = typeof MetricPairTypeId; +/** + * @since 2.0.0 + * @category model + */ +export interface MetricPair> extends MetricPair.Variance, Pipeable { + readonly metricKey: MetricKey.MetricKey; + readonly metricState: MetricState.MetricState>; +} +/** + * @since 2.0.0 + */ +export declare namespace MetricPair { + /** + * @since 2.0.0 + * @category models + */ + interface Untyped extends MetricPair> { + } + /** + * @since 2.0.0 + * @category models + */ + interface Variance> { + readonly [MetricPairTypeId]: { + readonly _Type: Types.Covariant; + }; + } +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: >(metricKey: MetricKey.MetricKey, metricState: MetricState.MetricState>) => MetricPair.Untyped; +/** + * @since 2.0.0 + * @category unsafe + */ +export declare const unsafeMake: >(metricKey: MetricKey.MetricKey, metricState: MetricState.MetricState.Untyped) => MetricPair.Untyped; +//# sourceMappingURL=MetricPair.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricPair.d.ts.map b/backend/node_modules/effect/dist/dts/MetricPair.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..77583cae5c6e06c1e9e20eff99a1c96da3f653a4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricPair.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MetricPair.d.ts","sourceRoot":"","sources":["../../src/MetricPair.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,KAAK,WAAW,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAkC,CAAA;AAExE;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA;AAEtD;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,GAAG,CAAC,IAAI,SAAS,aAAa,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAChF,SAAQ,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ;IAE3C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;IAC7C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;CACzF;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,UAAU,CAAC;IAClC;;;OAGG;IACH,UAAiB,OAAQ,SAAQ,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;KAAG;IAErF;;;OAGG;IACH,UAAiB,QAAQ,CAAC,GAAG,CAAC,IAAI,SAAS,aAAa,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC;QAC9E,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE;YAC3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;SACtC,CAAA;KACF;CACF;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,IAAI,SAAS,aAAa,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,EACpE,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,EACpC,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAC5E,UAAU,CAAC,OAAuB,CAAA;AAEvC;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,SAAS,aAAa,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,EAC1E,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,EACpC,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,OAAO,KACzC,UAAU,CAAC,OAA6B,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricRegistry.d.ts b/backend/node_modules/effect/dist/dts/MetricRegistry.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4a32e68740542752ef53feec142ec5d704166287 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricRegistry.d.ts @@ -0,0 +1,34 @@ +import type * as MetricHook from "./MetricHook.js"; +import type * as MetricKey from "./MetricKey.js"; +import type * as MetricKeyType from "./MetricKeyType.js"; +import type * as MetricPair from "./MetricPair.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricRegistryTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricRegistryTypeId = typeof MetricRegistryTypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface MetricRegistry { + readonly [MetricRegistryTypeId]: MetricRegistryTypeId; + snapshot(): Array; + get>(key: MetricKey.MetricKey): MetricHook.MetricHook, MetricKeyType.MetricKeyType.OutType>; + getCounter(key: MetricKey.MetricKey.Counter): MetricHook.MetricHook.Counter; + getFrequency(key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency; + getGauge(key: MetricKey.MetricKey.Gauge): MetricHook.MetricHook.Gauge; + getHistogram(key: MetricKey.MetricKey.Histogram): MetricHook.MetricHook.Histogram; + getSummary(key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (_: void) => MetricRegistry; +//# sourceMappingURL=MetricRegistry.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricRegistry.d.ts.map b/backend/node_modules/effect/dist/dts/MetricRegistry.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..ba9a8aa8a2daddd9c25e5358c35c3462d7f56a42 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricRegistry.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MetricRegistry.d.ts","sourceRoot":"","sources":["../../src/MetricRegistry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAElD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,OAAO,MAAsC,CAAA;AAEhF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,CAAC,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IACrD,QAAQ,IAAI,KAAK,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA;IAChD,GAAG,CAAC,IAAI,SAAS,aAAa,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,EACpD,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,UAAU,CAAC,UAAU,CACtB,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,GAAG,CAAC,SAAS,CAAC,CAAC,EACzD,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,GAAG,CAAC,SAAS,CAAC,CAAC,CAC3D,CAAA;IACD,UAAU,CAAC,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EACpC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,GAClC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IACnC,YAAY,CAAC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,CAAC,UAAU,CAAC,SAAS,CAAA;IACjF,QAAQ,CAAC,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACxG,YAAY,CAAC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,CAAC,UAAU,CAAC,SAAS,CAAA;IACjF,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,OAAO,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAA;CAC5E;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,cAA8B,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MetricState.d.ts b/backend/node_modules/effect/dist/dts/MetricState.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb44930439a74c3ff50e3e24af8f224e8fac695c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MetricState.d.ts @@ -0,0 +1,238 @@ +/** + * @since 2.0.0 + */ +import type * as Equal from "./Equal.js"; +import type * as MetricKeyType from "./MetricKeyType.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const MetricStateTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type MetricStateTypeId = typeof MetricStateTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const CounterStateTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type CounterStateTypeId = typeof CounterStateTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const FrequencyStateTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type FrequencyStateTypeId = typeof FrequencyStateTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const GaugeStateTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type GaugeStateTypeId = typeof GaugeStateTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const HistogramStateTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type HistogramStateTypeId = typeof HistogramStateTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const SummaryStateTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type SummaryStateTypeId = typeof SummaryStateTypeId; +/** + * A `MetricState` describes the state of a metric. The type parameter of a + * metric state corresponds to the type of the metric key (`MetricStateType`). + * This phantom type parameter is used to tie keys to their expected states. + * + * @since 2.0.0 + * @category models + */ +export interface MetricState extends MetricState.Variance, Equal.Equal, Pipeable { +} +/** + * @since 2.0.0 + */ +export declare namespace MetricState { + /** + * @since 2.0.0 + * @category models + */ + interface Untyped extends MetricState { + } + /** + * @since 2.0.0 + * @category models + */ + interface Counter extends MetricState> { + readonly [CounterStateTypeId]: CounterStateTypeId; + readonly count: A; + } + /** + * @since 2.0.0 + * @category models + */ + interface Frequency extends MetricState { + readonly [FrequencyStateTypeId]: FrequencyStateTypeId; + readonly occurrences: ReadonlyMap; + } + /** + * @since 2.0.0 + * @category models + */ + interface Gauge extends MetricState> { + readonly [GaugeStateTypeId]: GaugeStateTypeId; + readonly value: A; + } + /** + * @since 2.0.0 + * @category models + */ + interface Histogram extends MetricState { + readonly [HistogramStateTypeId]: HistogramStateTypeId; + readonly buckets: ReadonlyArray; + readonly count: number; + readonly min: number; + readonly max: number; + readonly sum: number; + } + /** + * @since 2.0.0 + * @category models + */ + interface Summary extends MetricState { + readonly [SummaryStateTypeId]: SummaryStateTypeId; + readonly error: number; + readonly quantiles: ReadonlyArray]>; + readonly count: number; + readonly min: number; + readonly max: number; + readonly sum: number; + } + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [MetricStateTypeId]: { + readonly _A: Types.Contravariant; + }; + } +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const counter: { + /** + * @since 2.0.0 + * @category constructors + */ + (count: number): MetricState.Counter; + /** + * @since 2.0.0 + * @category constructors + */ + (count: bigint): MetricState.Counter; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const frequency: (occurrences: ReadonlyMap) => MetricState.Frequency; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const gauge: { + /** + * @since 2.0.0 + * @category constructors + */ + (count: number): MetricState.Gauge; + /** + * @since 2.0.0 + * @category constructors + */ + (count: bigint): MetricState.Gauge; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const histogram: (options: { + readonly buckets: ReadonlyArray; + readonly count: number; + readonly min: number; + readonly max: number; + readonly sum: number; +}) => MetricState.Histogram; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const summary: (options: { + readonly error: number; + readonly quantiles: ReadonlyArray]>; + readonly count: number; + readonly min: number; + readonly max: number; + readonly sum: number; +}) => MetricState.Summary; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isMetricState: (u: unknown) => u is MetricState.Counter; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isCounterState: (u: unknown) => u is MetricState.Counter; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isFrequencyState: (u: unknown) => u is MetricState.Frequency; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isGaugeState: (u: unknown) => u is MetricState.Gauge; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isHistogramState: (u: unknown) => u is MetricState.Histogram; +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isSummaryState: (u: unknown) => u is MetricState.Summary; +//# sourceMappingURL=MetricState.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Micro.d.ts b/backend/node_modules/effect/dist/dts/Micro.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..46eb1613aa449fd3a233b6461174fec676826cd9 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Micro.d.ts @@ -0,0 +1,3440 @@ +import type { Channel } from "./Channel.js"; +import * as Context from "./Context.js"; +import type { Effect, EffectUnify, EffectUnifyIgnore } from "./Effect.js"; +import * as Effectable from "./Effectable.js"; +import * as Either from "./Either.js"; +import type { LazyArg } from "./Function.js"; +import type { TypeLambda } from "./HKT.js"; +import type { Inspectable } from "./Inspectable.js"; +import * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import type { Sink } from "./Sink.js"; +import type { Stream } from "./Stream.js"; +import type { Concurrency, Covariant, Equals, NoExcessProperties, NotFunction, Simplify } from "./Types.js"; +import type * as Unify from "./Unify.js"; +import { YieldWrap } from "./Utils.js"; +/** + * @since 3.4.0 + * @experimental + * @category type ids + */ +export declare const TypeId: unique symbol; +/** + * @since 3.4.0 + * @experimental + * @category type ids + */ +export type TypeId = typeof TypeId; +/** + * @since 3.4.0 + * @experimental + * @category MicroExit + */ +export declare const MicroExitTypeId: unique symbol; +/** + * @since 3.4.0 + * @experimental + * @category MicroExit + */ +export type MicroExitTypeId = typeof TypeId; +/** + * A lightweight alternative to the `Effect` data type, with a subset of the functionality. + * + * @since 3.4.0 + * @experimental + * @category models + */ +export interface Micro extends Effect { + readonly [TypeId]: Micro.Variance; + [Symbol.iterator](): MicroIterator>; + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: MicroUnify; + [Unify.ignoreSymbol]?: MicroUnifyIgnore; +} +/** + * @category models + * @since 3.4.3 + */ +export interface MicroUnify extends EffectUnify { + Micro?: () => A[Unify.typeSymbol] extends Micro | infer _ ? Micro : never; +} +/** + * @category models + * @since 3.4.3 + */ +export interface MicroUnifyIgnore extends EffectUnifyIgnore { + Effect?: true; +} +/** + * @category type lambdas + * @since 3.4.1 + */ +export interface MicroTypeLambda extends TypeLambda { + readonly type: Micro; +} +/** + * @since 3.4.0 + * @experimental + */ +export declare namespace Micro { + /** + * @since 3.4.0 + * @experimental + */ + interface Variance { + _A: Covariant; + _E: Covariant; + _R: Covariant; + } + /** + * @since 3.4.0 + * @experimental + */ + type Success = T extends Micro ? _A : never; + /** + * @since 3.4.0 + * @experimental + */ + type Error = T extends Micro ? _E : never; + /** + * @since 3.4.0 + * @experimental + */ + type Context = T extends Micro ? _R : never; +} +/** + * @since 3.4.0 + * @experimental + * @category guards + */ +export declare const isMicro: (u: unknown) => u is Micro; +/** + * @since 3.4.0 + * @experimental + * @category models + */ +export interface MicroIterator> { + next(...args: ReadonlyArray): IteratorResult, Micro.Success>; +} +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const MicroCauseTypeId: unique symbol; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export type MicroCauseTypeId = typeof MicroCauseTypeId; +/** + * A `MicroCause` is a data type that represents the different ways a `Micro` can fail. + * + * **Details** + * + * `MicroCause` comes in three forms: + * + * - `Die`: Indicates an unforeseen defect that wasn't planned for in the system's logic. + * - `Fail`: Covers anticipated errors that are recognized and typically handled within the application. + * - `Interrupt`: Signifies an operation that has been purposefully stopped. + * + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export type MicroCause = MicroCause.Die | MicroCause.Fail | MicroCause.Interrupt; +/** + * @since 3.6.6 + * @experimental + * @category guards + */ +export declare const isMicroCause: (self: unknown) => self is MicroCause; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare namespace MicroCause { + /** + * @since 3.4.6 + * @experimental + */ + type Error = T extends MicroCause.Fail ? E : never; + /** + * @since 3.4.0 + * @experimental + */ + interface Proto extends Pipeable, globalThis.Error { + readonly [MicroCauseTypeId]: { + _E: Covariant; + }; + readonly _tag: Tag; + readonly traces: ReadonlyArray; + } + /** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ + interface Die extends Proto<"Die", never> { + readonly defect: unknown; + } + /** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ + interface Fail extends Proto<"Fail", E> { + readonly error: E; + } + /** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ + interface Interrupt extends Proto<"Interrupt", never> { + } +} +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeFail: (error: E, traces?: ReadonlyArray) => MicroCause; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeDie: (defect: unknown, traces?: ReadonlyArray) => MicroCause; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeInterrupt: (traces?: ReadonlyArray) => MicroCause; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeIsFail: (self: MicroCause) => self is MicroCause.Fail; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeIsDie: (self: MicroCause) => self is MicroCause.Die; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeIsInterrupt: (self: MicroCause) => self is MicroCause.Interrupt; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeSquash: (self: MicroCause) => unknown; +/** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ +export declare const causeWithTrace: { + /** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ + (trace: string): (self: MicroCause) => MicroCause; + /** + * @since 3.4.6 + * @experimental + * @category MicroCause + */ + (self: MicroCause, trace: string): MicroCause; +}; +/** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ +export declare const MicroFiberTypeId: unique symbol; +/** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ +export type MicroFiberTypeId = typeof MicroFiberTypeId; +/** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ +export interface MicroFiber { + readonly [MicroFiberTypeId]: MicroFiber.Variance; + readonly currentOpCount: number; + readonly getRef: (ref: Context.Reference) => A; + readonly context: Context.Context; + readonly addObserver: (cb: (exit: MicroExit) => void) => () => void; + readonly unsafeInterrupt: () => void; + readonly unsafePoll: () => MicroExit | undefined; +} +/** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ +export declare namespace MicroFiber { + /** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ + interface Variance { + readonly _A: Covariant; + readonly _E: Covariant; + } +} +declare class MicroFiberImpl implements MicroFiber { + context: Context.Context; + interruptible: boolean; + readonly [MicroFiberTypeId]: MicroFiber.Variance; + readonly _stack: Array; + readonly _observers: Array<(exit: MicroExit) => void>; + _exit: MicroExit | undefined; + _children: Set> | undefined; + currentOpCount: number; + constructor(context: Context.Context, interruptible?: boolean); + getRef(ref: Context.Reference): A; + addObserver(cb: (exit: MicroExit) => void): () => void; + _interrupted: boolean; + unsafeInterrupt(): void; + unsafePoll(): MicroExit | undefined; + evaluate(effect: Primitive): void; + runLoop(effect: Primitive): MicroExit | Yield; + getCont(symbol: S): (Primitive & Record Primitive>) | undefined; + _yielded: MicroExit | (() => void) | undefined; + yieldWith(value: MicroExit | (() => void)): Yield; + children(): Set>; +} +/** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ +export declare const fiberAwait: (self: MicroFiber) => Micro>; +/** + * @since 3.11.2 + * @experimental + * @category MicroFiber + */ +export declare const fiberJoin: (self: MicroFiber) => Micro; +/** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ +export declare const fiberInterrupt: (self: MicroFiber) => Micro; +/** + * @since 3.11.0 + * @experimental + * @category MicroFiber + */ +export declare const fiberInterruptAll: >>(fibers: A) => Micro; +declare const identifier: unique symbol; +type identifier = typeof identifier; +declare const evaluate: unique symbol; +type evaluate = typeof evaluate; +declare const successCont: unique symbol; +type successCont = typeof successCont; +declare const failureCont: unique symbol; +type failureCont = typeof failureCont; +declare const ensureCont: unique symbol; +type ensureCont = typeof ensureCont; +declare const Yield: unique symbol; +type Yield = typeof Yield; +interface Primitive { + readonly [identifier]: string; + readonly [successCont]: ((value: unknown, fiber: MicroFiberImpl) => Primitive | Yield) | undefined; + readonly [failureCont]: ((cause: MicroCause, fiber: MicroFiberImpl) => Primitive | Yield) | undefined; + readonly [ensureCont]: ((fiber: MicroFiberImpl) => ((value: unknown, fiber: MicroFiberImpl) => Primitive | Yield) | undefined) | undefined; + [evaluate](fiber: MicroFiberImpl): Primitive | Yield; +} +/** + * Creates a `Micro` effect that will succeed with the specified constant value. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const succeed: (value: A) => Micro; +/** + * Creates a `Micro` effect that will fail with the specified `MicroCause`. + * + * @since 3.4.6 + * @experimental + * @category constructors + */ +export declare const failCause: (cause: MicroCause) => Micro; +/** + * Creates a `Micro` effect that fails with the given error. + * + * This results in a `Fail` variant of the `MicroCause` type, where the error is + * tracked at the type level. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const fail: (error: E) => Micro; +/** + * Creates a `Micro` effect that succeeds with a lazily evaluated value. + * + * If the evaluation of the value throws an error, the effect will fail with a + * `Die` variant of the `MicroCause` type. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const sync: (evaluate: LazyArg) => Micro; +/** + * Lazily creates a `Micro` effect from the given side-effect. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const suspend: (evaluate: LazyArg>) => Micro; +/** + * Pause the execution of the current `Micro` effect, and resume it on the next + * scheduler tick. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const yieldNowWith: (priority?: number) => Micro; +/** + * Pause the execution of the current `Micro` effect, and resume it on the next + * scheduler tick. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const yieldNow: Micro; +/** + * Creates a `Micro` effect that will succeed with the value wrapped in `Some`. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const succeedSome: (a: A) => Micro>; +/** + * Creates a `Micro` effect that succeeds with `None`. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const succeedNone: Micro>; +/** + * Creates a `Micro` effect that will fail with the lazily evaluated `MicroCause`. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const failCauseSync: (evaluate: LazyArg>) => Micro; +/** + * Creates a `Micro` effect that will die with the specified error. + * + * This results in a `Die` variant of the `MicroCause` type, where the error is + * not tracked at the type level. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const die: (defect: unknown) => Micro; +/** + * Creates a `Micro` effect that will fail with the lazily evaluated error. + * + * This results in a `Fail` variant of the `MicroCause` type, where the error is + * tracked at the type level. + * + * @since 3.4.6 + * @experimental + * @category constructors + */ +export declare const failSync: (error: LazyArg) => Micro; +/** + * Converts an `Option` into a `Micro` effect, that will fail with + * `NoSuchElementException` if the option is `None`. Otherwise, it will succeed with the + * value of the option. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const fromOption: (option: Option.Option) => Micro; +/** + * Converts an `Either` into a `Micro` effect, that will fail with the left side + * of the either if it is a `Left`. Otherwise, it will succeed with the right + * side of the either. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const fromEither: (either: Either.Either) => Micro; +declare const void_: Micro; +export { +/** + * A `Micro` effect that will succeed with `void` (`undefined`). + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +void_ as void }; +declare const try_: (options: { + try: LazyArg; + catch: (error: unknown) => E; +}) => Micro; +export { +/** + * The `Micro` equivalent of a try / catch block, which allows you to map + * thrown errors to a specific error type. + * + * @example + * ```ts + * import { Micro } from "effect" + * + * Micro.try({ + * try: () => { throw new Error("boom") }, + * catch: (cause) => new Error("caught", { cause }) + * }) + * ``` + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +try_ as try }; +/** + * Wrap a `Promise` into a `Micro` effect. + * + * Any errors will result in a `Die` variant of the `MicroCause` type, where the + * error is not tracked at the type level. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const promise: (evaluate: (signal: AbortSignal) => PromiseLike) => Micro; +/** + * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and + * converted into a specific error type. + * + * @example + * ```ts + * import { Micro } from "effect" + * + * Micro.tryPromise({ + * try: () => Promise.resolve("success"), + * catch: (cause) => new Error("caught", { cause }) + * }) + * ``` + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const tryPromise: (options: { + readonly try: (signal: AbortSignal) => PromiseLike; + readonly catch: (error: unknown) => E; +}) => Micro; +/** + * Create a `Micro` effect using the current `MicroFiber`. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const withMicroFiber: (evaluate: (fiber: MicroFiberImpl) => Micro) => Micro; +/** + * Flush any yielded effects that are waiting to be executed. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const yieldFlush: Micro; +/** + * Create a `Micro` effect from an asynchronous computation. + * + * You can return a cleanup effect that will be run when the effect is aborted. + * It is also passed an `AbortSignal` that is triggered when the effect is + * aborted. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const async: (register: (resume: (effect: Micro) => void, signal: AbortSignal) => void | Micro) => Micro; +/** + * A `Micro` that will never succeed or fail. It wraps `setInterval` to prevent + * the Javascript runtime from exiting. + * + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const never: Micro; +/** + * @since 3.4.0 + * @experimental + * @category constructors + */ +export declare const gen: >, AEff>(...args: [self: Self, body: (this: Self) => Generator] | [body: () => Generator]) => Micro>] ? E : never, [Eff] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>; +/** + * Create a `Micro` effect that will replace the success value of the given + * effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const as: { + /** + * Create a `Micro` effect that will replace the success value of the given + * effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (value: B): (self: Micro) => Micro; + /** + * Create a `Micro` effect that will replace the success value of the given + * effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (self: Micro, value: B): Micro; +}; +/** + * Wrap the success value of this `Micro` effect in a `Some`. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const asSome: (self: Micro) => Micro, E, R>; +/** + * Swap the error and success types of the `Micro` effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const flip: (self: Micro) => Micro; +/** + * A more flexible version of `flatMap` that combines `map` and `flatMap` into a + * single API. + * + * It also lets you directly pass a `Micro` effect, which will be executed after + * the current effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const andThen: { + /** + * A more flexible version of `flatMap` that combines `map` and `flatMap` into a + * single API. + * + * It also lets you directly pass a `Micro` effect, which will be executed after + * the current effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (f: (a: A) => X): (self: Micro) => [X] extends [Micro] ? Micro : Micro; + /** + * A more flexible version of `flatMap` that combines `map` and `flatMap` into a + * single API. + * + * It also lets you directly pass a `Micro` effect, which will be executed after + * the current effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (f: NotFunction): (self: Micro) => [X] extends [Micro] ? Micro : Micro; + /** + * A more flexible version of `flatMap` that combines `map` and `flatMap` into a + * single API. + * + * It also lets you directly pass a `Micro` effect, which will be executed after + * the current effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (self: Micro, f: (a: A) => X): [X] extends [Micro] ? Micro : Micro; + /** + * A more flexible version of `flatMap` that combines `map` and `flatMap` into a + * single API. + * + * It also lets you directly pass a `Micro` effect, which will be executed after + * the current effect. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (self: Micro, f: NotFunction): [X] extends [Micro] ? Micro : Micro; +}; +/** + * Execute a side effect from the success value of the `Micro` effect. + * + * It is similar to the `andThen` api, but the success value is ignored. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const tap: { + /** + * Execute a side effect from the success value of the `Micro` effect. + * + * It is similar to the `andThen` api, but the success value is ignored. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (f: (a: NoInfer) => X): (self: Micro) => [X] extends [Micro] ? Micro : Micro; + /** + * Execute a side effect from the success value of the `Micro` effect. + * + * It is similar to the `andThen` api, but the success value is ignored. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (f: NotFunction): (self: Micro) => [X] extends [Micro] ? Micro : Micro; + /** + * Execute a side effect from the success value of the `Micro` effect. + * + * It is similar to the `andThen` api, but the success value is ignored. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (self: Micro, f: (a: NoInfer) => X): [X] extends [Micro] ? Micro : Micro; + /** + * Execute a side effect from the success value of the `Micro` effect. + * + * It is similar to the `andThen` api, but the success value is ignored. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (self: Micro, f: NotFunction): [X] extends [Micro] ? Micro : Micro; +}; +/** + * Replace the success value of the `Micro` effect with `void`. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const asVoid: (self: Micro) => Micro; +/** + * Access the `MicroExit` of the given `Micro` effect. + * + * @since 3.4.6 + * @experimental + * @category mapping & sequencing + */ +export declare const exit: (self: Micro) => Micro, never, R>; +/** + * Replace the error type of the given `Micro` with the full `MicroCause` object. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const sandbox: (self: Micro) => Micro, R>; +/** + * Returns an effect that races all the specified effects, + * yielding the value of the first effect to succeed with a value. Losers of + * the race will be interrupted immediately + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ +export declare const raceAll: >(all: Iterable) => Micro, Micro.Error, Micro.Context>; +/** + * Returns an effect that races all the specified effects, + * yielding the value of the first effect to succeed or fail. Losers of + * the race will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ +export declare const raceAllFirst: >(all: Iterable) => Micro, Micro.Error, Micro.Context>; +/** + * Returns an effect that races two effects, yielding the value of the first + * effect to succeed. Losers of the race will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ +export declare const race: { + /** + * Returns an effect that races two effects, yielding the value of the first + * effect to succeed. Losers of the race will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ + (that: Micro): (self: Micro) => Micro; + /** + * Returns an effect that races two effects, yielding the value of the first + * effect to succeed. Losers of the race will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ + (self: Micro, that: Micro): Micro; +}; +/** + * Returns an effect that races two effects, yielding the value of the first + * effect to succeed *or* fail. Losers of the race will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ +export declare const raceFirst: { + /** + * Returns an effect that races two effects, yielding the value of the first + * effect to succeed *or* fail. Losers of the race will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ + (that: Micro): (self: Micro) => Micro; + /** + * Returns an effect that races two effects, yielding the value of the first + * effect to succeed *or* fail. Losers of the race will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category sequencing + */ + (self: Micro, that: Micro): Micro; +}; +/** + * Map the success value of this `Micro` effect to another `Micro` effect, then + * flatten the result. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const flatMap: { + /** + * Map the success value of this `Micro` effect to another `Micro` effect, then + * flatten the result. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (f: (a: A) => Micro): (self: Micro) => Micro; + /** + * Map the success value of this `Micro` effect to another `Micro` effect, then + * flatten the result. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (self: Micro, f: (a: A) => Micro): Micro; +}; +/** + * Flattens any nested `Micro` effects, merging the error and requirement types. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const flatten: (self: Micro, E2, R2>) => Micro; +/** + * Transforms the success value of the `Micro` effect with the specified + * function. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ +export declare const map: { + /** + * Transforms the success value of the `Micro` effect with the specified + * function. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (f: (a: A) => B): (self: Micro) => Micro; + /** + * Transforms the success value of the `Micro` effect with the specified + * function. + * + * @since 3.4.0 + * @experimental + * @category mapping & sequencing + */ + (self: Micro, f: (a: A) => B): Micro; +}; +/** + * The `MicroExit` type is used to represent the result of a `Micro` computation. It + * can either be successful, containing a value of type `A`, or it can fail, + * containing an error of type `E` wrapped in a `MicroCause`. + * + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export type MicroExit = MicroExit.Success | MicroExit.Failure; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare namespace MicroExit { + /** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ + interface Proto extends Micro { + readonly [MicroExitTypeId]: MicroExitTypeId; + } + /** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ + interface Success extends Proto { + readonly _tag: "Success"; + readonly value: A; + } + /** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ + interface Failure extends Proto { + readonly _tag: "Failure"; + readonly cause: MicroCause; + } +} +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const isMicroExit: (u: unknown) => u is MicroExit; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitSucceed: (a: A) => MicroExit; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitFailCause: (cause: MicroCause) => MicroExit; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitInterrupt: MicroExit; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitFail: (e: E) => MicroExit; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitDie: (defect: unknown) => MicroExit; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitIsSuccess: (self: MicroExit) => self is MicroExit.Success; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitIsFailure: (self: MicroExit) => self is MicroExit.Failure; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitIsInterrupt: (self: MicroExit) => self is MicroExit.Failure & { + readonly cause: MicroCause.Interrupt; +}; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitIsFail: (self: MicroExit) => self is MicroExit.Failure & { + readonly cause: MicroCause.Fail; +}; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitIsDie: (self: MicroExit) => self is MicroExit.Failure & { + readonly cause: MicroCause.Die; +}; +/** + * @since 3.4.6 + * @experimental + * @category MicroExit + */ +export declare const exitVoid: MicroExit; +/** + * @since 3.11.0 + * @experimental + * @category MicroExit + */ +export declare const exitVoidAll: >>(exits: I) => MicroExit> ? _E : never>; +/** + * @since 3.5.9 + * @experimental + * @category scheduler + */ +export interface MicroScheduler { + readonly scheduleTask: (task: () => void, priority: number) => void; + readonly shouldYield: (fiber: MicroFiber) => boolean; + readonly flush: () => void; +} +/** + * @since 3.5.9 + * @experimental + * @category scheduler + */ +export declare class MicroSchedulerDefault implements MicroScheduler { + private tasks; + private running; + /** + * @since 3.5.9 + */ + scheduleTask(task: () => void, _priority: number): void; + /** + * @since 3.5.9 + */ + afterScheduled: () => void; + /** + * @since 3.5.9 + */ + runTasks(): void; + /** + * @since 3.5.9 + */ + shouldYield(fiber: MicroFiber): boolean; + /** + * @since 3.5.9 + */ + flush(): void; +} +/** + * Access the given `Context.Tag` from the environment. + * + * @since 3.4.0 + * @experimental + * @category environment + */ +export declare const service: { + /** + * Access the given `Context.Tag` from the environment. + * + * @since 3.4.0 + * @experimental + * @category environment + */ + (tag: Context.Reference): Micro; + /** + * Access the given `Context.Tag` from the environment. + * + * @since 3.4.0 + * @experimental + * @category environment + */ + (tag: Context.Tag): Micro; +}; +/** + * Access the given `Context.Tag` from the environment, without tracking the + * dependency at the type level. + * + * It will return an `Option` of the service, depending on whether it is + * available in the environment or not. + * + * @since 3.4.0 + * @experimental + * @category environment + */ +export declare const serviceOption: (tag: Context.Tag) => Micro>; +/** + * Update the Context with the given mapping function. + * + * @since 3.11.0 + * @experimental + * @category environment + */ +export declare const updateContext: { + /** + * Update the Context with the given mapping function. + * + * @since 3.11.0 + * @experimental + * @category environment + */ + (f: (context: Context.Context) => Context.Context>): (self: Micro) => Micro; + /** + * Update the Context with the given mapping function. + * + * @since 3.11.0 + * @experimental + * @category environment + */ + (self: Micro, f: (context: Context.Context) => Context.Context>): Micro; +}; +/** + * Update the service for the given `Context.Tag` in the environment. + * + * @since 3.11.0 + * @experimental + * @category environment + */ +export declare const updateService: { + /** + * Update the service for the given `Context.Tag` in the environment. + * + * @since 3.11.0 + * @experimental + * @category environment + */ + (tag: Context.Reference, f: (value: A) => A): (self: Micro) => Micro; + /** + * Update the service for the given `Context.Tag` in the environment. + * + * @since 3.11.0 + * @experimental + * @category environment + */ + (tag: Context.Tag, f: (value: A) => A): (self: Micro) => Micro; + /** + * Update the service for the given `Context.Tag` in the environment. + * + * @since 3.11.0 + * @experimental + * @category environment + */ + (self: Micro, tag: Context.Reference, f: (value: A) => A): Micro; + /** + * Update the service for the given `Context.Tag` in the environment. + * + * @since 3.11.0 + * @experimental + * @category environment + */ + (self: Micro, tag: Context.Tag, f: (value: A) => A): Micro; +}; +/** + * Access the current `Context` from the environment. + * + * @since 3.4.0 + * @experimental + * @category environment + */ +export declare const context: () => Micro>; +/** + * Merge the given `Context` with the current context. + * + * @since 3.4.0 + * @experimental + * @category environment + */ +export declare const provideContext: { + /** + * Merge the given `Context` with the current context. + * + * @since 3.4.0 + * @experimental + * @category environment + */ + (context: Context.Context): (self: Micro) => Micro>; + /** + * Merge the given `Context` with the current context. + * + * @since 3.4.0 + * @experimental + * @category environment + */ + (self: Micro, context: Context.Context): Micro>; +}; +/** + * Add the provided service to the current context. + * + * @since 3.4.0 + * @experimental + * @category environment + */ +export declare const provideService: { + /** + * Add the provided service to the current context. + * + * @since 3.4.0 + * @experimental + * @category environment + */ + (tag: Context.Tag, service: S): (self: Micro) => Micro>; + /** + * Add the provided service to the current context. + * + * @since 3.4.0 + * @experimental + * @category environment + */ + (self: Micro, tag: Context.Tag, service: S): Micro>; +}; +/** + * Create a service using the provided `Micro` effect, and add it to the + * current context. + * + * @since 3.4.6 + * @experimental + * @category environment + */ +export declare const provideServiceEffect: { + /** + * Create a service using the provided `Micro` effect, and add it to the + * current context. + * + * @since 3.4.6 + * @experimental + * @category environment + */ + (tag: Context.Tag, acquire: Micro): (self: Micro) => Micro | R2>; + /** + * Create a service using the provided `Micro` effect, and add it to the + * current context. + * + * @since 3.4.6 + * @experimental + * @category environment + */ + (self: Micro, tag: Context.Tag, acquire: Micro): Micro | R2>; +}; +declare const MaxOpsBeforeYield_base: Context.ReferenceClass; +/** + * @since 3.11.0 + * @experimental + * @category references + */ +export declare class MaxOpsBeforeYield extends MaxOpsBeforeYield_base { +} +declare const CurrentConcurrency_base: Context.ReferenceClass; +/** + * @since 3.11.0 + * @experimental + * @category environment refs + */ +export declare class CurrentConcurrency extends CurrentConcurrency_base { +} +declare const CurrentScheduler_base: Context.ReferenceClass; +/** + * @since 3.11.0 + * @experimental + * @category environment refs + */ +export declare class CurrentScheduler extends CurrentScheduler_base { +} +/** + * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this + * api to control the concurrency of that `Micro` when it is run. + * + * @example + * ```ts + * import * as Micro from "effect/Micro" + * + * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), { + * concurrency: "inherit" + * }).pipe( + * Micro.withConcurrency(2) // use a concurrency of 2 + * ) + * ``` + * + * @since 3.4.0 + * @experimental + * @category environment refs + */ +export declare const withConcurrency: { + /** + * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this + * api to control the concurrency of that `Micro` when it is run. + * + * @example + * ```ts + * import * as Micro from "effect/Micro" + * + * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), { + * concurrency: "inherit" + * }).pipe( + * Micro.withConcurrency(2) // use a concurrency of 2 + * ) + * ``` + * + * @since 3.4.0 + * @experimental + * @category environment refs + */ + (concurrency: "unbounded" | number): (self: Micro) => Micro; + /** + * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this + * api to control the concurrency of that `Micro` when it is run. + * + * @example + * ```ts + * import * as Micro from "effect/Micro" + * + * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), { + * concurrency: "inherit" + * }).pipe( + * Micro.withConcurrency(2) // use a concurrency of 2 + * ) + * ``` + * + * @since 3.4.0 + * @experimental + * @category environment refs + */ + (self: Micro, concurrency: "unbounded" | number): Micro; +}; +/** + * Combine two `Micro` effects into a single effect that produces a tuple of + * their results. + * + * @since 3.4.0 + * @experimental + * @category zipping + */ +export declare const zip: { + /** + * Combine two `Micro` effects into a single effect that produces a tuple of + * their results. + * + * @since 3.4.0 + * @experimental + * @category zipping + */ + (that: Micro, options?: { + readonly concurrent?: boolean | undefined; + } | undefined): (self: Micro) => Micro<[A, A2], E2 | E, R2 | R>; + /** + * Combine two `Micro` effects into a single effect that produces a tuple of + * their results. + * + * @since 3.4.0 + * @experimental + * @category zipping + */ + (self: Micro, that: Micro, options?: { + readonly concurrent?: boolean | undefined; + }): Micro<[A, A2], E | E2, R | R2>; +}; +/** + * The `Micro.zipWith` function combines two `Micro` effects and allows you to + * apply a function to the results of the combined effects, transforming them + * into a single value. + * + * @since 3.4.3 + * @experimental + * @category zipping + */ +export declare const zipWith: { + /** + * The `Micro.zipWith` function combines two `Micro` effects and allows you to + * apply a function to the results of the combined effects, transforming them + * into a single value. + * + * @since 3.4.3 + * @experimental + * @category zipping + */ + (that: Micro, f: (a: A, b: A2) => B, options?: { + readonly concurrent?: boolean | undefined; + }): (self: Micro) => Micro; + /** + * The `Micro.zipWith` function combines two `Micro` effects and allows you to + * apply a function to the results of the combined effects, transforming them + * into a single value. + * + * @since 3.4.3 + * @experimental + * @category zipping + */ + (self: Micro, that: Micro, f: (a: A, b: A2) => B, options?: { + readonly concurrent?: boolean | undefined; + }): Micro; +}; +/** + * Filter the specified effect with the provided function, failing with specified + * `MicroCause` if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ +export declare const filterOrFailCause: { + /** + * Filter the specified effect with the provided function, failing with specified + * `MicroCause` if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (refinement: Refinement, orFailWith: (a: NoInfer) => MicroCause): (self: Micro) => Micro; + /** + * Filter the specified effect with the provided function, failing with specified + * `MicroCause` if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (predicate: Predicate>, orFailWith: (a: NoInfer) => MicroCause): (self: Micro) => Micro; + /** + * Filter the specified effect with the provided function, failing with specified + * `MicroCause` if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (self: Micro, refinement: Refinement, orFailWith: (a: A) => MicroCause): Micro; + /** + * Filter the specified effect with the provided function, failing with specified + * `MicroCause` if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (self: Micro, predicate: Predicate, orFailWith: (a: A) => MicroCause): Micro; +}; +/** + * Filter the specified effect with the provided function, failing with specified + * error if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ +export declare const filterOrFail: { + /** + * Filter the specified effect with the provided function, failing with specified + * error if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (refinement: Refinement, orFailWith: (a: NoInfer) => E2): (self: Micro) => Micro; + /** + * Filter the specified effect with the provided function, failing with specified + * error if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (predicate: Predicate>, orFailWith: (a: NoInfer) => E2): (self: Micro) => Micro; + /** + * Filter the specified effect with the provided function, failing with specified + * error if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (self: Micro, refinement: Refinement, orFailWith: (a: A) => E2): Micro; + /** + * Filter the specified effect with the provided function, failing with specified + * error if the predicate fails. + * + * In addition to the filtering capabilities discussed earlier, you have the option to further + * refine and narrow down the type of the success channel by providing a + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (self: Micro, predicate: Predicate, orFailWith: (a: A) => E2): Micro; +}; +/** + * The moral equivalent of `if (p) exp`. + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ +export declare const when: { + /** + * The moral equivalent of `if (p) exp`. + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (condition: LazyArg | Micro): (self: Micro) => Micro, E | E2, R | R2>; + /** + * The moral equivalent of `if (p) exp`. + * + * @since 3.4.0 + * @experimental + * @category filtering & conditionals + */ + (self: Micro, condition: LazyArg | Micro): Micro, E | E2, R | R2>; +}; +/** + * Repeat the given `Micro` using the provided options. + * + * The `while` predicate will be checked after each iteration, and can use the + * fall `MicroExit` of the effect to determine if the repetition should continue. + * + * @since 3.4.6 + * @experimental + * @category repetition + */ +export declare const repeatExit: { + /** + * Repeat the given `Micro` using the provided options. + * + * The `while` predicate will be checked after each iteration, and can use the + * fall `MicroExit` of the effect to determine if the repetition should continue. + * + * @since 3.4.6 + * @experimental + * @category repetition + */ + (options: { + while: Predicate>; + times?: number | undefined; + schedule?: MicroSchedule | undefined; + }): (self: Micro) => Micro; + /** + * Repeat the given `Micro` using the provided options. + * + * The `while` predicate will be checked after each iteration, and can use the + * fall `MicroExit` of the effect to determine if the repetition should continue. + * + * @since 3.4.6 + * @experimental + * @category repetition + */ + (self: Micro, options: { + while: Predicate>; + times?: number | undefined; + schedule?: MicroSchedule | undefined; + }): Micro; +}; +/** + * Repeat the given `Micro` effect using the provided options. Only successful + * results will be repeated. + * + * @since 3.4.0 + * @experimental + * @category repetition + */ +export declare const repeat: { + /** + * Repeat the given `Micro` effect using the provided options. Only successful + * results will be repeated. + * + * @since 3.4.0 + * @experimental + * @category repetition + */ + (options?: { + while?: Predicate | undefined; + times?: number | undefined; + schedule?: MicroSchedule | undefined; + } | undefined): (self: Micro) => Micro; + /** + * Repeat the given `Micro` effect using the provided options. Only successful + * results will be repeated. + * + * @since 3.4.0 + * @experimental + * @category repetition + */ + (self: Micro, options?: { + while?: Predicate | undefined; + times?: number | undefined; + schedule?: MicroSchedule | undefined; + } | undefined): Micro; +}; +/** + * Replicates the given effect `n` times. + * + * @since 3.11.0 + * @experimental + * @category repetition + */ +export declare const replicate: { + /** + * Replicates the given effect `n` times. + * + * @since 3.11.0 + * @experimental + * @category repetition + */ + (n: number): (self: Micro) => Array>; + /** + * Replicates the given effect `n` times. + * + * @since 3.11.0 + * @experimental + * @category repetition + */ + (self: Micro, n: number): Array>; +}; +/** + * Performs this effect the specified number of times and collects the + * results. + * + * @since 3.11.0 + * @category repetition + */ +export declare const replicateEffect: { + /** + * Performs this effect the specified number of times and collects the + * results. + * + * @since 3.11.0 + * @category repetition + */ + (n: number, options?: { + readonly concurrency?: Concurrency | undefined; + readonly discard?: false | undefined; + }): (self: Micro) => Micro, E, R>; + /** + * Performs this effect the specified number of times and collects the + * results. + * + * @since 3.11.0 + * @category repetition + */ + (n: number, options: { + readonly concurrency?: Concurrency | undefined; + readonly discard: true; + }): (self: Micro) => Micro; + /** + * Performs this effect the specified number of times and collects the + * results. + * + * @since 3.11.0 + * @category repetition + */ + (self: Micro, n: number, options?: { + readonly concurrency?: Concurrency | undefined; + readonly discard?: false | undefined; + }): Micro, E, R>; + /** + * Performs this effect the specified number of times and collects the + * results. + * + * @since 3.11.0 + * @category repetition + */ + (self: Micro, n: number, options: { + readonly concurrency?: Concurrency | undefined; + readonly discard: true; + }): Micro; +}; +/** + * Repeat the given `Micro` effect forever, only stopping if the effect fails. + * + * @since 3.4.0 + * @experimental + * @category repetition + */ +export declare const forever: (self: Micro) => Micro; +/** + * The `MicroSchedule` type represents a function that can be used to calculate + * the delay between repeats. + * + * The function takes the current attempt number and the elapsed time since the + * first attempt, and returns the delay for the next attempt. If the function + * returns `None`, the repetition will stop. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export type MicroSchedule = (attempt: number, elapsed: number) => Option.Option; +/** + * Create a `MicroSchedule` that will stop repeating after the specified number + * of attempts. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleRecurs: (n: number) => MicroSchedule; +/** + * Create a `MicroSchedule` that will generate a constant delay. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleSpaced: (millis: number) => MicroSchedule; +/** + * Create a `MicroSchedule` that will generate a delay with an exponential backoff. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleExponential: (baseMillis: number, factor?: number) => MicroSchedule; +/** + * Returns a new `MicroSchedule` with an added calculated delay to each delay + * returned by this schedule. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleAddDelay: { + /** + * Returns a new `MicroSchedule` with an added calculated delay to each delay + * returned by this schedule. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (f: () => number): (self: MicroSchedule) => MicroSchedule; + /** + * Returns a new `MicroSchedule` with an added calculated delay to each delay + * returned by this schedule. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (self: MicroSchedule, f: () => number): MicroSchedule; +}; +/** + * Transform a `MicroSchedule` to one that will have a delay that will never exceed + * the specified maximum. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleWithMaxDelay: { + /** + * Transform a `MicroSchedule` to one that will have a delay that will never exceed + * the specified maximum. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (max: number): (self: MicroSchedule) => MicroSchedule; + /** + * Transform a `MicroSchedule` to one that will have a delay that will never exceed + * the specified maximum. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (self: MicroSchedule, max: number): MicroSchedule; +}; +/** + * Transform a `MicroSchedule` to one that will stop repeating after the specified + * amount of time. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleWithMaxElapsed: { + /** + * Transform a `MicroSchedule` to one that will stop repeating after the specified + * amount of time. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (max: number): (self: MicroSchedule) => MicroSchedule; + /** + * Transform a `MicroSchedule` to one that will stop repeating after the specified + * amount of time. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (self: MicroSchedule, max: number): MicroSchedule; +}; +/** + * Combines two `MicroSchedule`s, by recurring if either schedule wants to + * recur, using the minimum of the two durations between recurrences. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleUnion: { + /** + * Combines two `MicroSchedule`s, by recurring if either schedule wants to + * recur, using the minimum of the two durations between recurrences. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule; + /** + * Combines two `MicroSchedule`s, by recurring if either schedule wants to + * recur, using the minimum of the two durations between recurrences. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (self: MicroSchedule, that: MicroSchedule): MicroSchedule; +}; +/** + * Combines two `MicroSchedule`s, by recurring only if both schedules want to + * recur, using the maximum of the two durations between recurrences. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ +export declare const scheduleIntersect: { + /** + * Combines two `MicroSchedule`s, by recurring only if both schedules want to + * recur, using the maximum of the two durations between recurrences. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule; + /** + * Combines two `MicroSchedule`s, by recurring only if both schedules want to + * recur, using the maximum of the two durations between recurrences. + * + * @since 3.4.6 + * @experimental + * @category scheduling + */ + (self: MicroSchedule, that: MicroSchedule): MicroSchedule; +}; +/** + * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to + * recover from any kind of cause. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const catchAllCause: { + /** + * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to + * recover from any kind of cause. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (f: (cause: NoInfer>) => Micro): (self: Micro) => Micro; + /** + * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to + * recover from any kind of cause. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, f: (cause: NoInfer>) => Micro): Micro; +}; +/** + * Selectively catch a `MicroCause` object of the given `Micro` effect, + * using the provided predicate to determine if the failure should be caught. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const catchCauseIf: { + /** + * Selectively catch a `MicroCause` object of the given `Micro` effect, + * using the provided predicate to determine if the failure should be caught. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + >(refinement: Refinement, EB>, f: (cause: EB) => Micro): (self: Micro) => Micro> | E2, R | R2>; + /** + * Selectively catch a `MicroCause` object of the given `Micro` effect, + * using the provided predicate to determine if the failure should be caught. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (predicate: Predicate>>, f: (cause: NoInfer>) => Micro): (self: Micro) => Micro; + /** + * Selectively catch a `MicroCause` object of the given `Micro` effect, + * using the provided predicate to determine if the failure should be caught. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + >(self: Micro, refinement: Refinement, EB>, f: (cause: EB) => Micro): Micro> | E2, R | R2>; + /** + * Selectively catch a `MicroCause` object of the given `Micro` effect, + * using the provided predicate to determine if the failure should be caught. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, predicate: Predicate>>, f: (cause: NoInfer>) => Micro): Micro; +}; +/** + * Catch the error of the given `Micro` effect, allowing you to recover from it. + * + * It only catches expected errors. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const catchAll: { + /** + * Catch the error of the given `Micro` effect, allowing you to recover from it. + * + * It only catches expected errors. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (f: (e: NoInfer) => Micro): (self: Micro) => Micro; + /** + * Catch the error of the given `Micro` effect, allowing you to recover from it. + * + * It only catches expected errors. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, f: (e: NoInfer) => Micro): Micro; +}; +/** + * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const catchAllDefect: { + /** + * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (f: (defect: unknown) => Micro): (self: Micro) => Micro; + /** + * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, f: (defect: unknown) => Micro): Micro; +}; +/** + * Perform a side effect using the full `MicroCause` object of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const tapErrorCause: { + /** + * Perform a side effect using the full `MicroCause` object of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (f: (cause: NoInfer>) => Micro): (self: Micro) => Micro; + /** + * Perform a side effect using the full `MicroCause` object of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, f: (cause: NoInfer>) => Micro): Micro; +}; +/** + * Perform a side effect using if a `MicroCause` object matches the specified + * predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const tapErrorCauseIf: { + /** + * Perform a side effect using if a `MicroCause` object matches the specified + * predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + >(refinement: Refinement, EB>, f: (a: EB) => Micro): (self: Micro) => Micro; + /** + * Perform a side effect using if a `MicroCause` object matches the specified + * predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (predicate: (cause: NoInfer>) => boolean, f: (a: NoInfer>) => Micro): (self: Micro) => Micro; + /** + * Perform a side effect using if a `MicroCause` object matches the specified + * predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + >(self: Micro, refinement: Refinement, EB>, f: (a: EB) => Micro): Micro; + /** + * Perform a side effect using if a `MicroCause` object matches the specified + * predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, predicate: (cause: NoInfer>) => boolean, f: (a: NoInfer>) => Micro): Micro; +}; +/** + * Perform a side effect from expected errors of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const tapError: { + /** + * Perform a side effect from expected errors of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (f: (e: NoInfer) => Micro): (self: Micro) => Micro; + /** + * Perform a side effect from expected errors of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, f: (e: NoInfer) => Micro): Micro; +}; +/** + * Perform a side effect from unexpected errors of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const tapDefect: { + /** + * Perform a side effect from unexpected errors of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (f: (defect: unknown) => Micro): (self: Micro) => Micro; + /** + * Perform a side effect from unexpected errors of the given `Micro`. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, f: (defect: unknown) => Micro): Micro; +}; +/** + * Catch any expected errors that match the specified predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const catchIf: { + /** + * Catch any expected errors that match the specified predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (refinement: Refinement, EB>, f: (e: EB) => Micro): (self: Micro) => Micro, R2 | R>; + /** + * Catch any expected errors that match the specified predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (predicate: Predicate>, f: (e: NoInfer) => Micro): (self: Micro) => Micro; + /** + * Catch any expected errors that match the specified predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, refinement: Refinement, f: (e: EB) => Micro): Micro, R | R2>; + /** + * Catch any expected errors that match the specified predicate. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, predicate: Predicate, f: (e: E) => Micro): Micro; +}; +/** + * Recovers from the specified tagged error. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const catchTag: { + /** + * Recovers from the specified tagged error. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (k: K, f: (e: Extract) => Micro): (self: Micro) => Micro, R1 | R>; + /** + * Recovers from the specified tagged error. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, k: K, f: (e: Extract) => Micro): Micro, R | R1>; +}; +/** + * Transform the full `MicroCause` object of the given `Micro` effect. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ +export declare const mapErrorCause: { + /** + * Transform the full `MicroCause` object of the given `Micro` effect. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (f: (e: MicroCause) => MicroCause): (self: Micro) => Micro; + /** + * Transform the full `MicroCause` object of the given `Micro` effect. + * + * @since 3.4.6 + * @experimental + * @category error handling + */ + (self: Micro, f: (e: MicroCause) => MicroCause): Micro; +}; +/** + * Transform any expected errors of the given `Micro` effect. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const mapError: { + /** + * Transform any expected errors of the given `Micro` effect. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (f: (e: E) => E2): (self: Micro) => Micro; + /** + * Transform any expected errors of the given `Micro` effect. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, f: (e: E) => E2): Micro; +}; +/** + * Elevate any expected errors of the given `Micro` effect to unexpected errors, + * resulting in an error type of `never`. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const orDie: (self: Micro) => Micro; +/** + * Recover from all errors by succeeding with the given value. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const orElseSucceed: { + /** + * Recover from all errors by succeeding with the given value. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (f: LazyArg): (self: Micro) => Micro; + /** + * Recover from all errors by succeeding with the given value. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, f: LazyArg): Micro; +}; +/** + * Ignore any expected errors of the given `Micro` effect, returning `void`. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const ignore: (self: Micro) => Micro; +/** + * Ignore any expected errors of the given `Micro` effect, returning `void`. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const ignoreLogged: (self: Micro) => Micro; +/** + * Replace the success value of the given `Micro` effect with an `Option`, + * wrapping the success value in `Some` and returning `None` if the effect fails + * with an expected error. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const option: (self: Micro) => Micro, never, R>; +/** + * Replace the success value of the given `Micro` effect with an `Either`, + * wrapping the success value in `Right` and wrapping any expected errors with + * a `Left`. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const either: (self: Micro) => Micro, never, R>; +/** + * Retry the given `Micro` effect using the provided options. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const retry: { + /** + * Retry the given `Micro` effect using the provided options. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (options?: { + while?: Predicate | undefined; + times?: number | undefined; + schedule?: MicroSchedule | undefined; + } | undefined): (self: Micro) => Micro; + /** + * Retry the given `Micro` effect using the provided options. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, options?: { + while?: Predicate | undefined; + times?: number | undefined; + schedule?: MicroSchedule | undefined; + } | undefined): Micro; +}; +/** + * Add a stack trace to any failures that occur in the effect. The trace will be + * added to the `traces` field of the `MicroCause` object. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ +export declare const withTrace: { + /** + * Add a stack trace to any failures that occur in the effect. The trace will be + * added to the `traces` field of the `MicroCause` object. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (name: string): (self: Micro) => Micro; + /** + * Add a stack trace to any failures that occur in the effect. The trace will be + * added to the `traces` field of the `MicroCause` object. + * + * @since 3.4.0 + * @experimental + * @category error handling + */ + (self: Micro, name: string): Micro; +}; +/** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ +export declare const matchCauseEffect: { + /** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ + (options: { + readonly onFailure: (cause: MicroCause) => Micro; + readonly onSuccess: (a: A) => Micro; + }): (self: Micro) => Micro; + /** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ + (self: Micro, options: { + readonly onFailure: (cause: MicroCause) => Micro; + readonly onSuccess: (a: A) => Micro; + }): Micro; +}; +/** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ +export declare const matchCause: { + /** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ + (options: { + readonly onFailure: (cause: MicroCause) => A2; + readonly onSuccess: (a: A) => A3; + }): (self: Micro) => Micro; + /** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ + (self: Micro, options: { + readonly onFailure: (cause: MicroCause) => A2; + readonly onSuccess: (a: A) => A3; + }): Micro; +}; +/** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ +export declare const matchEffect: { + /** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ + (options: { + readonly onFailure: (e: E) => Micro; + readonly onSuccess: (a: A) => Micro; + }): (self: Micro) => Micro; + /** + * @since 3.4.6 + * @experimental + * @category pattern matching + */ + (self: Micro, options: { + readonly onFailure: (e: E) => Micro; + readonly onSuccess: (a: A) => Micro; + }): Micro; +}; +/** + * @since 3.4.0 + * @experimental + * @category pattern matching + */ +export declare const match: { + /** + * @since 3.4.0 + * @experimental + * @category pattern matching + */ + (options: { + readonly onFailure: (error: E) => A2; + readonly onSuccess: (value: A) => A3; + }): (self: Micro) => Micro; + /** + * @since 3.4.0 + * @experimental + * @category pattern matching + */ + (self: Micro, options: { + readonly onFailure: (error: E) => A2; + readonly onSuccess: (value: A) => A3; + }): Micro; +}; +/** + * Create a `Micro` effect that will sleep for the specified duration. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ +export declare const sleep: (millis: number) => Micro; +/** + * Returns an effect that will delay the execution of this effect by the + * specified duration. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ +export declare const delay: { + /** + * Returns an effect that will delay the execution of this effect by the + * specified duration. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (millis: number): (self: Micro) => Micro; + /** + * Returns an effect that will delay the execution of this effect by the + * specified duration. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (self: Micro, millis: number): Micro; +}; +/** + * Returns an effect that will timeout this effect, that will execute the + * fallback effect if the timeout elapses before the effect has produced a value. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ +export declare const timeoutOrElse: { + /** + * Returns an effect that will timeout this effect, that will execute the + * fallback effect if the timeout elapses before the effect has produced a value. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (options: { + readonly duration: number; + readonly onTimeout: LazyArg>; + }): (self: Micro) => Micro; + /** + * Returns an effect that will timeout this effect, that will execute the + * fallback effect if the timeout elapses before the effect has produced a value. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (self: Micro, options: { + readonly duration: number; + readonly onTimeout: LazyArg>; + }): Micro; +}; +/** + * Returns an effect that will timeout this effect, that will fail with a + * `TimeoutException` if the timeout elapses before the effect has produced a + * value. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ +export declare const timeout: { + /** + * Returns an effect that will timeout this effect, that will fail with a + * `TimeoutException` if the timeout elapses before the effect has produced a + * value. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (millis: number): (self: Micro) => Micro; + /** + * Returns an effect that will timeout this effect, that will fail with a + * `TimeoutException` if the timeout elapses before the effect has produced a + * value. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (self: Micro, millis: number): Micro; +}; +/** + * Returns an effect that will timeout this effect, succeeding with a `None` + * if the timeout elapses before the effect has produced a value; and `Some` of + * the produced value otherwise. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ +export declare const timeoutOption: { + /** + * Returns an effect that will timeout this effect, succeeding with a `None` + * if the timeout elapses before the effect has produced a value; and `Some` of + * the produced value otherwise. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (millis: number): (self: Micro) => Micro, E, R>; + /** + * Returns an effect that will timeout this effect, succeeding with a `None` + * if the timeout elapses before the effect has produced a value; and `Some` of + * the produced value otherwise. + * + * If the timeout elapses, the running effect will be safely interrupted. + * + * @since 3.4.0 + * @experimental + * @category delays & timeouts + */ + (self: Micro, millis: number): Micro, E, R>; +}; +/** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const MicroScopeTypeId: unique symbol; +/** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export type MicroScopeTypeId = typeof MicroScopeTypeId; +/** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export interface MicroScope { + readonly [MicroScopeTypeId]: MicroScopeTypeId; + readonly addFinalizer: (finalizer: (exit: MicroExit) => Micro) => Micro; + readonly fork: Micro; +} +/** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare namespace MicroScope { + /** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ + interface Closeable extends MicroScope { + readonly close: (exit: MicroExit) => Micro; + } +} +/** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const MicroScope: Context.Tag; +/** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const scopeMake: Micro; +/** + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const scopeUnsafeMake: () => MicroScope.Closeable; +/** + * Access the current `MicroScope`. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const scope: Micro; +/** + * Provide a `MicroScope` to an effect. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const provideScope: { + /** + * Provide a `MicroScope` to an effect. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ + (scope: MicroScope): (self: Micro) => Micro>; + /** + * Provide a `MicroScope` to an effect. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ + (self: Micro, scope: MicroScope): Micro>; +}; +/** + * Provide a `MicroScope` to the given effect, closing it after the effect has + * finished executing. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const scoped: (self: Micro) => Micro>; +/** + * Create a resource with a cleanup `Micro` effect, ensuring the cleanup is + * executed when the `MicroScope` is closed. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const acquireRelease: (acquire: Micro, release: (a: A, exit: MicroExit) => Micro) => Micro; +/** + * Add a finalizer to the current `MicroScope`. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const addFinalizer: (finalizer: (exit: MicroExit) => Micro) => Micro; +/** + * When the `Micro` effect is completed, run the given finalizer effect with the + * `MicroExit` of the executed effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ +export declare const onExit: { + /** + * When the `Micro` effect is completed, run the given finalizer effect with the + * `MicroExit` of the executed effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (f: (exit: MicroExit) => Micro): (self: Micro) => Micro; + /** + * When the `Micro` effect is completed, run the given finalizer effect with the + * `MicroExit` of the executed effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (self: Micro, f: (exit: MicroExit) => Micro): Micro; +}; +/** + * Regardless of the result of the this `Micro` effect, run the finalizer effect. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const ensuring: { + /** + * Regardless of the result of the this `Micro` effect, run the finalizer effect. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ + (finalizer: Micro): (self: Micro) => Micro; + /** + * Regardless of the result of the this `Micro` effect, run the finalizer effect. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ + (self: Micro, finalizer: Micro): Micro; +}; +/** + * When the `Micro` effect is completed, run the given finalizer effect if it + * matches the specified predicate. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ +export declare const onExitIf: { + /** + * When the `Micro` effect is completed, run the given finalizer effect if it + * matches the specified predicate. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + >(refinement: Refinement, B>, f: (exit: B) => Micro): (self: Micro) => Micro; + /** + * When the `Micro` effect is completed, run the given finalizer effect if it + * matches the specified predicate. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (predicate: Predicate, NoInfer>>, f: (exit: MicroExit, NoInfer>) => Micro): (self: Micro) => Micro; + /** + * When the `Micro` effect is completed, run the given finalizer effect if it + * matches the specified predicate. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + >(self: Micro, refinement: Refinement, B>, f: (exit: B) => Micro): Micro; + /** + * When the `Micro` effect is completed, run the given finalizer effect if it + * matches the specified predicate. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (self: Micro, predicate: Predicate, NoInfer>>, f: (exit: MicroExit, NoInfer>) => Micro): Micro; +}; +/** + * When the `Micro` effect fails, run the given finalizer effect with the + * `MicroCause` of the executed effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ +export declare const onError: { + /** + * When the `Micro` effect fails, run the given finalizer effect with the + * `MicroCause` of the executed effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (f: (cause: MicroCause>) => Micro): (self: Micro) => Micro; + /** + * When the `Micro` effect fails, run the given finalizer effect with the + * `MicroCause` of the executed effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (self: Micro, f: (cause: MicroCause>) => Micro): Micro; +}; +/** + * If this `Micro` effect is aborted, run the finalizer effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ +export declare const onInterrupt: { + /** + * If this `Micro` effect is aborted, run the finalizer effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (finalizer: Micro): (self: Micro) => Micro; + /** + * If this `Micro` effect is aborted, run the finalizer effect. + * + * @since 3.4.6 + * @experimental + * @category resources & finalization + */ + (self: Micro, finalizer: Micro): Micro; +}; +/** + * Acquire a resource, use it, and then release the resource when the `use` + * effect has completed. + * + * @since 3.4.0 + * @experimental + * @category resources & finalization + */ +export declare const acquireUseRelease: (acquire: Micro, use: (a: Resource) => Micro, release: (a: Resource, exit: MicroExit) => Micro) => Micro; +/** + * Abort the current `Micro` effect. + * + * @since 3.4.6 + * @experimental + * @category interruption + */ +export declare const interrupt: Micro; +/** + * Flag the effect as uninterruptible, which means that when the effect is + * interrupted, it will be allowed to continue running until completion. + * + * @since 3.4.0 + * @experimental + * @category flags + */ +export declare const uninterruptible: (self: Micro) => Micro; +/** + * Flag the effect as interruptible, which means that when the effect is + * interrupted, it will be interrupted immediately. + * + * @since 3.4.0 + * @experimental + * @category flags + */ +export declare const interruptible: (self: Micro) => Micro; +/** + * Wrap the given `Micro` effect in an uninterruptible region, preventing the + * effect from being aborted. + * + * You can use the `restore` function to restore a `Micro` effect to the + * interruptibility state before the `uninterruptibleMask` was applied. + * + * @example + * ```ts + * import * as Micro from "effect/Micro" + * + * Micro.uninterruptibleMask((restore) => + * Micro.sleep(1000).pipe( // uninterruptible + * Micro.andThen(restore(Micro.sleep(1000))) // interruptible + * ) + * ) + * ``` + * + * @since 3.4.0 + * @experimental + * @category interruption + */ +export declare const uninterruptibleMask: (f: (restore: (effect: Micro) => Micro) => Micro) => Micro; +/** + * @since 3.4.0 + * @experimental + */ +export declare namespace All { + /** + * @since 3.4.0 + * @experimental + */ + type MicroAny = Micro; + /** + * @since 3.4.0 + * @experimental + */ + type ReturnIterable, Discard extends boolean> = [T] extends [ + Iterable> + ] ? Micro, E, R> : never; + /** + * @since 3.4.0 + * @experimental + */ + type ReturnTuple, Discard extends boolean> = Micro ? _A : never; + }, T[number] extends never ? never : T[number] extends Micro ? _E : never, T[number] extends never ? never : T[number] extends Micro ? _R : never> extends infer X ? X : never; + /** + * @since 3.4.0 + * @experimental + */ + type ReturnObject = [T] extends [{ + [K: string]: MicroAny; + }] ? Micro] ? _A : never; + }, keyof T extends never ? never : T[keyof T] extends Micro ? _E : never, keyof T extends never ? never : T[keyof T] extends Micro ? _R : never> : never; + /** + * @since 3.4.0 + * @experimental + */ + type IsDiscard = [Extract] extends [never] ? false : true; + /** + * @since 3.4.0 + * @experimental + */ + type Return | Record, O extends NoExcessProperties<{ + readonly concurrency?: Concurrency | undefined; + readonly discard?: boolean | undefined; + }, O>> = [Arg] extends [ReadonlyArray] ? ReturnTuple> : [Arg] extends [Iterable] ? ReturnIterable> : [Arg] extends [Record] ? ReturnObject> : never; +} +/** + * Runs all the provided effects in sequence respecting the structure provided in input. + * + * Supports multiple arguments, a single argument tuple / array or record / struct. + * + * @since 3.4.0 + * @experimental + * @category collecting & elements + */ +export declare const all: > | Record>, O extends NoExcessProperties<{ + readonly concurrency?: Concurrency | undefined; + readonly discard?: boolean | undefined; +}, O>>(arg: Arg, options?: O) => All.Return; +/** + * @since 3.11.0 + * @experimental + * @category collecting & elements + */ +export declare const whileLoop: (options: { + readonly while: LazyArg; + readonly body: LazyArg>; + readonly step: (a: A) => void; +}) => Micro; +/** + * For each element of the provided iterable, run the effect and collect the + * results. + * + * If the `discard` option is set to `true`, the results will be discarded and + * the effect will return `void`. + * + * The `concurrency` option can be set to control how many effects are run + * concurrently. By default, the effects are run sequentially. + * + * @since 3.4.0 + * @experimental + * @category collecting & elements + */ +export declare const forEach: { + /** + * For each element of the provided iterable, run the effect and collect the + * results. + * + * If the `discard` option is set to `true`, the results will be discarded and + * the effect will return `void`. + * + * The `concurrency` option can be set to control how many effects are run + * concurrently. By default, the effects are run sequentially. + * + * @since 3.4.0 + * @experimental + * @category collecting & elements + */ + (iterable: Iterable, f: (a: A, index: number) => Micro, options?: { + readonly concurrency?: Concurrency | undefined; + readonly discard?: false | undefined; + }): Micro, E, R>; + /** + * For each element of the provided iterable, run the effect and collect the + * results. + * + * If the `discard` option is set to `true`, the results will be discarded and + * the effect will return `void`. + * + * The `concurrency` option can be set to control how many effects are run + * concurrently. By default, the effects are run sequentially. + * + * @since 3.4.0 + * @experimental + * @category collecting & elements + */ + (iterable: Iterable, f: (a: A, index: number) => Micro, options: { + readonly concurrency?: Concurrency | undefined; + readonly discard: true; + }): Micro; +}; +/** + * Effectfully filter the elements of the provided iterable. + * + * Use the `concurrency` option to control how many elements are processed + * concurrently. + * + * @since 3.4.0 + * @experimental + * @category collecting & elements + */ +export declare const filter: (iterable: Iterable, f: (a: NoInfer) => Micro, options?: { + readonly concurrency?: Concurrency | undefined; + readonly negate?: boolean | undefined; +}) => Micro, E, R>; +/** + * Effectfully filter the elements of the provided iterable. + * + * Use the `concurrency` option to control how many elements are processed + * concurrently. + * + * @since 3.4.0 + * @experimental + * @category collecting & elements + */ +export declare const filterMap: (iterable: Iterable, f: (a: NoInfer) => Micro, E, R>, options?: { + readonly concurrency?: Concurrency | undefined; +}) => Micro, E, R>; +/** + * Start a do notation block. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ +export declare const Do: Micro<{}>; +/** + * Bind the success value of this `Micro` effect to the provided name. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ +export declare const bindTo: { + /** + * Bind the success value of this `Micro` effect to the provided name. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ + (name: N): (self: Micro) => Micro<{ + [K in N]: A; + }, E, R>; + /** + * Bind the success value of this `Micro` effect to the provided name. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ + (self: Micro, name: N): Micro<{ + [K in N]: A; + }, E, R>; +}; +/** + * Bind the success value of this `Micro` effect to the provided name. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ +export declare const bind: { + /** + * Bind the success value of this `Micro` effect to the provided name. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ + , B, E2, R2>(name: N, f: (a: NoInfer) => Micro): (self: Micro) => Micro & { + [K in N]: B; + }>, E | E2, R | R2>; + /** + * Bind the success value of this `Micro` effect to the provided name. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ + , E, R, B, E2, R2, N extends string>(self: Micro, name: N, f: (a: NoInfer) => Micro): Micro & { + [K in N]: B; + }>, E | E2, R | R2>; +}; +declare const let_: { + , B>(name: N, f: (a: NoInfer) => B): (self: Micro) => Micro & { + [K in N]: B; + }>, E, R>; + , E, R, B, N extends string>(self: Micro, name: N, f: (a: NoInfer) => B): Micro & { + [K in N]: B; + }>, E, R>; +}; +export { +/** + * Bind the result of a synchronous computation to the given name. + * + * @since 3.4.0 + * @experimental + * @category do notation + */ +let_ as let }; +/** + * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or + * aborted. + * + * When the parent `Micro` finishes, this `Micro` will be aborted. + * + * @since 3.4.0 + * @experimental + * @category fiber & forking + */ +export declare const fork: (self: Micro) => Micro, never, R>; +/** + * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or + * aborted. + * + * It will not be aborted when the parent `Micro` finishes. + * + * @since 3.4.0 + * @experimental + * @category fiber & forking + */ +export declare const forkDaemon: (self: Micro) => Micro, never, R>; +/** + * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or + * aborted. + * + * The lifetime of the handle will be attached to the provided `MicroScope`. + * + * @since 3.4.0 + * @experimental + * @category fiber & forking + */ +export declare const forkIn: { + /** + * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or + * aborted. + * + * The lifetime of the handle will be attached to the provided `MicroScope`. + * + * @since 3.4.0 + * @experimental + * @category fiber & forking + */ + (scope: MicroScope): (self: Micro) => Micro, never, R>; + /** + * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or + * aborted. + * + * The lifetime of the handle will be attached to the provided `MicroScope`. + * + * @since 3.4.0 + * @experimental + * @category fiber & forking + */ + (self: Micro, scope: MicroScope): Micro, never, R>; +}; +/** + * Run the `Micro` effect in a new `MicroFiber` that can be awaited, joined, or + * aborted. + * + * The lifetime of the handle will be attached to the current `MicroScope`. + * + * @since 3.4.0 + * @experimental + * @category fiber & forking + */ +export declare const forkScoped: (self: Micro) => Micro, never, R | MicroScope>; +/** + * Execute the `Micro` effect and return a `MicroFiber` that can be awaited, joined, + * or aborted. + * + * You can listen for the result by adding an observer using the handle's + * `addObserver` method. + * + * @example + * ```ts + * import * as Micro from "effect/Micro" + * + * const handle = Micro.succeed(42).pipe( + * Micro.delay(1000), + * Micro.runFork + * ) + * + * handle.addObserver((exit) => { + * console.log(exit) + * }) + * ``` + * + * @since 3.4.0 + * @experimental + * @category execution + */ +export declare const runFork: (effect: Micro, options?: { + readonly signal?: AbortSignal | undefined; + readonly scheduler?: MicroScheduler | undefined; +} | undefined) => MicroFiberImpl; +/** + * Execute the `Micro` effect and return a `Promise` that resolves with the + * `MicroExit` of the computation. + * + * @since 3.4.6 + * @experimental + * @category execution + */ +export declare const runPromiseExit: (effect: Micro, options?: { + readonly signal?: AbortSignal | undefined; + readonly scheduler?: MicroScheduler | undefined; +} | undefined) => Promise>; +/** + * Execute the `Micro` effect and return a `Promise` that resolves with the + * successful value of the computation. + * + * @since 3.4.0 + * @experimental + * @category execution + */ +export declare const runPromise: (effect: Micro, options?: { + readonly signal?: AbortSignal | undefined; + readonly scheduler?: MicroScheduler | undefined; +} | undefined) => Promise; +/** + * Attempt to execute the `Micro` effect synchronously and return the `MicroExit`. + * + * If any asynchronous effects are encountered, the function will return a + * `CauseDie` containing the `MicroFiber`. + * + * @since 3.4.6 + * @experimental + * @category execution + */ +export declare const runSyncExit: (effect: Micro) => MicroExit; +/** + * Attempt to execute the `Micro` effect synchronously and return the success + * value. + * + * @since 3.4.0 + * @experimental + * @category execution + */ +export declare const runSync: (effect: Micro) => A; +/** + * @since 3.4.0 + * @experimental + * @category errors + */ +export interface YieldableError extends Pipeable, Inspectable, Readonly { + readonly [Effectable.EffectTypeId]: Effect.VarianceStruct; + readonly [Effectable.StreamTypeId]: Stream.VarianceStruct; + readonly [Effectable.SinkTypeId]: Sink.VarianceStruct; + readonly [Effectable.ChannelTypeId]: Channel.VarianceStruct; + readonly [TypeId]: Micro.Variance; + [Symbol.iterator](): MicroIterator>; +} +/** + * @since 3.4.0 + * @experimental + * @category errors + */ +export declare const Error: new = {}>(args: Equals extends true ? void : { + readonly [P in keyof A]: A[P]; +}) => YieldableError & Readonly; +/** + * @since 3.4.0 + * @experimental + * @category errors + */ +export declare const TaggedError: (tag: Tag) => new = {}>(args: Equals extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & { + readonly _tag: Tag; +} & Readonly; +declare const NoSuchElementException_base: new = {}>(args: Equals extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & { + readonly _tag: "NoSuchElementException"; +} & Readonly; +/** + * Represents a checked exception which occurs when an expected element was + * unable to be found. + * + * @since 3.4.4 + * @experimental + * @category errors + */ +export declare class NoSuchElementException extends NoSuchElementException_base<{ + message?: string | undefined; +}> { +} +declare const TimeoutException_base: new = {}>(args: Equals extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & { + readonly _tag: "TimeoutException"; +} & Readonly; +/** + * Represents a checked exception which occurs when a timeout occurs. + * + * @since 3.4.4 + * @experimental + * @category errors + */ +export declare class TimeoutException extends TimeoutException_base { +} +//# sourceMappingURL=Micro.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Micro.d.ts.map b/backend/node_modules/effect/dist/dts/Micro.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..05eb0c8e229577c8b65f78cae7442466fcf0c533 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Micro.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Micro.d.ts","sourceRoot":"","sources":["../../src/Micro.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ModuleVersion.d.ts.map b/backend/node_modules/effect/dist/dts/ModuleVersion.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..785ffb6ce4e88cd083833c870283cc134ecbcf0b --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ModuleVersion.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ModuleVersion.d.ts","sourceRoot":"","sources":["../../src/ModuleVersion.ts"],"names":[],"mappings":"AAOA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,MAAmC,CAAA;AAEzE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAiC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MutableHashMap.d.ts.map b/backend/node_modules/effect/dist/dts/MutableHashMap.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..63d5f3af68d47bb8a1935124e830d584c95566de --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MutableHashMap.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MutableHashMap.d.ts","sourceRoot":"","sources":["../../src/MutableHashMap.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MutableHashSet.d.ts.map b/backend/node_modules/effect/dist/dts/MutableHashSet.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..016937ea97e27308bd2736b5bd73e128a4b9e64c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MutableHashSet.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MutableHashSet.d.ts","sourceRoot":"","sources":["../../src/MutableHashSet.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MutableList.d.ts.map b/backend/node_modules/effect/dist/dts/MutableList.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6a0711a650a1890c1041b0d4e2e15055ce260d30 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MutableList.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MutableList.d.ts","sourceRoot":"","sources":["../../src/MutableList.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MutableQueue.d.ts.map b/backend/node_modules/effect/dist/dts/MutableQueue.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6eabf14de3721806e08e683033dbe161e86c0ff0 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MutableQueue.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MutableQueue.d.ts","sourceRoot":"","sources":["../../src/MutableQueue.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MutableRef.d.ts b/backend/node_modules/effect/dist/dts/MutableRef.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..42c91e9196f44fcd0b54ac37727cf404badef023 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MutableRef.d.ts @@ -0,0 +1,175 @@ +import { type Inspectable } from "./Inspectable.js"; +import type { Pipeable } from "./Pipeable.js"; +declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface MutableRef extends Pipeable, Inspectable { + readonly [TypeId]: TypeId; + current: T; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (value: T) => MutableRef; +/** + * @since 2.0.0 + * @category general + */ +export declare const compareAndSet: { + /** + * @since 2.0.0 + * @category general + */ + (oldValue: T, newValue: T): (self: MutableRef) => boolean; + /** + * @since 2.0.0 + * @category general + */ + (self: MutableRef, oldValue: T, newValue: T): boolean; +}; +/** + * @since 2.0.0 + * @category numeric + */ +export declare const decrement: (self: MutableRef) => MutableRef; +/** + * @since 2.0.0 + * @category numeric + */ +export declare const decrementAndGet: (self: MutableRef) => number; +/** + * @since 2.0.0 + * @category general + */ +export declare const get: (self: MutableRef) => T; +/** + * @since 2.0.0 + * @category numeric + */ +export declare const getAndDecrement: (self: MutableRef) => number; +/** + * @since 2.0.0 + * @category numeric + */ +export declare const getAndIncrement: (self: MutableRef) => number; +/** + * @since 2.0.0 + * @category general + */ +export declare const getAndSet: { + /** + * @since 2.0.0 + * @category general + */ + (value: T): (self: MutableRef) => T; + /** + * @since 2.0.0 + * @category general + */ + (self: MutableRef, value: T): T; +}; +/** + * @since 2.0.0 + * @category general + */ +export declare const getAndUpdate: { + /** + * @since 2.0.0 + * @category general + */ + (f: (value: T) => T): (self: MutableRef) => T; + /** + * @since 2.0.0 + * @category general + */ + (self: MutableRef, f: (value: T) => T): T; +}; +/** + * @since 2.0.0 + * @category numeric + */ +export declare const increment: (self: MutableRef) => MutableRef; +/** + * @since 2.0.0 + * @category numeric + */ +export declare const incrementAndGet: (self: MutableRef) => number; +/** + * @since 2.0.0 + * @category general + */ +export declare const set: { + /** + * @since 2.0.0 + * @category general + */ + (value: T): (self: MutableRef) => MutableRef; + /** + * @since 2.0.0 + * @category general + */ + (self: MutableRef, value: T): MutableRef; +}; +/** + * @since 2.0.0 + * @category general + */ +export declare const setAndGet: { + /** + * @since 2.0.0 + * @category general + */ + (value: T): (self: MutableRef) => T; + /** + * @since 2.0.0 + * @category general + */ + (self: MutableRef, value: T): T; +}; +/** + * @since 2.0.0 + * @category general + */ +export declare const update: { + /** + * @since 2.0.0 + * @category general + */ + (f: (value: T) => T): (self: MutableRef) => MutableRef; + /** + * @since 2.0.0 + * @category general + */ + (self: MutableRef, f: (value: T) => T): MutableRef; +}; +/** + * @since 2.0.0 + * @category general + */ +export declare const updateAndGet: { + /** + * @since 2.0.0 + * @category general + */ + (f: (value: T) => T): (self: MutableRef) => T; + /** + * @since 2.0.0 + * @category general + */ + (self: MutableRef, f: (value: T) => T): T; +}; +/** + * @since 2.0.0 + * @category boolean + */ +export declare const toggle: (self: MutableRef) => MutableRef; +export {}; +//# sourceMappingURL=MutableRef.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/MutableRef.d.ts.map b/backend/node_modules/effect/dist/dts/MutableRef.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..775b7c594efb0d33c75a5316eb7a8300f835d4e3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/MutableRef.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"MutableRef.d.ts","sourceRoot":"","sources":["../../src/MutableRef.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/NonEmptyIterable.d.ts b/backend/node_modules/effect/dist/dts/NonEmptyIterable.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1bc7ad4c9b114ed23c34adc9d78cc68895222fde --- /dev/null +++ b/backend/node_modules/effect/dist/dts/NonEmptyIterable.d.ts @@ -0,0 +1,21 @@ +/** + * @since 2.0.0 + */ +/** + * @category symbol + * @since 2.0.0 + */ +export declare const nonEmpty: unique symbol; +/** + * @category model + * @since 2.0.0 + */ +export interface NonEmptyIterable extends Iterable { + readonly [nonEmpty]: A; +} +/** + * @category getters + * @since 2.0.0 + */ +export declare const unprepend: (self: NonEmptyIterable) => [firstElement: A, remainingElements: Iterator]; +//# sourceMappingURL=NonEmptyIterable.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Number.d.ts b/backend/node_modules/effect/dist/dts/Number.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..38d9a0f07575b43a9fb42054880efad81a1f1605 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Number.d.ts @@ -0,0 +1,1361 @@ +/** + * # Number + * + * This module provides utility functions and type class instances for working + * with the `number` type in TypeScript. It includes functions for basic + * arithmetic operations, as well as type class instances for `Equivalence` and + * `Order`. + * + * ## Operations Reference + * + * | Category | Operation | Description | Domain | Co-domain | + * | ------------ | ------------------------------------------ | ------------------------------------------------------- | ------------------------------ | --------------------- | + * | constructors | {@link module:Number.parse} | Safely parses a string to a number | `string` | `Option` | + * | | | | | | + * | math | {@link module:Number.sum} | Adds two numbers | `number`, `number` | `number` | + * | math | {@link module:Number.sumAll} | Sums all numbers in a collection | `Iterable` | `number` | + * | math | {@link module:Number.subtract} | Subtracts one number from another | `number`, `number` | `number` | + * | math | {@link module:Number.multiply} | Multiplies two numbers | `number`, `number` | `number` | + * | math | {@link module:Number.multiplyAll} | Multiplies all numbers in a collection | `Iterable` | `number` | + * | math | {@link module:Number.divide} | Safely divides handling division by zero | `number`, `number` | `Option` | + * | math | {@link module:Number.unsafeDivide} | Divides but misbehaves for division by zero | `number`, `number` | `number` | + * | math | {@link module:Number.remainder} | Calculates remainder of division | `number`, `number` | `number` | + * | math | {@link module:Number.increment} | Adds 1 to a number | `number` | `number` | + * | math | {@link module:Number.decrement} | Subtracts 1 from a number | `number` | `number` | + * | math | {@link module:Number.sign} | Determines the sign of a number | `number` | `Ordering` | + * | math | {@link module:Number.nextPow2} | Finds the next power of 2 | `number` | `number` | + * | math | {@link module:Number.round} | Rounds a number with specified precision | `number`, `number` | `number` | + * | | | | | | + * | predicates | {@link module:Number.between} | Checks if a number is in a range | `number`, `{minimum, maximum}` | `boolean` | + * | predicates | {@link module:Number.lessThan} | Checks if one number is less than another | `number`, `number` | `boolean` | + * | predicates | {@link module:Number.lessThanOrEqualTo} | Checks if one number is less than or equal | `number`, `number` | `boolean` | + * | predicates | {@link module:Number.greaterThan} | Checks if one number is greater than another | `number`, `number` | `boolean` | + * | predicates | {@link module:Number.greaterThanOrEqualTo} | Checks if one number is greater or equal | `number`, `number` | `boolean` | + * | | | | | | + * | guards | {@link module:Number.isNumber} | Type guard for JavaScript numbers | `unknown` | `boolean` | + * | | | | | | + * | comparison | {@link module:Number.min} | Returns the minimum of two numbers | `number`, `number` | `number` | + * | comparison | {@link module:Number.max} | Returns the maximum of two numbers | `number`, `number` | `number` | + * | comparison | {@link module:Number.clamp} | Restricts a number to a range | `number`, `{minimum, maximum}` | `number` | + * | | | | | | + * | instances | {@link module:Number.Equivalence} | Equivalence instance for numbers | | `Equivalence` | + * | instances | {@link module:Number.Order} | Order instance for numbers | | `Order` | + * | | | | | | + * | errors | {@link module:Number.DivisionByZeroError} | Error thrown by unsafeDivide | | | + * + * ## Composition Patterns and Type Safety + * + * When building function pipelines, understanding how types flow through + * operations is critical: + * + * ### Composing with type-preserving operations + * + * Most operations in this module are type-preserving (`number → number`), + * making them easily composable in pipelines: + * + * ```ts + * import { pipe } from "effect" + * import * as Number from "effect/Number" + * + * const result = pipe( + * 10, + * Number.increment, // number → number + * Number.multiply(2), // number → number + * Number.round(1) // number → number + * ) // Result: number (21) + * ``` + * + * ### Working with Option results + * + * Operations that might fail (like division by zero) return Option types and + * require Option combinators: + * + * ```ts + * import { pipe, Option } from "effect" + * import * as Number from "effect/Number" + * + * const result = pipe( + * 10, + * Number.divide(0), // number → Option + * Option.getOrElse(() => 0) // Option → number + * ) // Result: number (0) + * ``` + * + * ### Composition best practices + * + * - Chain type-preserving operations for maximum composability + * - Use Option combinators when working with potentially failing operations + * - Consider using Effect for operations that might fail with specific errors + * - Remember that all operations maintain JavaScript's floating-point precision + * limitations + * + * @module Number + * @since 2.0.0 + * @see {@link module:BigInt} for more similar operations on `bigint` types + * @see {@link module:BigDecimal} for more similar operations on `BigDecimal` types + */ +import * as equivalence from "./Equivalence.js"; +import type { Option } from "./Option.js"; +import * as order from "./Order.js"; +import type { Ordering } from "./Ordering.js"; +/** + * Type guard that tests if a value is a member of the set of JavaScript + * numbers. + * + * @memberof Number + * @since 2.0.0 + * @category guards + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import * as Number from "effect/Number" + * + * // Regular numbers + * assert.equal(Number.isNumber(2), true) + * assert.equal(Number.isNumber(-3.14), true) + * assert.equal(Number.isNumber(0), true) + * + * // Special numeric values + * assert.equal(Number.isNumber(Infinity), true) + * assert.equal(Number.isNumber(NaN), true) + * + * // Non-number values + * assert.equal(Number.isNumber("2"), false) + * assert.equal(Number.isNumber(true), false) + * assert.equal(Number.isNumber(null), false) + * assert.equal(Number.isNumber(undefined), false) + * assert.equal(Number.isNumber({}), false) + * assert.equal(Number.isNumber([]), false) + * + * // Using as a type guard in conditionals + * function processValue(value: unknown): string { + * if (Number.isNumber(value)) { + * // TypeScript now knows 'value' is a number + * return `Numeric value: ${value.toFixed(2)}` + * } + * return "Not a number" + * } + * + * assert.strictEqual(processValue(42), "Numeric value: 42.00") + * assert.strictEqual(processValue("hello"), "Not a number") + * + * // Filtering for numbers in an array + * const mixed = [1, "two", 3, false, 5] + * const onlyNumbers = mixed.filter(Number.isNumber) + * assert.equal(onlyNumbers, [1, 3, 5]) + * ``` + * + * @param input - The value to test for membership in the set of JavaScript + * numbers + * + * @returns `true` if the input is a JavaScript number, `false` otherwise + */ +export declare const isNumber: (input: unknown) => input is number; +/** + * Returns the additive inverse of a number, effectively negating it. + * + * @memberof Number + * @since 3.14.6 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { pipe } from "effect" + * import * as Number from "effect/Number" + * + * assert.equal( + * Number.negate(5), // + * -5 + * ) + * + * assert.equal( + * Number.negate(-5), // + * 5 + * ) + * + * assert.equal( + * Number.negate(0), // + * 0 + * ) + * ``` + * + * @param n - The number value to be negated. + * + * @returns The negated number value. + */ +export declare const negate: (n: number) => number; +/** + * Performs addition in the set of JavaScript numbers. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { pipe } from "effect" + * import * as Number from "effect/Number" + * + * // Data-first style (direct application) + * assert.equal(Number.sum(2, 3), 5) + * assert.equal(Number.sum(-10, 5), -5) + * assert.equal(Number.sum(0.1, 0.2), 0.30000000000000004) // Note: floating-point precision limitation + * + * // Data-last style (pipeable) + * assert.equal( + * pipe( + * 10, + * Number.sum(5) // 10 + 5 = 15 + * ), + * 15 + * ) + * + * // Chaining multiple additions + * assert.equal( + * pipe( + * 1, + * Number.sum(2), // 1 + 2 = 3 + * Number.sum(3), // 3 + 3 = 6 + * Number.sum(4) // 6 + 4 = 10 + * ), + * 10 + * ) + * + * // Identity property: a + 0 = a + * assert.equal(Number.sum(42, 0), 42) + * + * // Commutative property: a + b = b + a + * assert.equal(Number.sum(5, 3), Number.sum(3, 5)) + * ``` + */ +export declare const sum: { + /** + * Returns a function that adds a specified number to its argument. + * + * @param that - The number to add to the input of the resulting function + * + * @returns A function that takes a number and returns the sum of that number + * and `that` + */ + (that: number): (self: number) => number; + /** + * Adds two numbers together. + * + * @param self - The first addend + * @param that - The second addend + * + * @returns The sum of the two numbers + */ + (self: number, that: number): number; +}; +/** + * Computes the sum of all elements in an iterable collection of numbers. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import * as Number from "effect/Number" + * + * // Basic sums + * assert.equal(Number.sumAll([2, 3, 4]), 9) // 2 + 3 + 4 = 9 + * assert.equal(Number.sumAll([1.1, 2.2, 3.3]), 6.6) // 1.1 + 2.2 + 3.3 = 6.6 + * + * // Empty collection returns the additive identity (0) + * assert.equal(Number.sumAll([]), 0) + * + * // Single element collection + * assert.equal(Number.sumAll([42]), 42) + * + * // Sums with negative numbers + * assert.equal(Number.sumAll([2, -3, 4]), 3) // 2 + (-3) + 4 = 3 + * assert.equal(Number.sumAll([-2, -3, -4]), -9) // (-2) + (-3) + (-4) = -9 + * + * // Works with any iterable + * assert.equal(Number.sumAll(new Set([2, 3, 4])), 9) + * + * // Using with generated sequences + * function* range(start: number, end: number) { + * for (let i = start; i <= end; i++) yield i + * } + * + * // Compute sum of first 5 natural numbers: 1 + 2 + 3 + 4 + 5 = 15 + * assert.equal(Number.sumAll(range(1, 5)), 15) + * + * // Floating point precision example + * assert.equal( + * Number.sumAll([0.1, 0.2]), + * 0.30000000000000004 // Note IEEE 754 precision limitation + * ) + * ``` + * + * @param collection - An `iterable` containing the `numbers` to sum + * + * @returns The sum of all numbers in the collection, or 0 if the collection is + * empty + */ +export declare const sumAll: (collection: Iterable) => number; +/** + * Performs subtraction in the set of JavaScript numbers. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { pipe } from "effect" + * import * as Number from "effect/Number" + * + * // Data-first style (direct application) + * assert.equal(Number.subtract(2, 3), -1) // 2 - 3 = -1 + * assert.equal(Number.subtract(10, 5), 5) // 10 - 5 = 5 + * assert.equal(Number.subtract(0.3, 0.1), 0.19999999999999998) // Note: floating-point precision limitation + * + * // Data-last style (pipeable) + * assert.equal( + * pipe( + * 10, + * Number.subtract(5) // 10 - 5 = 5 + * ), + * 5 + * ) + * + * // Chaining multiple subtractions + * assert.equal( + * pipe( + * 20, + * Number.subtract(5), // 20 - 5 = 15 + * Number.subtract(3), // 15 - 3 = 12 + * Number.subtract(2) // 12 - 2 = 10 + * ), + * 10 + * ) + * + * // Right identity property: a - 0 = a + * assert.equal(Number.subtract(42, 0), 42) + * + * // Self-annihilation property: a - a = 0 + * assert.equal(Number.subtract(42, 42), 0) + * + * // Non-commutative property: a - b ≠ b - a + * assert.equal(Number.subtract(5, 3), 2) // 5 - 3 = 2 + * assert.equal(Number.subtract(3, 5), -2) // 3 - 5 = -2 + * + * // Inverse relation: a - b = -(b - a) + * assert.equal(Number.subtract(5, 3), -Number.subtract(3, 5)) + * ``` + */ +export declare const subtract: { + /** + * Returns a function that subtracts a specified number from its argument. + * + * @param subtrahend - The number to subtract from the input of the resulting + * function + * + * @returns A function that takes a minuend and returns the difference of + * subtracting the subtrahend from it + */ + (subtrahend: number): (minuend: number) => number; + /** + * Subtracts the subtrahend from the minuend and returns the difference. + * + * @param minuend - The number from which another number is to be subtracted + * @param subtrahend - The number to subtract from the minuend + * + * @returns The difference of the minuend minus the subtrahend + */ + (minuend: number, subtrahend: number): number; +}; +/** + * Performs **multiplication** in the set of JavaScript numbers. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { pipe } from "effect" + * import * as Number from "effect/Number" + * + * // Data-first style (direct application) + * assert.equal(Number.multiply(2, 3), 6) // 2 × 3 = 6 + * assert.equal(Number.multiply(-4, 5), -20) // (-4) × 5 = -20 + * assert.equal(Number.multiply(-3, -2), 6) // (-3) × (-2) = 6 + * assert.equal(Number.multiply(0.1, 0.2), 0.020000000000000004) // Note: floating-point precision limitation + * + * // Data-last style (pipeable) + * assert.equal( + * pipe( + * 10, + * Number.multiply(5) // 10 × 5 = 50 + * ), + * 50 + * ) + * + * // Chaining multiple multiplications + * assert.equal( + * pipe( + * 2, + * Number.multiply(3), // 2 × 3 = 6 + * Number.multiply(4), // 6 × 4 = 24 + * Number.multiply(0.5) // 24 × 0.5 = 12 + * ), + * 12 + * ) + * + * // Identity property: a × 1 = a + * assert.equal(Number.multiply(42, 1), 42) + * + * // Zero property: a × 0 = 0 + * assert.equal(Number.multiply(42, 0), 0) + * + * // Commutative property: a × b = b × a + * assert.equal(Number.multiply(5, 3), Number.multiply(3, 5)) + * + * // Associative property: (a × b) × c = a × (b × c) + * const a = 2, + * b = 3, + * c = 4 + * assert.equal( + * Number.multiply(Number.multiply(a, b), c), + * Number.multiply(a, Number.multiply(b, c)) + * ) + * ``` + */ +export declare const multiply: { + /** + * Returns a function that multiplies a specified number with its argument. + * + * @param multiplicand - The number to multiply with the input of the + * resulting function + * + * @returns A function that takes a multiplier and returns the product of that + * multiplier and the multiplicand + */ + (multiplicand: number): (multiplier: number) => number; + /** + * Multiplies two numbers together. + * + * @param multiplier - The first factor + * @param multiplicand - The second factor + * + * @returns The product of the two numbers + */ + (multiplier: number, multiplicand: number): number; +}; +/** + * Computes the product of all elements in an iterable collection of numbers. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import * as Number from "effect/Number" + * + * // Basic products + * assert.equal(Number.multiplyAll([2, 3, 4]), 24) // 2 × 3 × 4 = 24 + * assert.equal(Number.multiplyAll([1.5, 2, 3]), 9) // 1.5 × 2 × 3 = 9 + * + * // Empty collection returns the multiplicative identity (1) + * assert.equal(Number.multiplyAll([]), 1) + * + * // Single element collection + * assert.equal(Number.multiplyAll([42]), 42) + * + * // Products with negative numbers + * assert.equal(Number.multiplyAll([2, -3, 4]), -24) // 2 × (-3) × 4 = -24 + * assert.equal(Number.multiplyAll([-2, -3]), 6) // (-2) × (-3) = 6 + * + * // Zero property - if any element is zero, product is zero + * assert.equal(Number.multiplyAll([2, 0, 3]), 0) + * + * // Works with any iterable + * assert.equal(Number.multiplyAll(new Set([2, 3, 4])), 24) + * + * // Using with generated sequences + * function* range(start: number, end: number) { + * for (let i = start; i <= end; i++) yield i + * } + * + * // Compute factorial: 5! = 5 × 4 × 3 × 2 × 1 = 120 + * assert.equal(Number.multiplyAll(range(1, 5)), 120) + * ``` + * + * @param collection - An `iterable` containing the `numbers` to multiply + * + * @returns The product of all numbers in the collection, or 1 if the collection + * is empty + */ +export declare const multiplyAll: (collection: Iterable) => number; +/** + * Performs division in the set of JavaScript numbers, returning the result + * wrapped in an `Option` to handle division by zero. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { pipe, Option } from "effect" + * import * as Number from "effect/Number" + * + * // Data-first style (direct application) + * assert.equal(Number.divide(6, 3), Option.some(2)) // 6 ÷ 3 = 2 + * assert.equal(Number.divide(-8, 4), Option.some(-2)) // (-8) ÷ 4 = -2 + * assert.equal(Number.divide(-10, -5), Option.some(2)) // (-10) ÷ (-5) = 2 + * assert.equal(Number.divide(1, 3), Option.some(0.3333333333333333)) // Note: floating-point approximation + * + * // Handling division by zero + * assert.equal(Number.divide(6, 0), Option.none()) // 6 ÷ 0 is undefined + * + * // Data-last style (pipeable) + * assert.equal( + * pipe( + * 10, + * Number.divide(2) // 10 ÷ 2 = 5 + * ), + * Option.some(5) + * ) + * + * // Chaining multiple divisions using Option combinators + * assert.equal( + * pipe( + * Option.some(24), + * Option.flatMap((n) => Number.divide(n, 2)), // 24 ÷ 2 = 12 + * Option.flatMap(Number.divide(3)), // 12 ÷ 3 = 4 + * Option.flatMap(Number.divide(2)) // 4 ÷ 2 = 2 + * ), + * Option.some(2) + * ) + * + * // Division-by-one property: a ÷ 1 = a + * assert.equal(Number.divide(42, 1), Option.some(42)) + * + * // Self-division property: a ÷ a = 1 (for a ≠ 0) + * assert.equal(Number.divide(42, 42), Option.some(1)) + * + * // Non-commutative property: a ÷ b ≠ b ÷ a + * assert.notDeepStrictEqual( + * Number.divide(6, 3), // 6 ÷ 3 = 2 + * Number.divide(3, 6) // 3 ÷ 6 = 0.5 + * ) + * ``` + */ +export declare const divide: { + /** + * Returns a function that divides its input by a specified divisor. + * + * @param divisor - The number to divide by + * + * @returns A function that takes a dividend and returns the quotient wrapped + * in an Option (Option.none() if divisor is 0) + */ + (divisor: number): (dividend: number) => Option; + /** + * Divides the dividend by the divisor and returns the quotient wrapped in an + * Option. + * + * @param dividend - The number to be divided + * @param divisor - The number to divide by + * + * @returns Some(quotient) if the divisor is not 0, None otherwise + */ + (dividend: number, divisor: number): Option; +}; +/** + * Performs division in the set of JavaScript numbers, but misbehaves for + * division by zero. + * + * Unlike {@link module:Number.divide} which returns an Option, this function + * directly returns a number or `Infinity` or `NaN`. + * + * - If the `divisor` is zero, it returns `Infinity`. + * - If both the `dividend` and the `divisor` are zero, then it returns `NaN`. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { pipe } from "effect" + * import * as Number from "effect/Number" + * + * // Data-first style (direct application) + * assert.equal(Number.unsafeDivide(6, 3), 2) // 6 ÷ 3 = 2 + * assert.equal(Number.unsafeDivide(-8, 4), -2) // (-8) ÷ 4 = -2 + * assert.equal(Number.unsafeDivide(-10, -5), 2) // (-10) ÷ (-5) = 2 + * assert.equal(Number.unsafeDivide(1, 3), 0.3333333333333333) + * + * // Data-last style (pipeable) + * assert.equal( + * pipe( + * 10, + * Number.unsafeDivide(2) // 10 ÷ 2 = 5 + * ), + * 5 + * ) + * + * // Chaining multiple divisions + * assert.equal( + * pipe( + * 24, + * Number.unsafeDivide(2), // 24 ÷ 2 = 12 + * Number.unsafeDivide(3), // 12 ÷ 3 = 4 + * Number.unsafeDivide(2) // 4 ÷ 2 = 2 + * ), + * 2 + * ) + * + * assert.equal(Number.unsafeDivide(6, 0), Infinity) + * + * assert.equal(Number.unsafeDivide(0, 0), NaN) + * + * // Compare with safe division + * const safeResult = Number.divide(6, 3) // Option.some(2) + * const unsafeResult = Number.unsafeDivide(6, 3) // 2 directly + * ``` + * + * @throws - An {@link module:Number.DivisionByZeroError} if the divisor is zero. + * @see {@link module:Number.divide} - Safe division returning an Option + */ +export declare const unsafeDivide: { + /** + * Returns a function that divides its input by a specified divisor. + * + * @param divisor - The number to divide by + * + * @returns A function that takes a dividend and returns the quotient + * @throws - An {@link module:Number.DivisionByZeroError} if the divisor is + * zero + */ + (divisor: number): (dividend: number) => number; + /** + * Divides the dividend by the divisor and returns the quotient. + * + * If the divisor is zero, it returns Infinity. + * + * @param dividend - The number to be divided + * @param divisor - The number to divide by + * + * @returns The quotient of the division + */ + (dividend: number, divisor: number): number; +}; +/** + * Returns the result of adding `1` to a given number. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { increment } from "effect/Number" + * + * assert.equal(increment(2), 3) + * ``` + */ +export declare const increment: (n: number) => number; +/** + * Decrements a number by `1`. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { decrement } from "effect/Number" + * + * assert.equal(decrement(3), 2) + * ``` + */ +export declare const decrement: (n: number) => number; +/** + * @memberof Number + * @since 2.0.0 + * @category instances + */ +export declare const Equivalence: equivalence.Equivalence; +/** + * @memberof Number + * @since 2.0.0 + * @category instances + */ +export declare const Order: order.Order; +/** + * Returns `true` if the first argument is less than the second, otherwise + * `false`. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { lessThan } from "effect/Number" + * + * assert.equal(lessThan(2, 3), true) + * assert.equal(lessThan(3, 3), false) + * assert.equal(lessThan(4, 3), false) + * ``` + */ +export declare const lessThan: { + /** + * Returns `true` if the first argument is less than the second, otherwise + * `false`. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { lessThan } from "effect/Number" + * + * assert.equal(lessThan(2, 3), true) + * assert.equal(lessThan(3, 3), false) + * assert.equal(lessThan(4, 3), false) + * ``` + */ + (that: number): (self: number) => boolean; + /** + * Returns `true` if the first argument is less than the second, otherwise + * `false`. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { lessThan } from "effect/Number" + * + * assert.equal(lessThan(2, 3), true) + * assert.equal(lessThan(3, 3), false) + * assert.equal(lessThan(4, 3), false) + * ``` + */ + (self: number, that: number): boolean; +}; +/** + * Returns a function that checks if a given `number` is less than or equal to + * the provided one. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { lessThanOrEqualTo } from "effect/Number" + * + * assert.equal(lessThanOrEqualTo(2, 3), true) + * assert.equal(lessThanOrEqualTo(3, 3), true) + * assert.equal(lessThanOrEqualTo(4, 3), false) + * ``` + */ +export declare const lessThanOrEqualTo: { + /** + * Returns a function that checks if a given `number` is less than or equal to + * the provided one. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { lessThanOrEqualTo } from "effect/Number" + * + * assert.equal(lessThanOrEqualTo(2, 3), true) + * assert.equal(lessThanOrEqualTo(3, 3), true) + * assert.equal(lessThanOrEqualTo(4, 3), false) + * ``` + */ + (that: number): (self: number) => boolean; + /** + * Returns a function that checks if a given `number` is less than or equal to + * the provided one. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { lessThanOrEqualTo } from "effect/Number" + * + * assert.equal(lessThanOrEqualTo(2, 3), true) + * assert.equal(lessThanOrEqualTo(3, 3), true) + * assert.equal(lessThanOrEqualTo(4, 3), false) + * ``` + */ + (self: number, that: number): boolean; +}; +/** + * Returns `true` if the first argument is greater than the second, otherwise + * `false`. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { greaterThan } from "effect/Number" + * + * assert.equal(greaterThan(2, 3), false) + * assert.equal(greaterThan(3, 3), false) + * assert.equal(greaterThan(4, 3), true) + * ``` + */ +export declare const greaterThan: { + /** + * Returns `true` if the first argument is greater than the second, otherwise + * `false`. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { greaterThan } from "effect/Number" + * + * assert.equal(greaterThan(2, 3), false) + * assert.equal(greaterThan(3, 3), false) + * assert.equal(greaterThan(4, 3), true) + * ``` + */ + (that: number): (self: number) => boolean; + /** + * Returns `true` if the first argument is greater than the second, otherwise + * `false`. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { greaterThan } from "effect/Number" + * + * assert.equal(greaterThan(2, 3), false) + * assert.equal(greaterThan(3, 3), false) + * assert.equal(greaterThan(4, 3), true) + * ``` + */ + (self: number, that: number): boolean; +}; +/** + * Returns a function that checks if a given `number` is greater than or equal + * to the provided one. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { greaterThanOrEqualTo } from "effect/Number" + * + * assert.equal(greaterThanOrEqualTo(2, 3), false) + * assert.equal(greaterThanOrEqualTo(3, 3), true) + * assert.equal(greaterThanOrEqualTo(4, 3), true) + * ``` + */ +export declare const greaterThanOrEqualTo: { + /** + * Returns a function that checks if a given `number` is greater than or equal + * to the provided one. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { greaterThanOrEqualTo } from "effect/Number" + * + * assert.equal(greaterThanOrEqualTo(2, 3), false) + * assert.equal(greaterThanOrEqualTo(3, 3), true) + * assert.equal(greaterThanOrEqualTo(4, 3), true) + * ``` + */ + (that: number): (self: number) => boolean; + /** + * Returns a function that checks if a given `number` is greater than or equal + * to the provided one. + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { greaterThanOrEqualTo } from "effect/Number" + * + * assert.equal(greaterThanOrEqualTo(2, 3), false) + * assert.equal(greaterThanOrEqualTo(3, 3), true) + * assert.equal(greaterThanOrEqualTo(4, 3), true) + * ``` + */ + (self: number, that: number): boolean; +}; +/** + * Checks if a `number` is between a `minimum` and `maximum` value (inclusive). + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Number } from "effect" + * + * const between = Number.between({ minimum: 0, maximum: 5 }) + * + * assert.equal(between(3), true) + * assert.equal(between(-1), false) + * assert.equal(between(6), false) + * ``` + */ +export declare const between: { + /** + * Checks if a `number` is between a `minimum` and `maximum` value (inclusive). + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Number } from "effect" + * + * const between = Number.between({ minimum: 0, maximum: 5 }) + * + * assert.equal(between(3), true) + * assert.equal(between(-1), false) + * assert.equal(between(6), false) + * ``` + */ + (options: { + minimum: number; + maximum: number; + }): (self: number) => boolean; + /** + * Checks if a `number` is between a `minimum` and `maximum` value (inclusive). + * + * @memberof Number + * @since 2.0.0 + * @category predicates + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Number } from "effect" + * + * const between = Number.between({ minimum: 0, maximum: 5 }) + * + * assert.equal(between(3), true) + * assert.equal(between(-1), false) + * assert.equal(between(6), false) + * ``` + */ + (self: number, options: { + minimum: number; + maximum: number; + }): boolean; +}; +/** + * Restricts the given `number` to be within the range specified by the + * `minimum` and `maximum` values. + * + * - If the `number` is less than the `minimum` value, the function returns the + * `minimum` value. + * - If the `number` is greater than the `maximum` value, the function returns the + * `maximum` value. + * - Otherwise, it returns the original `number`. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Number } from "effect" + * + * const clamp = Number.clamp({ minimum: 1, maximum: 5 }) + * + * assert.equal(clamp(3), 3) + * assert.equal(clamp(0), 1) + * assert.equal(clamp(6), 5) + * ``` + */ +export declare const clamp: { + /** + * Restricts the given `number` to be within the range specified by the + * `minimum` and `maximum` values. + * + * - If the `number` is less than the `minimum` value, the function returns the + * `minimum` value. + * - If the `number` is greater than the `maximum` value, the function returns the + * `maximum` value. + * - Otherwise, it returns the original `number`. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Number } from "effect" + * + * const clamp = Number.clamp({ minimum: 1, maximum: 5 }) + * + * assert.equal(clamp(3), 3) + * assert.equal(clamp(0), 1) + * assert.equal(clamp(6), 5) + * ``` + */ + (options: { + minimum: number; + maximum: number; + }): (self: number) => number; + /** + * Restricts the given `number` to be within the range specified by the + * `minimum` and `maximum` values. + * + * - If the `number` is less than the `minimum` value, the function returns the + * `minimum` value. + * - If the `number` is greater than the `maximum` value, the function returns the + * `maximum` value. + * - Otherwise, it returns the original `number`. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { Number } from "effect" + * + * const clamp = Number.clamp({ minimum: 1, maximum: 5 }) + * + * assert.equal(clamp(3), 3) + * assert.equal(clamp(0), 1) + * assert.equal(clamp(6), 5) + * ``` + */ + (self: number, options: { + minimum: number; + maximum: number; + }): number; +}; +/** + * Returns the minimum between two `number`s. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { min } from "effect/Number" + * + * assert.equal(min(2, 3), 2) + * ``` + */ +export declare const min: { + /** + * Returns the minimum between two `number`s. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { min } from "effect/Number" + * + * assert.equal(min(2, 3), 2) + * ``` + */ + (that: number): (self: number) => number; + /** + * Returns the minimum between two `number`s. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { min } from "effect/Number" + * + * assert.equal(min(2, 3), 2) + * ``` + */ + (self: number, that: number): number; +}; +/** + * Returns the maximum between two `number`s. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { max } from "effect/Number" + * + * assert.equal(max(2, 3), 3) + * ``` + */ +export declare const max: { + /** + * Returns the maximum between two `number`s. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { max } from "effect/Number" + * + * assert.equal(max(2, 3), 3) + * ``` + */ + (that: number): (self: number) => number; + /** + * Returns the maximum between two `number`s. + * + * @memberof Number + * @since 2.0.0 + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { max } from "effect/Number" + * + * assert.equal(max(2, 3), 3) + * ``` + */ + (self: number, that: number): number; +}; +/** + * Determines the sign of a given `number`. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { sign } from "effect/Number" + * + * assert.equal(sign(-5), -1) + * assert.equal(sign(0), 0) + * assert.equal(sign(5), 1) + * ``` + */ +export declare const sign: (n: number) => Ordering; +/** + * Returns the remainder left over when one operand is divided by a second + * operand. + * + * It always takes the sign of the dividend. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { remainder } from "effect/Number" + * + * assert.equal(remainder(2, 2), 0) + * assert.equal(remainder(3, 2), 1) + * assert.equal(remainder(-4, 2), -0) + * ``` + */ +export declare const remainder: { + /** + * Returns the remainder left over when one operand is divided by a second + * operand. + * + * It always takes the sign of the dividend. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { remainder } from "effect/Number" + * + * assert.equal(remainder(2, 2), 0) + * assert.equal(remainder(3, 2), 1) + * assert.equal(remainder(-4, 2), -0) + * ``` + */ + (divisor: number): (dividend: number) => number; + /** + * Returns the remainder left over when one operand is divided by a second + * operand. + * + * It always takes the sign of the dividend. + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { remainder } from "effect/Number" + * + * assert.equal(remainder(2, 2), 0) + * assert.equal(remainder(3, 2), 1) + * assert.equal(remainder(-4, 2), -0) + * ``` + */ + (dividend: number, divisor: number): number; +}; +/** + * Returns the next power of 2 greater than or equal to the given number. + * + * - For `positive` inputs, returns the smallest power of 2 that is >= the input + * - For `zero`, returns 2 + * - For `negative` inputs, returns NaN (as logarithms of negative numbers are + * undefined) + * - For `NaN` input, returns NaN + * - For `Infinity`, returns Infinity + * + * @memberof Number + * @since 2.0.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { nextPow2 } from "effect/Number" + * + * assert.equal(nextPow2(5), 8) + * assert.equal(nextPow2(17), 32) + * assert.equal(nextPow2(0), 2) + * assert.equal(Number.isNaN(nextPow2(-1)), true) // Negative inputs result in NaN + * ``` + */ +export declare const nextPow2: (n: number) => number; +/** + * Tries to parse a `number` from a `string` using the `Number()` function. The + * following special string values are supported: "NaN", "Infinity", + * "-Infinity". + * + * @memberof Number + * @since 2.0.0 + * @category constructors + */ +export declare const parse: { + /** + * Tries to parse a `number` from a `string` using the `Number()` function. The + * following special string values are supported: "NaN", "Infinity", + * "-Infinity". + * + * @memberof Number + * @since 2.0.0 + * @category constructors + */ + (s: string): Option; +}; +/** + * Returns the number rounded with the given precision. + * + * @memberof Number + * @since 3.8.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { round } from "effect/Number" + * + * assert.equal(round(1.1234, 2), 1.12) + * assert.equal(round(1.567, 2), 1.57) + * ``` + */ +export declare const round: { + /** + * Returns the number rounded with the given precision. + * + * @memberof Number + * @since 3.8.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { round } from "effect/Number" + * + * assert.equal(round(1.1234, 2), 1.12) + * assert.equal(round(1.567, 2), 1.57) + * ``` + */ + (precision: number): (self: number) => number; + /** + * Returns the number rounded with the given precision. + * + * @memberof Number + * @since 3.8.0 + * @category math + * @example + * + * ```ts + * import * as assert from "node:assert/strict" + * import { round } from "effect/Number" + * + * assert.equal(round(1.1234, 2), 1.12) + * assert.equal(round(1.567, 2), 1.57) + * ``` + */ + (self: number, precision: number): number; +}; +//# sourceMappingURL=Number.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Number.d.ts.map b/backend/node_modules/effect/dist/dts/Number.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..521973e5319568a5b4707231ee8ceff8e9d1413a --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Number.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Number.d.ts","sourceRoot":"","sources":["../../src/Number.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Option.d.ts b/backend/node_modules/effect/dist/dts/Option.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..73d5dc9fb55d382b3b93d9b3ceb8f2f4e05ac75e --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Option.d.ts @@ -0,0 +1,3757 @@ +/** + * @since 2.0.0 + */ +import type { Either } from "./Either.js"; +import * as Equivalence from "./Equivalence.js"; +import type { LazyArg } from "./Function.js"; +import type { TypeLambda } from "./HKT.js"; +import type { Inspectable } from "./Inspectable.js"; +import type { Order } from "./Order.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import type { Covariant, NoInfer, NotFunction } from "./Types.js"; +import type * as Unify from "./Unify.js"; +import * as Gen from "./Utils.js"; +/** + * The `Option` data type represents optional values. An `Option` can either + * be `Some`, containing a value of type `A`, or `None`, representing the + * absence of a value. + * + * **When to Use** + * + * You can use `Option` in scenarios like: + * + * - Using it for initial values + * - Returning values from functions that are not defined for all possible + * inputs (referred to as “partial functions”) + * - Managing optional fields in data structures + * - Handling optional function arguments + * + * @category Models + * @since 2.0.0 + */ +export type Option = None | Some; +/** + * @category Symbols + * @since 2.0.0 + */ +export declare const TypeId: unique symbol; +/** + * @category Symbols + * @since 2.0.0 + */ +export type TypeId = typeof TypeId; +/** + * @category Models + * @since 2.0.0 + */ +export interface None extends Pipeable, Inspectable { + readonly _tag: "None"; + readonly _op: "None"; + readonly [TypeId]: { + readonly _A: Covariant; + }; + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: OptionUnify; + [Unify.ignoreSymbol]?: OptionUnifyIgnore; +} +/** + * @category Models + * @since 2.0.0 + */ +export interface Some extends Pipeable, Inspectable { + readonly _tag: "Some"; + readonly _op: "Some"; + readonly value: A; + readonly [TypeId]: { + readonly _A: Covariant; + }; + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: OptionUnify; + [Unify.ignoreSymbol]?: OptionUnifyIgnore; +} +/** + * @category Models + * @since 2.0.0 + */ +export interface OptionUnify { + Option?: () => A[Unify.typeSymbol] extends Option | infer _ ? Option : never; +} +/** + * @since 2.0.0 + */ +export declare namespace Option { + /** + * Extracts the type of the value contained in an `Option`. + * + * **Example** (Getting the Value Type of an Option) + * + * ```ts + * import { Option } from "effect" + * + * // Declare an Option holding a string + * declare const myOption: Option.Option + * + * // Extract the type of the value within the Option + * // + * // ┌─── string + * // ▼ + * type MyType = Option.Option.Value + * ``` + * + * @since 2.0.0 + * @category Type-level Utils + */ + type Value> = [T] extends [Option] ? _A : never; +} +/** + * @category Models + * @since 2.0.0 + */ +export interface OptionUnifyIgnore { +} +/** + * @category Type Lambdas + * @since 2.0.0 + */ +export interface OptionTypeLambda extends TypeLambda { + readonly type: Option; +} +/** + * Represents the absence of a value by creating an empty `Option`. + * + * `Option.none` returns an `Option`, which is a subtype of `Option`. + * This means you can use it in place of any `Option` regardless of the type + * `A`. + * + * **Example** (Creating an Option with No Value) + * + * ```ts + * import { Option } from "effect" + * + * // An Option holding no value + * // + * // ┌─── Option + * // ▼ + * const noValue = Option.none() + * + * console.log(noValue) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @see {@link some} for the opposite operation. + * + * @category Constructors + * @since 2.0.0 + */ +export declare const none: () => Option; +/** + * Wraps the given value into an `Option` to represent its presence. + * + * **Example** (Creating an Option with a Value) + * + * ```ts + * import { Option } from "effect" + * + * // An Option holding the number 1 + * // + * // ┌─── Option + * // ▼ + * const value = Option.some(1) + * + * console.log(value) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * ``` + * + * @see {@link none} for the opposite operation. + * + * @category Constructors + * @since 2.0.0 + */ +export declare const some: (value: A) => Option; +/** + * Determines whether the given value is an `Option`. + * + * **Details** + * + * This function checks if a value is an instance of `Option`. It returns `true` + * if the value is either `Option.some` or `Option.none`, and `false` otherwise. + * This is particularly useful when working with unknown values or when you need + * to ensure type safety in your code. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.isOption(Option.some(1))) + * // Output: true + * + * console.log(Option.isOption(Option.none())) + * // Output: true + * + * console.log(Option.isOption({})) + * // Output: false + * ``` + * + * @category Guards + * @since 2.0.0 + */ +export declare const isOption: (input: unknown) => input is Option; +/** + * Checks whether an `Option` represents the absence of a value (`None`). + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.isNone(Option.some(1))) + * // Output: false + * + * console.log(Option.isNone(Option.none())) + * // Output: true + * ``` + * + * @see {@link isSome} for the opposite check. + * + * @category Guards + * @since 2.0.0 + */ +export declare const isNone: (self: Option) => self is None; +/** + * Checks whether an `Option` contains a value (`Some`). + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.isSome(Option.some(1))) + * // Output: true + * + * console.log(Option.isSome(Option.none())) + * // Output: false + * ``` + * + * @see {@link isNone} for the opposite check. + * + * @category Guards + * @since 2.0.0 + */ +export declare const isSome: (self: Option) => self is Some; +/** + * Performs pattern matching on an `Option` to handle both `Some` and `None` + * cases. + * + * **Details** + * + * This function allows you to match against an `Option` and handle both + * scenarios: when the `Option` is `None` (i.e., contains no value), and when + * the `Option` is `Some` (i.e., contains a value). It executes one of the + * provided functions based on the case: + * + * - If the `Option` is `None`, the `onNone` function is executed and its result + * is returned. + * - If the `Option` is `Some`, the `onSome` function is executed with the + * contained value, and its result is returned. + * + * This function provides a concise and functional way to handle optional values + * without resorting to `if` or manual checks, making your code more declarative + * and readable. + * + * **Example** (Pattern Matching with Option) + * + * ```ts + * import { Option } from "effect" + * + * const foo = Option.some(1) + * + * const message = Option.match(foo, { + * onNone: () => "Option is empty", + * onSome: (value) => `Option has a value: ${value}` + * }) + * + * console.log(message) + * // Output: "Option has a value: 1" + * ``` + * + * @category Pattern matching + * @since 2.0.0 + */ +export declare const match: { + /** + * Performs pattern matching on an `Option` to handle both `Some` and `None` + * cases. + * + * **Details** + * + * This function allows you to match against an `Option` and handle both + * scenarios: when the `Option` is `None` (i.e., contains no value), and when + * the `Option` is `Some` (i.e., contains a value). It executes one of the + * provided functions based on the case: + * + * - If the `Option` is `None`, the `onNone` function is executed and its result + * is returned. + * - If the `Option` is `Some`, the `onSome` function is executed with the + * contained value, and its result is returned. + * + * This function provides a concise and functional way to handle optional values + * without resorting to `if` or manual checks, making your code more declarative + * and readable. + * + * **Example** (Pattern Matching with Option) + * + * ```ts + * import { Option } from "effect" + * + * const foo = Option.some(1) + * + * const message = Option.match(foo, { + * onNone: () => "Option is empty", + * onSome: (value) => `Option has a value: ${value}` + * }) + * + * console.log(message) + * // Output: "Option has a value: 1" + * ``` + * + * @category Pattern matching + * @since 2.0.0 + */ + (options: { + readonly onNone: LazyArg; + readonly onSome: (a: A) => C; + }): (self: Option) => B | C; + /** + * Performs pattern matching on an `Option` to handle both `Some` and `None` + * cases. + * + * **Details** + * + * This function allows you to match against an `Option` and handle both + * scenarios: when the `Option` is `None` (i.e., contains no value), and when + * the `Option` is `Some` (i.e., contains a value). It executes one of the + * provided functions based on the case: + * + * - If the `Option` is `None`, the `onNone` function is executed and its result + * is returned. + * - If the `Option` is `Some`, the `onSome` function is executed with the + * contained value, and its result is returned. + * + * This function provides a concise and functional way to handle optional values + * without resorting to `if` or manual checks, making your code more declarative + * and readable. + * + * **Example** (Pattern Matching with Option) + * + * ```ts + * import { Option } from "effect" + * + * const foo = Option.some(1) + * + * const message = Option.match(foo, { + * onNone: () => "Option is empty", + * onSome: (value) => `Option has a value: ${value}` + * }) + * + * console.log(message) + * // Output: "Option has a value: 1" + * ``` + * + * @category Pattern matching + * @since 2.0.0 + */ + (self: Option, options: { + readonly onNone: LazyArg; + readonly onSome: (a: A) => C; + }): B | C; +}; +/** + * Converts an `Option`-returning function into a type guard. + * + * **Details** + * + * This function transforms a function that returns an `Option` into a type + * guard, ensuring type safety when validating or narrowing types. The returned + * type guard function checks whether the input satisfies the condition defined + * in the original `Option`-returning function. + * + * If the original function returns `Option.some`, the type guard evaluates to + * `true`, confirming the input is of the desired type. If the function returns + * `Option.none`, the type guard evaluates to `false`. + * + * This utility is especially useful for validating types in union types, + * filtering arrays, or ensuring safe handling of specific subtypes. + * + * @example + * ```ts + * import { Option } from "effect" + * + * type MyData = string | number + * + * const parseString = (data: MyData): Option.Option => + * typeof data === "string" ? Option.some(data) : Option.none() + * + * // ┌─── (a: MyData) => a is string + * // ▼ + * const isString = Option.toRefinement(parseString) + * + * console.log(isString("a")) + * // Output: true + * + * console.log(isString(1)) + * // Output: false + * ``` + * + * @category Conversions + * @since 2.0.0 + */ +export declare const toRefinement: (f: (a: A) => Option) => (a: A) => a is B; +/** + * Converts an `Iterable` into an `Option`, wrapping the first element if it + * exists. + * + * **Details** + * + * This function takes an `Iterable` (e.g., an array, a generator, or any object + * implementing the `Iterable` interface) and returns an `Option` based on its + * content: + * + * - If the `Iterable` contains at least one element, the first element is + * wrapped in a `Some` and returned. + * - If the `Iterable` is empty, `None` is returned, representing the absence of + * a value. + * + * This utility is useful for safely handling collections that might be empty, + * ensuring you explicitly handle both cases where a value exists or doesn't. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.fromIterable([1, 2, 3])) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(Option.fromIterable([])) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Constructors + * @since 2.0.0 + */ +export declare const fromIterable: (collection: Iterable) => Option; +/** + * Converts an `Either` into an `Option` by discarding the error and extracting + * the right value. + * + * **Details** + * + * This function takes an `Either` and returns an `Option` based on its value: + * + * - If the `Either` is a `Right`, its value is wrapped in a `Some` and + * returned. + * - If the `Either` is a `Left`, the error is discarded, and `None` is + * returned. + * + * This is particularly useful when you only care about the success case + * (`Right`) of an `Either` and want to handle the result using `Option`. By + * using this function, you can convert `Either` into a simpler structure for + * cases where error handling is not required. + * + * @example + * ```ts + * import { Either, Option } from "effect" + * + * console.log(Option.getRight(Either.right("ok"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'ok' } + * + * console.log(Option.getRight(Either.left("err"))) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @see {@link getLeft} for the opposite operation. + * + * @category Conversions + * @since 2.0.0 + */ +export declare const getRight: (self: Either) => Option; +/** + * Converts an `Either` into an `Option` by discarding the right value and + * extracting the left value. + * + * **Details** + * + * This function transforms an `Either` into an `Option` as follows: + * + * - If the `Either` is a `Left`, its value is wrapped in a `Some` and returned. + * - If the `Either` is a `Right`, the value is discarded, and `None` is + * returned. + * + * This utility is useful when you only care about the error case (`Left`) of an + * `Either` and want to handle it as an `Option`. By discarding the right value, + * it simplifies error-focused workflows. + * + * @example + * ```ts + * import { Either, Option } from "effect" + * + * console.log(Option.getLeft(Either.right("ok"))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.getLeft(Either.left("err"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'err' } + * ``` + * + * @see {@link getRight} for the opposite operation. + * + * @category Conversions + * @since 2.0.0 + */ +export declare const getLeft: (self: Either) => Option; +/** + * Returns the value contained in the `Option` if it is `Some`, otherwise + * evaluates and returns the result of `onNone`. + * + * **Details** + * + * This function allows you to provide a fallback value or computation for when + * an `Option` is `None`. If the `Option` contains a value (`Some`), that value + * is returned. If it is empty (`None`), the `onNone` function is executed, and + * its result is returned instead. + * + * This utility is helpful for safely handling `Option` values by ensuring you + * always receive a meaningful result, whether or not the `Option` contains a + * value. It is particularly useful for providing default values or alternative + * logic when working with optional values. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.some(1).pipe(Option.getOrElse(() => 0))) + * // Output: 1 + * + * console.log(Option.none().pipe(Option.getOrElse(() => 0))) + * // Output: 0 + * ``` + * + * @see {@link getOrNull} for a version that returns `null` instead of executing a function. + * @see {@link getOrUndefined} for a version that returns `undefined` instead of executing a function. + * + * @category Getters + * @since 2.0.0 + */ +export declare const getOrElse: { + /** + * Returns the value contained in the `Option` if it is `Some`, otherwise + * evaluates and returns the result of `onNone`. + * + * **Details** + * + * This function allows you to provide a fallback value or computation for when + * an `Option` is `None`. If the `Option` contains a value (`Some`), that value + * is returned. If it is empty (`None`), the `onNone` function is executed, and + * its result is returned instead. + * + * This utility is helpful for safely handling `Option` values by ensuring you + * always receive a meaningful result, whether or not the `Option` contains a + * value. It is particularly useful for providing default values or alternative + * logic when working with optional values. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.some(1).pipe(Option.getOrElse(() => 0))) + * // Output: 1 + * + * console.log(Option.none().pipe(Option.getOrElse(() => 0))) + * // Output: 0 + * ``` + * + * @see {@link getOrNull} for a version that returns `null` instead of executing a function. + * @see {@link getOrUndefined} for a version that returns `undefined` instead of executing a function. + * + * @category Getters + * @since 2.0.0 + */ + (onNone: LazyArg): (self: Option) => B | A; + /** + * Returns the value contained in the `Option` if it is `Some`, otherwise + * evaluates and returns the result of `onNone`. + * + * **Details** + * + * This function allows you to provide a fallback value or computation for when + * an `Option` is `None`. If the `Option` contains a value (`Some`), that value + * is returned. If it is empty (`None`), the `onNone` function is executed, and + * its result is returned instead. + * + * This utility is helpful for safely handling `Option` values by ensuring you + * always receive a meaningful result, whether or not the `Option` contains a + * value. It is particularly useful for providing default values or alternative + * logic when working with optional values. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.some(1).pipe(Option.getOrElse(() => 0))) + * // Output: 1 + * + * console.log(Option.none().pipe(Option.getOrElse(() => 0))) + * // Output: 0 + * ``` + * + * @see {@link getOrNull} for a version that returns `null` instead of executing a function. + * @see {@link getOrUndefined} for a version that returns `undefined` instead of executing a function. + * + * @category Getters + * @since 2.0.0 + */ + (self: Option, onNone: LazyArg): A | B; +}; +/** + * Returns the provided `Option` `that` if the current `Option` (`self`) is + * `None`; otherwise, it returns `self`. + * + * **Details** + * + * This function provides a fallback mechanism for `Option` values. If the + * current `Option` is `None` (i.e., it contains no value), the `that` function + * is evaluated, and its resulting `Option` is returned. If the current `Option` + * is `Some` (i.e., it contains a value), the original `Option` is returned + * unchanged. + * + * This is particularly useful for chaining fallback values or computations, + * allowing you to provide alternative `Option` values when the first one is + * empty. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.none().pipe(Option.orElse(() => Option.none()))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.some("a").pipe(Option.orElse(() => Option.none()))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * + * console.log(Option.none().pipe(Option.orElse(() => Option.some("b")))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'b' } + * + * console.log(Option.some("a").pipe(Option.orElse(() => Option.some("b")))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Error handling + * @since 2.0.0 + */ +export declare const orElse: { + /** + * Returns the provided `Option` `that` if the current `Option` (`self`) is + * `None`; otherwise, it returns `self`. + * + * **Details** + * + * This function provides a fallback mechanism for `Option` values. If the + * current `Option` is `None` (i.e., it contains no value), the `that` function + * is evaluated, and its resulting `Option` is returned. If the current `Option` + * is `Some` (i.e., it contains a value), the original `Option` is returned + * unchanged. + * + * This is particularly useful for chaining fallback values or computations, + * allowing you to provide alternative `Option` values when the first one is + * empty. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.none().pipe(Option.orElse(() => Option.none()))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.some("a").pipe(Option.orElse(() => Option.none()))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * + * console.log(Option.none().pipe(Option.orElse(() => Option.some("b")))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'b' } + * + * console.log(Option.some("a").pipe(Option.orElse(() => Option.some("b")))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Error handling + * @since 2.0.0 + */ + (that: LazyArg>): (self: Option) => Option; + /** + * Returns the provided `Option` `that` if the current `Option` (`self`) is + * `None`; otherwise, it returns `self`. + * + * **Details** + * + * This function provides a fallback mechanism for `Option` values. If the + * current `Option` is `None` (i.e., it contains no value), the `that` function + * is evaluated, and its resulting `Option` is returned. If the current `Option` + * is `Some` (i.e., it contains a value), the original `Option` is returned + * unchanged. + * + * This is particularly useful for chaining fallback values or computations, + * allowing you to provide alternative `Option` values when the first one is + * empty. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.none().pipe(Option.orElse(() => Option.none()))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.some("a").pipe(Option.orElse(() => Option.none()))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * + * console.log(Option.none().pipe(Option.orElse(() => Option.some("b")))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'b' } + * + * console.log(Option.some("a").pipe(Option.orElse(() => Option.some("b")))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Error handling + * @since 2.0.0 + */ + (self: Option, that: LazyArg>): Option; +}; +/** + * Returns the provided default value wrapped in `Some` if the current `Option` + * (`self`) is `None`; otherwise, returns `self`. + * + * **Details** + * + * This function provides a way to supply a default value for cases where an + * `Option` is `None`. If the current `Option` is empty (`None`), the `onNone` + * function is executed to compute the default value, which is then wrapped in a + * `Some`. If the current `Option` contains a value (`Some`), it is returned as + * is. + * + * This is particularly useful for handling optional values where a fallback + * default needs to be provided explicitly in case of absence. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.none().pipe(Option.orElseSome(() => "b"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'b' } + * + * console.log(Option.some("a").pipe(Option.orElseSome(() => "b"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Error handling + * @since 2.0.0 + */ +export declare const orElseSome: { + /** + * Returns the provided default value wrapped in `Some` if the current `Option` + * (`self`) is `None`; otherwise, returns `self`. + * + * **Details** + * + * This function provides a way to supply a default value for cases where an + * `Option` is `None`. If the current `Option` is empty (`None`), the `onNone` + * function is executed to compute the default value, which is then wrapped in a + * `Some`. If the current `Option` contains a value (`Some`), it is returned as + * is. + * + * This is particularly useful for handling optional values where a fallback + * default needs to be provided explicitly in case of absence. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.none().pipe(Option.orElseSome(() => "b"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'b' } + * + * console.log(Option.some("a").pipe(Option.orElseSome(() => "b"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Error handling + * @since 2.0.0 + */ + (onNone: LazyArg): (self: Option) => Option; + /** + * Returns the provided default value wrapped in `Some` if the current `Option` + * (`self`) is `None`; otherwise, returns `self`. + * + * **Details** + * + * This function provides a way to supply a default value for cases where an + * `Option` is `None`. If the current `Option` is empty (`None`), the `onNone` + * function is executed to compute the default value, which is then wrapped in a + * `Some`. If the current `Option` contains a value (`Some`), it is returned as + * is. + * + * This is particularly useful for handling optional values where a fallback + * default needs to be provided explicitly in case of absence. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.none().pipe(Option.orElseSome(() => "b"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'b' } + * + * console.log(Option.some("a").pipe(Option.orElseSome(() => "b"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Error handling + * @since 2.0.0 + */ + (self: Option, onNone: LazyArg): Option; +}; +/** + * Similar to {@link orElse}, but returns an `Either` wrapped in an `Option` to + * indicate the source of the value. + * + * **Details** + * + * This function allows you to provide a fallback `Option` in case the current + * `Option` (`self`) is `None`. However, unlike `orElse`, it returns the value + * wrapped in an `Either` object, providing additional information about where + * the value came from: + * + * - If the value is from the fallback `Option` (`that`), it is wrapped in an + * `Either.right`. + * - If the value is from the original `Option` (`self`), it is wrapped in an + * `Either.left`. + * + * This is especially useful when you need to differentiate between values + * originating from the primary `Option` and those coming from the fallback, + * while still maintaining the `Option`-style handling. + * + * @category Error handling + * @since 2.0.0 + */ +export declare const orElseEither: { + /** + * Similar to {@link orElse}, but returns an `Either` wrapped in an `Option` to + * indicate the source of the value. + * + * **Details** + * + * This function allows you to provide a fallback `Option` in case the current + * `Option` (`self`) is `None`. However, unlike `orElse`, it returns the value + * wrapped in an `Either` object, providing additional information about where + * the value came from: + * + * - If the value is from the fallback `Option` (`that`), it is wrapped in an + * `Either.right`. + * - If the value is from the original `Option` (`self`), it is wrapped in an + * `Either.left`. + * + * This is especially useful when you need to differentiate between values + * originating from the primary `Option` and those coming from the fallback, + * while still maintaining the `Option`-style handling. + * + * @category Error handling + * @since 2.0.0 + */ + (that: LazyArg>): (self: Option) => Option>; + /** + * Similar to {@link orElse}, but returns an `Either` wrapped in an `Option` to + * indicate the source of the value. + * + * **Details** + * + * This function allows you to provide a fallback `Option` in case the current + * `Option` (`self`) is `None`. However, unlike `orElse`, it returns the value + * wrapped in an `Either` object, providing additional information about where + * the value came from: + * + * - If the value is from the fallback `Option` (`that`), it is wrapped in an + * `Either.right`. + * - If the value is from the original `Option` (`self`), it is wrapped in an + * `Either.left`. + * + * This is especially useful when you need to differentiate between values + * originating from the primary `Option` and those coming from the fallback, + * while still maintaining the `Option`-style handling. + * + * @category Error handling + * @since 2.0.0 + */ + (self: Option, that: LazyArg>): Option>; +}; +/** + * Returns the first `Some` value found in an `Iterable` collection of + * `Option`s, or `None` if no `Some` is found. + * + * **Details** + * + * This function iterates over a collection of `Option` values and returns the + * first `Some` it encounters. If the collection contains only `None` values, + * the result will also be `None`. This utility is useful for efficiently + * finding the first valid value in a sequence of potentially empty or invalid + * options. + * + * The iteration stops as soon as a `Some` is found, making this function + * efficient for large collections. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.firstSomeOf([ + * Option.none(), + * Option.some(1), + * Option.some(2) + * ])) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * ``` + * + * @category Error handling + * @since 2.0.0 + */ +export declare const firstSomeOf: > = Iterable>>(collection: C) => [C] extends [Iterable>] ? Option : never; +/** + * Converts a nullable value into an `Option`. Returns `None` if the value is + * `null` or `undefined`, otherwise wraps the value in a `Some`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.fromNullable(undefined)) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.fromNullable(null)) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.fromNullable(1)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * ``` + * + * @category Conversions + * @since 2.0.0 + */ +export declare const fromNullable: (nullableValue: A) => Option>; +/** + * Lifts a function that returns `null` or `undefined` into the `Option` + * context. + * + * **Details** + * + * This function takes a function `f` that might return `null` or `undefined` + * and transforms it into a function that returns an `Option`. The resulting + * function will return: + * - `Some` if the original function produces a non-null, non-undefined value. + * - `None` if the original function produces `null` or `undefined`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const parse = (s: string): number | undefined => { + * const n = parseFloat(s) + * return isNaN(n) ? undefined : n + * } + * + * const parseOption = Option.liftNullable(parse) + * + * console.log(parseOption("1")) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(parseOption("not a number")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Conversions + * @since 2.0.0 + */ +export declare const liftNullable: , B>(f: (...a: A) => B | null | undefined) => (...a: A) => Option>; +/** + * Returns the value contained in the `Option` if it is `Some`; otherwise, + * returns `null`. + * + * **Details** + * + * This function provides a way to extract the value of an `Option` while + * falling back to `null` if the `Option` is `None`. + * + * It is particularly useful in scenarios where `null` is an acceptable + * placeholder for the absence of a value, such as when interacting with APIs or + * systems that use `null` as a default for missing values. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.getOrNull(Option.some(1))) + * // Output: 1 + * + * console.log(Option.getOrNull(Option.none())) + * // Output: null + * ``` + * + * @category Getters + * @since 2.0.0 + */ +export declare const getOrNull: (self: Option) => A | null; +/** + * Returns the value contained in the `Option` if it is `Some`; otherwise, + * returns `undefined`. + * + * **Details** + * + * This function provides a way to extract the value of an `Option` while + * falling back to `undefined` if the `Option` is `None`. + * + * It is particularly useful in scenarios where `undefined` is an acceptable + * placeholder for the absence of a value, such as when interacting with APIs or + * systems that use `undefined` as a default for missing values. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.getOrUndefined(Option.some(1))) + * // Output: 1 + * + * console.log(Option.getOrUndefined(Option.none())) + * // Output: undefined + * ``` + * + * @category Getters + * @since 2.0.0 + */ +export declare const getOrUndefined: (self: Option) => A | undefined; +/** + * Lifts a function that throws exceptions into a function that returns an + * `Option`. + * + * **Details** + * + * This utility function takes a function `f` that might throw an exception and + * transforms it into a safer function that returns an `Option`. If the original + * function executes successfully, the result is wrapped in a `Some`. If an + * exception is thrown, the result is `None`, allowing the developer to handle + * errors in a functional, type-safe way. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const parse = Option.liftThrowable(JSON.parse) + * + * console.log(parse("1")) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(parse("")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Conversions + * @since 2.0.0 + */ +export declare const liftThrowable: , B>(f: (...a: A) => B) => (...a: A) => Option; +/** + * Extracts the value of an `Option` or throws an error if the `Option` is + * `None`, using a custom error factory. + * + * **Details** + * + * This function allows you to extract the value of an `Option` when it is + * `Some`. If the `Option` is `None`, it throws an error generated by the + * provided `onNone` function. This utility is particularly useful when you need + * a fail-fast behavior for empty `Option` values and want to provide a custom + * error message or object. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option } from "effect" + * + * assert.deepStrictEqual( + * Option.getOrThrowWith(Option.some(1), () => new Error('Unexpected None')), + * 1 + * ) + * assert.throws(() => Option.getOrThrowWith(Option.none(), () => new Error('Unexpected None'))) + * ``` + * + * @see {@link getOrThrow} for a version that throws a default error. + * + * @category Conversions + * @since 2.0.0 + */ +export declare const getOrThrowWith: { + /** + * Extracts the value of an `Option` or throws an error if the `Option` is + * `None`, using a custom error factory. + * + * **Details** + * + * This function allows you to extract the value of an `Option` when it is + * `Some`. If the `Option` is `None`, it throws an error generated by the + * provided `onNone` function. This utility is particularly useful when you need + * a fail-fast behavior for empty `Option` values and want to provide a custom + * error message or object. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option } from "effect" + * + * assert.deepStrictEqual( + * Option.getOrThrowWith(Option.some(1), () => new Error('Unexpected None')), + * 1 + * ) + * assert.throws(() => Option.getOrThrowWith(Option.none(), () => new Error('Unexpected None'))) + * ``` + * + * @see {@link getOrThrow} for a version that throws a default error. + * + * @category Conversions + * @since 2.0.0 + */ + (onNone: () => unknown): (self: Option) => A; + /** + * Extracts the value of an `Option` or throws an error if the `Option` is + * `None`, using a custom error factory. + * + * **Details** + * + * This function allows you to extract the value of an `Option` when it is + * `Some`. If the `Option` is `None`, it throws an error generated by the + * provided `onNone` function. This utility is particularly useful when you need + * a fail-fast behavior for empty `Option` values and want to provide a custom + * error message or object. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option } from "effect" + * + * assert.deepStrictEqual( + * Option.getOrThrowWith(Option.some(1), () => new Error('Unexpected None')), + * 1 + * ) + * assert.throws(() => Option.getOrThrowWith(Option.none(), () => new Error('Unexpected None'))) + * ``` + * + * @see {@link getOrThrow} for a version that throws a default error. + * + * @category Conversions + * @since 2.0.0 + */ + (self: Option, onNone: () => unknown): A; +}; +/** + * Extracts the value of an `Option` or throws a default error if the `Option` + * is `None`. + * + * **Details** + * + * This function extracts the value from an `Option` if it is `Some`. If the + * `Option` is `None`, it throws a default error. It is useful for fail-fast + * scenarios where the absence of a value is treated as an exceptional case and + * a default error is sufficient. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option } from "effect" + * + * assert.deepStrictEqual(Option.getOrThrow(Option.some(1)), 1) + * assert.throws(() => Option.getOrThrow(Option.none())) + * ``` + * + * @see {@link getOrThrowWith} for a version that allows you to provide a custom error. + * + * @category Conversions + * @since 2.0.0 + */ +export declare const getOrThrow: (self: Option) => A; +/** + * Transforms the value inside a `Some` to a new value using the provided + * function, while leaving `None` unchanged. + * + * **Details** + * + * This function applies a mapping function `f` to the value inside an `Option` + * if it is a `Some`. If the `Option` is `None`, it remains unchanged. The + * result is a new `Option` with the transformed value (if it was a `Some`) or + * still `None`. + * + * This utility is particularly useful for chaining transformations in a + * functional way without needing to manually handle `None` cases. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Mapping over a `Some` + * const someValue = Option.some(2) + * + * console.log(Option.map(someValue, (n) => n * 2)) + * // Output: { _id: 'Option', _tag: 'Some', value: 4 } + * + * // Mapping over a `None` + * const noneValue = Option.none() + * + * console.log(Option.map(noneValue, (n) => n * 2)) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Mapping + * @since 2.0.0 + */ +export declare const map: { + /** + * Transforms the value inside a `Some` to a new value using the provided + * function, while leaving `None` unchanged. + * + * **Details** + * + * This function applies a mapping function `f` to the value inside an `Option` + * if it is a `Some`. If the `Option` is `None`, it remains unchanged. The + * result is a new `Option` with the transformed value (if it was a `Some`) or + * still `None`. + * + * This utility is particularly useful for chaining transformations in a + * functional way without needing to manually handle `None` cases. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Mapping over a `Some` + * const someValue = Option.some(2) + * + * console.log(Option.map(someValue, (n) => n * 2)) + * // Output: { _id: 'Option', _tag: 'Some', value: 4 } + * + * // Mapping over a `None` + * const noneValue = Option.none() + * + * console.log(Option.map(noneValue, (n) => n * 2)) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Mapping + * @since 2.0.0 + */ + (f: (a: A) => B): (self: Option) => Option; + /** + * Transforms the value inside a `Some` to a new value using the provided + * function, while leaving `None` unchanged. + * + * **Details** + * + * This function applies a mapping function `f` to the value inside an `Option` + * if it is a `Some`. If the `Option` is `None`, it remains unchanged. The + * result is a new `Option` with the transformed value (if it was a `Some`) or + * still `None`. + * + * This utility is particularly useful for chaining transformations in a + * functional way without needing to manually handle `None` cases. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Mapping over a `Some` + * const someValue = Option.some(2) + * + * console.log(Option.map(someValue, (n) => n * 2)) + * // Output: { _id: 'Option', _tag: 'Some', value: 4 } + * + * // Mapping over a `None` + * const noneValue = Option.none() + * + * console.log(Option.map(noneValue, (n) => n * 2)) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Mapping + * @since 2.0.0 + */ + (self: Option, f: (a: A) => B): Option; +}; +/** + * Replaces the value inside a `Some` with the specified constant value, leaving + * `None` unchanged. + * + * **Details** + * + * This function transforms an `Option` by replacing the value inside a `Some` + * with the given constant value `b`. If the `Option` is `None`, it remains + * unchanged. + * + * This is useful when you want to preserve the presence of a value (`Some`) but + * replace its content with a fixed value. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Replacing the value of a `Some` + * const someValue = Option.some(42) + * + * console.log(Option.as(someValue, "new value")) + * // Output: { _id: 'Option', _tag: 'Some', value: 'new value' } + * + * // Replacing a `None` (no effect) + * const noneValue = Option.none() + * + * console.log(Option.as(noneValue, "new value")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Mapping + * @since 2.0.0 + */ +export declare const as: { + /** + * Replaces the value inside a `Some` with the specified constant value, leaving + * `None` unchanged. + * + * **Details** + * + * This function transforms an `Option` by replacing the value inside a `Some` + * with the given constant value `b`. If the `Option` is `None`, it remains + * unchanged. + * + * This is useful when you want to preserve the presence of a value (`Some`) but + * replace its content with a fixed value. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Replacing the value of a `Some` + * const someValue = Option.some(42) + * + * console.log(Option.as(someValue, "new value")) + * // Output: { _id: 'Option', _tag: 'Some', value: 'new value' } + * + * // Replacing a `None` (no effect) + * const noneValue = Option.none() + * + * console.log(Option.as(noneValue, "new value")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Mapping + * @since 2.0.0 + */ + (b: B): (self: Option) => Option; + /** + * Replaces the value inside a `Some` with the specified constant value, leaving + * `None` unchanged. + * + * **Details** + * + * This function transforms an `Option` by replacing the value inside a `Some` + * with the given constant value `b`. If the `Option` is `None`, it remains + * unchanged. + * + * This is useful when you want to preserve the presence of a value (`Some`) but + * replace its content with a fixed value. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Replacing the value of a `Some` + * const someValue = Option.some(42) + * + * console.log(Option.as(someValue, "new value")) + * // Output: { _id: 'Option', _tag: 'Some', value: 'new value' } + * + * // Replacing a `None` (no effect) + * const noneValue = Option.none() + * + * console.log(Option.as(noneValue, "new value")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Mapping + * @since 2.0.0 + */ + (self: Option, b: B): Option; +}; +/** + * Replaces the value inside a `Some` with the constant value `void`, leaving + * `None` unchanged. + * + * **Details** + * + * This function transforms an `Option` by replacing the value inside a `Some` + * with `void`. If the `Option` is `None`, it remains unchanged. + * + * This is particularly useful in scenarios where the presence or absence of a + * value is significant, but the actual content of the value is irrelevant. + * + * @category Mapping + * @since 2.0.0 + */ +export declare const asVoid: <_>(self: Option<_>) => Option; +declare const void_: Option; +export { +/** + * @since 2.0.0 + */ +void_ as void }; +/** + * Applies a function to the value of a `Some` and flattens the resulting + * `Option`. If the input is `None`, it remains `None`. + * + * **Details** + * + * This function allows you to chain computations that return `Option` values. + * If the input `Option` is `Some`, the provided function `f` is applied to the + * contained value, and the resulting `Option` is returned. If the input is + * `None`, the function is not applied, and the result remains `None`. + * + * This utility is particularly useful for sequencing operations that may fail + * or produce optional results, enabling clean and concise workflows for + * handling such cases. + * + * @example + * ```ts + * import { Option } from "effect" + * + * interface Address { + * readonly city: string + * readonly street: Option.Option + * } + * + * interface User { + * readonly id: number + * readonly username: string + * readonly email: Option.Option + * readonly address: Option.Option

+ * } + * + * const user: User = { + * id: 1, + * username: "john_doe", + * email: Option.some("john.doe@example.com"), + * address: Option.some({ + * city: "New York", + * street: Option.some("123 Main St") + * }) + * } + * + * // Use flatMap to extract the street value + * const street = user.address.pipe( + * Option.flatMap((address) => address.street) + * ) + * + * console.log(street) + * // Output: { _id: 'Option', _tag: 'Some', value: '123 Main St' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ +export declare const flatMap: { + /** + * Applies a function to the value of a `Some` and flattens the resulting + * `Option`. If the input is `None`, it remains `None`. + * + * **Details** + * + * This function allows you to chain computations that return `Option` values. + * If the input `Option` is `Some`, the provided function `f` is applied to the + * contained value, and the resulting `Option` is returned. If the input is + * `None`, the function is not applied, and the result remains `None`. + * + * This utility is particularly useful for sequencing operations that may fail + * or produce optional results, enabling clean and concise workflows for + * handling such cases. + * + * @example + * ```ts + * import { Option } from "effect" + * + * interface Address { + * readonly city: string + * readonly street: Option.Option + * } + * + * interface User { + * readonly id: number + * readonly username: string + * readonly email: Option.Option + * readonly address: Option.Option
+ * } + * + * const user: User = { + * id: 1, + * username: "john_doe", + * email: Option.some("john.doe@example.com"), + * address: Option.some({ + * city: "New York", + * street: Option.some("123 Main St") + * }) + * } + * + * // Use flatMap to extract the street value + * const street = user.address.pipe( + * Option.flatMap((address) => address.street) + * ) + * + * console.log(street) + * // Output: { _id: 'Option', _tag: 'Some', value: '123 Main St' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (f: (a: A) => Option): (self: Option) => Option; + /** + * Applies a function to the value of a `Some` and flattens the resulting + * `Option`. If the input is `None`, it remains `None`. + * + * **Details** + * + * This function allows you to chain computations that return `Option` values. + * If the input `Option` is `Some`, the provided function `f` is applied to the + * contained value, and the resulting `Option` is returned. If the input is + * `None`, the function is not applied, and the result remains `None`. + * + * This utility is particularly useful for sequencing operations that may fail + * or produce optional results, enabling clean and concise workflows for + * handling such cases. + * + * @example + * ```ts + * import { Option } from "effect" + * + * interface Address { + * readonly city: string + * readonly street: Option.Option + * } + * + * interface User { + * readonly id: number + * readonly username: string + * readonly email: Option.Option + * readonly address: Option.Option
+ * } + * + * const user: User = { + * id: 1, + * username: "john_doe", + * email: Option.some("john.doe@example.com"), + * address: Option.some({ + * city: "New York", + * street: Option.some("123 Main St") + * }) + * } + * + * // Use flatMap to extract the street value + * const street = user.address.pipe( + * Option.flatMap((address) => address.street) + * ) + * + * console.log(street) + * // Output: { _id: 'Option', _tag: 'Some', value: '123 Main St' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (self: Option, f: (a: A) => Option): Option; +}; +/** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ +export declare const andThen: { + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (f: (a: A) => Option): (self: Option) => Option; + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (f: Option): (self: Option) => Option; + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (f: (a: A) => B): (self: Option) => Option; + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (f: NotFunction): (self: Option) => Option; + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (self: Option, f: (a: A) => Option): Option; + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (self: Option, f: Option): Option; + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (self: Option, f: (a: A) => B): Option; + /** + * Chains two `Option`s together. The second `Option` can either be a static + * value or depend on the result of the first `Option`. + * + * **Details** + * + * This function enables sequencing of two `Option` computations. If the first + * `Option` is `Some`, the second `Option` is evaluated. The second `Option` can + * either: + * + * - Be a static `Option` value. + * - Be a function that produces an `Option`, optionally based on the value of + * the first `Option`. + * + * If the first `Option` is `None`, the function skips the evaluation of the + * second `Option` and directly returns `None`. + * + * @category Sequencing + * @since 2.0.0 + */ + (self: Option, f: NotFunction): Option; +}; +/** + * Combines `flatMap` and `fromNullable`, transforming the value inside a `Some` + * using a function that may return `null` or `undefined`. + * + * **Details** + * + * This function applies a transformation function `f` to the value inside a + * `Some`. The function `f` may return a value, `null`, or `undefined`. If `f` + * returns a value, it is wrapped in a `Some`. If `f` returns `null` or + * `undefined`, the result is `None`. If the input `Option` is `None`, the + * function is not applied, and `None` is returned. + * + * This utility is particularly useful when working with deeply nested optional + * values or chaining computations that may result in `null` or `undefined` at + * some point. + * + * @example + * ```ts + * import { Option } from "effect" + * + * interface Employee { + * company?: { + * address?: { + * street?: { + * name?: string + * } + * } + * } + * } + * + * const employee1: Employee = { company: { address: { street: { name: "high street" } } } } + * + * // Extracting a deeply nested property + * console.log( + * Option.some(employee1) + * .pipe(Option.flatMapNullable((employee) => employee.company?.address?.street?.name)) + * ) + * // Output: { _id: 'Option', _tag: 'Some', value: 'high street' } + * + * const employee2: Employee = { company: { address: { street: {} } } } + * + * // Property does not exist + * console.log( + * Option.some(employee2) + * .pipe(Option.flatMapNullable((employee) => employee.company?.address?.street?.name)) + * ) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ +export declare const flatMapNullable: { + /** + * Combines `flatMap` and `fromNullable`, transforming the value inside a `Some` + * using a function that may return `null` or `undefined`. + * + * **Details** + * + * This function applies a transformation function `f` to the value inside a + * `Some`. The function `f` may return a value, `null`, or `undefined`. If `f` + * returns a value, it is wrapped in a `Some`. If `f` returns `null` or + * `undefined`, the result is `None`. If the input `Option` is `None`, the + * function is not applied, and `None` is returned. + * + * This utility is particularly useful when working with deeply nested optional + * values or chaining computations that may result in `null` or `undefined` at + * some point. + * + * @example + * ```ts + * import { Option } from "effect" + * + * interface Employee { + * company?: { + * address?: { + * street?: { + * name?: string + * } + * } + * } + * } + * + * const employee1: Employee = { company: { address: { street: { name: "high street" } } } } + * + * // Extracting a deeply nested property + * console.log( + * Option.some(employee1) + * .pipe(Option.flatMapNullable((employee) => employee.company?.address?.street?.name)) + * ) + * // Output: { _id: 'Option', _tag: 'Some', value: 'high street' } + * + * const employee2: Employee = { company: { address: { street: {} } } } + * + * // Property does not exist + * console.log( + * Option.some(employee2) + * .pipe(Option.flatMapNullable((employee) => employee.company?.address?.street?.name)) + * ) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (f: (a: A) => B | null | undefined): (self: Option) => Option>; + /** + * Combines `flatMap` and `fromNullable`, transforming the value inside a `Some` + * using a function that may return `null` or `undefined`. + * + * **Details** + * + * This function applies a transformation function `f` to the value inside a + * `Some`. The function `f` may return a value, `null`, or `undefined`. If `f` + * returns a value, it is wrapped in a `Some`. If `f` returns `null` or + * `undefined`, the result is `None`. If the input `Option` is `None`, the + * function is not applied, and `None` is returned. + * + * This utility is particularly useful when working with deeply nested optional + * values or chaining computations that may result in `null` or `undefined` at + * some point. + * + * @example + * ```ts + * import { Option } from "effect" + * + * interface Employee { + * company?: { + * address?: { + * street?: { + * name?: string + * } + * } + * } + * } + * + * const employee1: Employee = { company: { address: { street: { name: "high street" } } } } + * + * // Extracting a deeply nested property + * console.log( + * Option.some(employee1) + * .pipe(Option.flatMapNullable((employee) => employee.company?.address?.street?.name)) + * ) + * // Output: { _id: 'Option', _tag: 'Some', value: 'high street' } + * + * const employee2: Employee = { company: { address: { street: {} } } } + * + * // Property does not exist + * console.log( + * Option.some(employee2) + * .pipe(Option.flatMapNullable((employee) => employee.company?.address?.street?.name)) + * ) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (self: Option, f: (a: A) => B | null | undefined): Option>; +}; +/** + * Flattens an `Option` of `Option` into a single `Option`. + * + * **Details** + * + * This function takes an `Option` that wraps another `Option` and flattens it + * into a single `Option`. If the outer `Option` is `Some`, the function + * extracts the inner `Option`. If the outer `Option` is `None`, the result + * remains `None`. + * + * This is useful for simplifying nested `Option` structures that may arise + * during functional operations. + * + * @category Sequencing + * @since 2.0.0 + */ +export declare const flatten: (self: Option>) => Option; +/** + * Combines two `Option`s, keeping the value from the second `Option` if both + * are `Some`. + * + * **Details** + * + * This function takes two `Option`s and returns the second one if the first is + * `Some`. If the first `Option` is `None`, the result will also be `None`, + * regardless of the second `Option`. It effectively "zips" the two `Option`s + * while discarding the value from the first `Option`. + * + * This is particularly useful when sequencing computations where the result of + * the first computation is not needed, and you only care about the result of + * the second computation. + * + * @category Zipping + * @since 2.0.0 + */ +export declare const zipRight: { + /** + * Combines two `Option`s, keeping the value from the second `Option` if both + * are `Some`. + * + * **Details** + * + * This function takes two `Option`s and returns the second one if the first is + * `Some`. If the first `Option` is `None`, the result will also be `None`, + * regardless of the second `Option`. It effectively "zips" the two `Option`s + * while discarding the value from the first `Option`. + * + * This is particularly useful when sequencing computations where the result of + * the first computation is not needed, and you only care about the result of + * the second computation. + * + * @category Zipping + * @since 2.0.0 + */ + (that: Option): <_>(self: Option<_>) => Option; + /** + * Combines two `Option`s, keeping the value from the second `Option` if both + * are `Some`. + * + * **Details** + * + * This function takes two `Option`s and returns the second one if the first is + * `Some`. If the first `Option` is `None`, the result will also be `None`, + * regardless of the second `Option`. It effectively "zips" the two `Option`s + * while discarding the value from the first `Option`. + * + * This is particularly useful when sequencing computations where the result of + * the first computation is not needed, and you only care about the result of + * the second computation. + * + * @category Zipping + * @since 2.0.0 + */ + (self: Option, that: Option): Option; +}; +/** + * Combines two `Option`s, keeping the value from the first `Option` if both are + * `Some`. + * + * **Details** + * + * This function takes two `Option`s and returns the first one if it is `Some`. + * If either the first `Option` or the second `Option` is `None`, the result + * will be `None`. This operation "zips" the two `Option`s while discarding the + * value from the second `Option`. + * + * This is useful when sequencing computations where the second `Option` + * represents a dependency or condition that must hold, but its value is + * irrelevant. + * + * @category Zipping + * @since 2.0.0 + */ +export declare const zipLeft: { + /** + * Combines two `Option`s, keeping the value from the first `Option` if both are + * `Some`. + * + * **Details** + * + * This function takes two `Option`s and returns the first one if it is `Some`. + * If either the first `Option` or the second `Option` is `None`, the result + * will be `None`. This operation "zips" the two `Option`s while discarding the + * value from the second `Option`. + * + * This is useful when sequencing computations where the second `Option` + * represents a dependency or condition that must hold, but its value is + * irrelevant. + * + * @category Zipping + * @since 2.0.0 + */ + <_>(that: Option<_>): (self: Option) => Option; + /** + * Combines two `Option`s, keeping the value from the first `Option` if both are + * `Some`. + * + * **Details** + * + * This function takes two `Option`s and returns the first one if it is `Some`. + * If either the first `Option` or the second `Option` is `None`, the result + * will be `None`. This operation "zips" the two `Option`s while discarding the + * value from the second `Option`. + * + * This is useful when sequencing computations where the second `Option` + * represents a dependency or condition that must hold, but its value is + * irrelevant. + * + * @category Zipping + * @since 2.0.0 + */ + (self: Option, that: Option): Option; +}; +/** + * Composes two functions that return `Option` values, creating a new function + * that chains them together. + * + * **Details** + * + * This function allows you to compose two computations, each represented by a + * function that returns an `Option`. The result of the first function is passed + * to the second function if it is `Some`. If the first function returns `None`, + * the composed function short-circuits and returns `None` without invoking the + * second function. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const parse = (s: string): Option.Option => isNaN(Number(s)) ? Option.none() : Option.some(Number(s)) + * + * const double = (n: number): Option.Option => n > 0 ? Option.some(n * 2) : Option.none() + * + * const parseAndDouble = Option.composeK(parse, double) + * + * console.log(parseAndDouble("42")) + * // Output: { _id: 'Option', _tag: 'Some', value: 84 } + * + * console.log(parseAndDouble("not a number")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ +export declare const composeK: { + /** + * Composes two functions that return `Option` values, creating a new function + * that chains them together. + * + * **Details** + * + * This function allows you to compose two computations, each represented by a + * function that returns an `Option`. The result of the first function is passed + * to the second function if it is `Some`. If the first function returns `None`, + * the composed function short-circuits and returns `None` without invoking the + * second function. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const parse = (s: string): Option.Option => isNaN(Number(s)) ? Option.none() : Option.some(Number(s)) + * + * const double = (n: number): Option.Option => n > 0 ? Option.some(n * 2) : Option.none() + * + * const parseAndDouble = Option.composeK(parse, double) + * + * console.log(parseAndDouble("42")) + * // Output: { _id: 'Option', _tag: 'Some', value: 84 } + * + * console.log(parseAndDouble("not a number")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (bfc: (b: B) => Option): (afb: (a: A) => Option) => (a: A) => Option; + /** + * Composes two functions that return `Option` values, creating a new function + * that chains them together. + * + * **Details** + * + * This function allows you to compose two computations, each represented by a + * function that returns an `Option`. The result of the first function is passed + * to the second function if it is `Some`. If the first function returns `None`, + * the composed function short-circuits and returns `None` without invoking the + * second function. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const parse = (s: string): Option.Option => isNaN(Number(s)) ? Option.none() : Option.some(Number(s)) + * + * const double = (n: number): Option.Option => n > 0 ? Option.some(n * 2) : Option.none() + * + * const parseAndDouble = Option.composeK(parse, double) + * + * console.log(parseAndDouble("42")) + * // Output: { _id: 'Option', _tag: 'Some', value: 84 } + * + * console.log(parseAndDouble("not a number")) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (afb: (a: A) => Option, bfc: (b: B) => Option): (a: A) => Option; +}; +/** + * Applies the provided function `f` to the value of the `Option` if it is + * `Some` and returns the original `Option`, unless `f` returns `None`, in which + * case it returns `None`. + * + * **Details** + * + * This function allows you to perform additional computations on the value of + * an `Option` without modifying its original value. If the `Option` is `Some`, + * the provided function `f` is executed with the value, and its result + * determines whether the original `Option` is returned (`Some`) or the result + * is `None` if `f` returns `None`. If the input `Option` is `None`, the + * function is not executed, and `None` is returned. + * + * This is particularly useful for applying side conditions or performing + * validation checks while retaining the original `Option`'s value. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const getInteger = (n: number) => Number.isInteger(n) ? Option.some(n) : Option.none() + * + * console.log(Option.tap(Option.none(), getInteger)) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.tap(Option.some(1), getInteger)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(Option.tap(Option.some(1.14), getInteger)) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ +export declare const tap: { + /** + * Applies the provided function `f` to the value of the `Option` if it is + * `Some` and returns the original `Option`, unless `f` returns `None`, in which + * case it returns `None`. + * + * **Details** + * + * This function allows you to perform additional computations on the value of + * an `Option` without modifying its original value. If the `Option` is `Some`, + * the provided function `f` is executed with the value, and its result + * determines whether the original `Option` is returned (`Some`) or the result + * is `None` if `f` returns `None`. If the input `Option` is `None`, the + * function is not executed, and `None` is returned. + * + * This is particularly useful for applying side conditions or performing + * validation checks while retaining the original `Option`'s value. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const getInteger = (n: number) => Number.isInteger(n) ? Option.some(n) : Option.none() + * + * console.log(Option.tap(Option.none(), getInteger)) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.tap(Option.some(1), getInteger)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(Option.tap(Option.some(1.14), getInteger)) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (f: (a: A) => Option): (self: Option) => Option; + /** + * Applies the provided function `f` to the value of the `Option` if it is + * `Some` and returns the original `Option`, unless `f` returns `None`, in which + * case it returns `None`. + * + * **Details** + * + * This function allows you to perform additional computations on the value of + * an `Option` without modifying its original value. If the `Option` is `Some`, + * the provided function `f` is executed with the value, and its result + * determines whether the original `Option` is returned (`Some`) or the result + * is `None` if `f` returns `None`. If the input `Option` is `None`, the + * function is not executed, and `None` is returned. + * + * This is particularly useful for applying side conditions or performing + * validation checks while retaining the original `Option`'s value. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const getInteger = (n: number) => Number.isInteger(n) ? Option.some(n) : Option.none() + * + * console.log(Option.tap(Option.none(), getInteger)) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(Option.tap(Option.some(1), getInteger)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(Option.tap(Option.some(1.14), getInteger)) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Sequencing + * @since 2.0.0 + */ + (self: Option, f: (a: A) => Option): Option; +}; +/** + * Combines two `Option` values into a single `Option` containing a tuple of + * their values if both are `Some`. + * + * **Details** + * + * This function takes two `Option`s and combines their values into a tuple `[A, + * B]` if both are `Some`. If either of the `Option`s is `None`, the result is + * `None`. This is particularly useful for combining multiple `Option` values + * into a single one, ensuring both contain valid values. + * + * @category Combining + * @since 2.0.0 + */ +export declare const product: (self: Option, that: Option) => Option<[A, B]>; +/** + * Combines an `Option` with a collection of `Option`s into a single `Option` + * containing a tuple of their values if all are `Some`. + * + * **Details** + * + * This function takes a primary `Option` and a collection of `Option`s and + * combines their values into a tuple `[A, ...Array]` if all are `Some`. If + * the primary `Option` or any `Option` in the collection is `None`, the result + * is `None`. + * + * @category Combining + * @since 2.0.0 + */ +export declare const productMany: (self: Option, collection: Iterable>) => Option<[A, ...Array]>; +/** + * Combines a structure of `Option`s into a single `Option` containing the + * values with the same structure. + * + * **Details** + * + * This function takes a structure of `Option`s (a tuple, struct, or iterable) + * and produces a single `Option` that contains the values from the input + * structure if all `Option`s are `Some`. If any `Option` in the input is + * `None`, the result is `None`. The structure of the input is preserved in the + * output. + * + * - If the input is a tuple (e.g., an array), the result will be an `Option` + * containing a tuple with the same length. + * - If the input is a struct (e.g., an object), the result will be an `Option` + * containing a struct with the same keys. + * - If the input is an iterable, the result will be an `Option` containing an + * array. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const maybeName: Option.Option = Option.some("John") + * const maybeAge: Option.Option = Option.some(25) + * + * // ┌─── Option<[string, number]> + * // ▼ + * const tuple = Option.all([maybeName, maybeAge]) + * console.log(tuple) + * // Output: + * // { _id: 'Option', _tag: 'Some', value: [ 'John', 25 ] } + * + * // ┌─── Option<{ name: string; age: number; }> + * // ▼ + * const struct = Option.all({ name: maybeName, age: maybeAge }) + * console.log(struct) + * // Output: + * // { _id: 'Option', _tag: 'Some', value: { name: 'John', age: 25 } } + * ``` + * + * @category Combining + * @since 2.0.0 + */ +export declare const all: > | Record>>(input: I) => [I] extends [ReadonlyArray>] ? Option<{ + -readonly [K in keyof I]: [I[K]] extends [Option] ? A : never; +}> : [I] extends [Iterable>] ? Option> : Option<{ + -readonly [K in keyof I]: [I[K]] extends [Option] ? A : never; +}>; +/** + * Combines two `Option` values into a new `Option` by applying a provided + * function to their values. + * + * **Details** + * + * This function takes two `Option` values (`self` and `that`) and a combining + * function `f`. If both `Option` values are `Some`, the function `f` is applied + * to their values, and the result is wrapped in a new `Some`. If either + * `Option` is `None`, the result is `None`. + * + * This utility is useful for combining two optional computations into a single + * result while maintaining type safety and avoiding explicit checks for `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const maybeName: Option.Option = Option.some("John") + * const maybeAge: Option.Option = Option.some(25) + * + * // Combine the name and age into a person object + * const person = Option.zipWith(maybeName, maybeAge, (name, age) => ({ + * name: name.toUpperCase(), + * age + * })) + * + * console.log(person) + * // Output: + * // { _id: 'Option', _tag: 'Some', value: { name: 'JOHN', age: 25 } } + * ``` + * + * @category Zipping + * @since 2.0.0 + */ +export declare const zipWith: { + /** + * Combines two `Option` values into a new `Option` by applying a provided + * function to their values. + * + * **Details** + * + * This function takes two `Option` values (`self` and `that`) and a combining + * function `f`. If both `Option` values are `Some`, the function `f` is applied + * to their values, and the result is wrapped in a new `Some`. If either + * `Option` is `None`, the result is `None`. + * + * This utility is useful for combining two optional computations into a single + * result while maintaining type safety and avoiding explicit checks for `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const maybeName: Option.Option = Option.some("John") + * const maybeAge: Option.Option = Option.some(25) + * + * // Combine the name and age into a person object + * const person = Option.zipWith(maybeName, maybeAge, (name, age) => ({ + * name: name.toUpperCase(), + * age + * })) + * + * console.log(person) + * // Output: + * // { _id: 'Option', _tag: 'Some', value: { name: 'JOHN', age: 25 } } + * ``` + * + * @category Zipping + * @since 2.0.0 + */ + (that: Option, f: (a: A, b: B) => C): (self: Option) => Option; + /** + * Combines two `Option` values into a new `Option` by applying a provided + * function to their values. + * + * **Details** + * + * This function takes two `Option` values (`self` and `that`) and a combining + * function `f`. If both `Option` values are `Some`, the function `f` is applied + * to their values, and the result is wrapped in a new `Some`. If either + * `Option` is `None`, the result is `None`. + * + * This utility is useful for combining two optional computations into a single + * result while maintaining type safety and avoiding explicit checks for `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const maybeName: Option.Option = Option.some("John") + * const maybeAge: Option.Option = Option.some(25) + * + * // Combine the name and age into a person object + * const person = Option.zipWith(maybeName, maybeAge, (name, age) => ({ + * name: name.toUpperCase(), + * age + * })) + * + * console.log(person) + * // Output: + * // { _id: 'Option', _tag: 'Some', value: { name: 'JOHN', age: 25 } } + * ``` + * + * @category Zipping + * @since 2.0.0 + */ + (self: Option, that: Option, f: (a: A, b: B) => C): Option; +}; +/** + * Applies a function inside a `Some` to a value inside another `Some`, + * combining them into a new `Option`. + * + * **Details** + * + * This function allows you to apply a function wrapped in an `Option` (`self`) + * to a value wrapped in another `Option` (`that`). If both `Option`s are + * `Some`, the function is applied to the value, and the result is wrapped in a + * new `Some`. If either `Option` is `None`, the result is `None`. + * + * @category Combining + * @since 2.0.0 + */ +export declare const ap: { + /** + * Applies a function inside a `Some` to a value inside another `Some`, + * combining them into a new `Option`. + * + * **Details** + * + * This function allows you to apply a function wrapped in an `Option` (`self`) + * to a value wrapped in another `Option` (`that`). If both `Option`s are + * `Some`, the function is applied to the value, and the result is wrapped in a + * new `Some`. If either `Option` is `None`, the result is `None`. + * + * @category Combining + * @since 2.0.0 + */ + (that: Option): (self: Option<(a: A) => B>) => Option; + /** + * Applies a function inside a `Some` to a value inside another `Some`, + * combining them into a new `Option`. + * + * **Details** + * + * This function allows you to apply a function wrapped in an `Option` (`self`) + * to a value wrapped in another `Option` (`that`). If both `Option`s are + * `Some`, the function is applied to the value, and the result is wrapped in a + * new `Some`. If either `Option` is `None`, the result is `None`. + * + * @category Combining + * @since 2.0.0 + */ + (self: Option<(a: A) => B>, that: Option): Option; +}; +/** + * Reduces an `Iterable` of `Option` to a single value of type `B`, ignoring + * elements that are `None`. + * + * **Details** + * + * This function takes an initial value of type `B` and a reducing function `f` + * that combines the accumulator with values of type `A`. It processes an + * iterable of `Option`, applying `f` only to the `Some` values while + * ignoring the `None` values. The result is a single value of type `B`. + * + * This utility is particularly useful for aggregating values from an iterable + * of `Option`s while skipping the absent (`None`) values. + * + * @example + * ```ts + * import { Option, pipe } from "effect" + * + * const iterable = [Option.some(1), Option.none(), Option.some(2), Option.none()] + * + * console.log(pipe(iterable, Option.reduceCompact(0, (b, a) => b + a))) + * // Output: 3 + * ``` + * + * @category Reducing + * @since 2.0.0 + */ +export declare const reduceCompact: { + /** + * Reduces an `Iterable` of `Option` to a single value of type `B`, ignoring + * elements that are `None`. + * + * **Details** + * + * This function takes an initial value of type `B` and a reducing function `f` + * that combines the accumulator with values of type `A`. It processes an + * iterable of `Option`, applying `f` only to the `Some` values while + * ignoring the `None` values. The result is a single value of type `B`. + * + * This utility is particularly useful for aggregating values from an iterable + * of `Option`s while skipping the absent (`None`) values. + * + * @example + * ```ts + * import { Option, pipe } from "effect" + * + * const iterable = [Option.some(1), Option.none(), Option.some(2), Option.none()] + * + * console.log(pipe(iterable, Option.reduceCompact(0, (b, a) => b + a))) + * // Output: 3 + * ``` + * + * @category Reducing + * @since 2.0.0 + */ + (b: B, f: (b: B, a: A) => B): (self: Iterable>) => B; + /** + * Reduces an `Iterable` of `Option` to a single value of type `B`, ignoring + * elements that are `None`. + * + * **Details** + * + * This function takes an initial value of type `B` and a reducing function `f` + * that combines the accumulator with values of type `A`. It processes an + * iterable of `Option`, applying `f` only to the `Some` values while + * ignoring the `None` values. The result is a single value of type `B`. + * + * This utility is particularly useful for aggregating values from an iterable + * of `Option`s while skipping the absent (`None`) values. + * + * @example + * ```ts + * import { Option, pipe } from "effect" + * + * const iterable = [Option.some(1), Option.none(), Option.some(2), Option.none()] + * + * console.log(pipe(iterable, Option.reduceCompact(0, (b, a) => b + a))) + * // Output: 3 + * ``` + * + * @category Reducing + * @since 2.0.0 + */ + (self: Iterable>, b: B, f: (b: B, a: A) => B): B; +}; +/** + * Converts an `Option` into an `Array`. + * If the input is `None`, an empty array is returned. + * If the input is `Some`, its value is wrapped in a single-element array. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.toArray(Option.some(1))) + * // Output: [1] + * + * console.log(Option.toArray(Option.none())) + * // Output: [] + * ``` + * + * @category Conversions + * @since 2.0.0 + */ +export declare const toArray: (self: Option) => Array; +/** + * Splits an `Option` into two `Option`s based on the result of a mapping + * function that produces an `Either`. + * + * **Details** + * + * This function takes an `Option` and a mapping function `f` that converts its + * value into an `Either`. It returns a tuple of two `Option`s: + * + * - The first `Option` (`left`) contains the value from the `Left` side of the + * `Either` if it exists, otherwise `None`. + * - The second `Option` (`right`) contains the value from the `Right` side of + * the `Either` if it exists, otherwise `None`. + * + * If the input `Option` is `None`, both returned `Option`s are `None`. + * + * This utility is useful for filtering and categorizing the contents of an + * `Option` based on a bifurcating computation. + * + * @category Filtering + * @since 2.0.0 + */ +export declare const partitionMap: { + /** + * Splits an `Option` into two `Option`s based on the result of a mapping + * function that produces an `Either`. + * + * **Details** + * + * This function takes an `Option` and a mapping function `f` that converts its + * value into an `Either`. It returns a tuple of two `Option`s: + * + * - The first `Option` (`left`) contains the value from the `Left` side of the + * `Either` if it exists, otherwise `None`. + * - The second `Option` (`right`) contains the value from the `Right` side of + * the `Either` if it exists, otherwise `None`. + * + * If the input `Option` is `None`, both returned `Option`s are `None`. + * + * This utility is useful for filtering and categorizing the contents of an + * `Option` based on a bifurcating computation. + * + * @category Filtering + * @since 2.0.0 + */ + (f: (a: A) => Either): (self: Option) => [left: Option, right: Option]; + /** + * Splits an `Option` into two `Option`s based on the result of a mapping + * function that produces an `Either`. + * + * **Details** + * + * This function takes an `Option` and a mapping function `f` that converts its + * value into an `Either`. It returns a tuple of two `Option`s: + * + * - The first `Option` (`left`) contains the value from the `Left` side of the + * `Either` if it exists, otherwise `None`. + * - The second `Option` (`right`) contains the value from the `Right` side of + * the `Either` if it exists, otherwise `None`. + * + * If the input `Option` is `None`, both returned `Option`s are `None`. + * + * This utility is useful for filtering and categorizing the contents of an + * `Option` based on a bifurcating computation. + * + * @category Filtering + * @since 2.0.0 + */ + (self: Option, f: (a: A) => Either): [left: Option, right: Option]; +}; +/** + * Alias of {@link flatMap}. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Transform and filter numbers + * const transformEven = (n: Option.Option): Option.Option => + * Option.filterMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())) + * + * console.log(transformEven(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(transformEven(Option.some(1))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(transformEven(Option.some(2))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ +export declare const filterMap: { + /** + * Alias of {@link flatMap}. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Transform and filter numbers + * const transformEven = (n: Option.Option): Option.Option => + * Option.filterMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())) + * + * console.log(transformEven(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(transformEven(Option.some(1))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(transformEven(Option.some(2))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ + (f: (a: A) => Option): (self: Option) => Option; + /** + * Alias of {@link flatMap}. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Transform and filter numbers + * const transformEven = (n: Option.Option): Option.Option => + * Option.filterMap(n, (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())) + * + * console.log(transformEven(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(transformEven(Option.some(1))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(transformEven(Option.some(2))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ + (self: Option, f: (a: A) => Option): Option; +}; +/** + * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`. + * + * If you need to change the type of the `Option` in addition to filtering, see `filterMap`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const removeEmptyString = (input: Option.Option) => + * Option.filter(input, (value) => value !== "") + * + * console.log(removeEmptyString(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some(""))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some("a"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ +export declare const filter: { + /** + * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`. + * + * If you need to change the type of the `Option` in addition to filtering, see `filterMap`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const removeEmptyString = (input: Option.Option) => + * Option.filter(input, (value) => value !== "") + * + * console.log(removeEmptyString(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some(""))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some("a"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ + (refinement: Refinement, B>): (self: Option) => Option; + /** + * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`. + * + * If you need to change the type of the `Option` in addition to filtering, see `filterMap`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const removeEmptyString = (input: Option.Option) => + * Option.filter(input, (value) => value !== "") + * + * console.log(removeEmptyString(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some(""))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some("a"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ + (predicate: Predicate>): (self: Option) => Option; + /** + * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`. + * + * If you need to change the type of the `Option` in addition to filtering, see `filterMap`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const removeEmptyString = (input: Option.Option) => + * Option.filter(input, (value) => value !== "") + * + * console.log(removeEmptyString(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some(""))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some("a"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ + (self: Option, refinement: Refinement): Option; + /** + * Filters an `Option` using a predicate. If the predicate is not satisfied or the `Option` is `None` returns `None`. + * + * If you need to change the type of the `Option` in addition to filtering, see `filterMap`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const removeEmptyString = (input: Option.Option) => + * Option.filter(input, (value) => value !== "") + * + * console.log(removeEmptyString(Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some(""))) + * // Output: { _id: 'Option', _tag: 'None' } + * + * console.log(removeEmptyString(Option.some("a"))) + * // Output: { _id: 'Option', _tag: 'Some', value: 'a' } + * ``` + * + * @category Filtering + * @since 2.0.0 + */ + (self: Option, predicate: Predicate): Option; +}; +/** + * Creates an `Equivalence` instance for comparing `Option` values, using a + * provided `Equivalence` for the inner type. + * + * **Details** + * + * This function takes an `Equivalence` instance for a specific type `A` and + * produces an `Equivalence` instance for `Option`. The resulting + * `Equivalence` determines whether two `Option` values are equivalent: + * + * - Two `None`s are considered equivalent. + * - A `Some` and a `None` are not equivalent. + * - Two `Some` values are equivalent if their inner values are equivalent + * according to the provided `Equivalence`. + * + * **Example** (Comparing Optional Numbers for Equivalence) + * + * ```ts + * import { Number, Option } from "effect" + * + * const isEquivalent = Option.getEquivalence(Number.Equivalence) + * + * console.log(isEquivalent(Option.none(), Option.none())) + * // Output: true + * + * console.log(isEquivalent(Option.none(), Option.some(1))) + * // Output: false + * + * console.log(isEquivalent(Option.some(1), Option.none())) + * // Output: false + * + * console.log(isEquivalent(Option.some(1), Option.some(2))) + * // Output: false + * + * console.log(isEquivalent(Option.some(1), Option.some(1))) + * // Output: true + * ``` + * + * @category Equivalence + * @since 2.0.0 + */ +export declare const getEquivalence: (isEquivalent: Equivalence.Equivalence) => Equivalence.Equivalence>; +/** + * Creates an `Order` instance for comparing `Option` values, using a provided + * `Order` for the inner type. + * + * **Details** + * + * This function produces an `Order` instance for `Option`, allowing `Option` + * values to be compared: + * + * - `None` is always considered less than any `Some` value. + * - If both are `Some`, their inner values are compared using the provided + * `Order` instance. + * + * @example + * ```ts + * import { Number, Option } from "effect" + * + * const order = Option.getOrder(Number.Order) + * + * console.log(order(Option.none(), Option.none())) + * // Output: 0 + * + * console.log(order(Option.none(), Option.some(1))) + * // Output: -1 + * + * console.log(order(Option.some(1), Option.none())) + * // Output: 1 + * + * console.log(order(Option.some(1), Option.some(2))) + * // Output: -1 + * + * console.log(order(Option.some(1), Option.some(1))) + * // Output: 0 + * ``` + * + * @category Sorting + * @since 2.0.0 + */ +export declare const getOrder: (O: Order) => Order>; +/** + * Lifts a binary function to work with `Option` values, allowing the function + * to operate on two `Option`s. + * + * **Details** + * + * This function takes a binary function `f` and returns a new function that + * applies `f` to the values of two `Option`s (`self` and `that`). If both + * `Option`s are `Some`, the binary function `f` is applied to their values, and + * the result is wrapped in a new `Some`. If either `Option` is `None`, the + * result is `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // A binary function to add two numbers + * const add = (a: number, b: number): number => a + b + * + * // Lift the `add` function to work with `Option` values + * const addOptions = Option.lift2(add) + * + * // Both `Option`s are `Some` + * console.log(addOptions(Option.some(2), Option.some(3))) + * // Output: { _id: 'Option', _tag: 'Some', value: 5 } + * + * // One `Option` is `None` + * console.log(addOptions(Option.some(2), Option.none())) + * // Output: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Lifting + * @since 2.0.0 + */ +export declare const lift2: (f: (a: A, b: B) => C) => { + (that: Option): (self: Option) => Option; + (self: Option, that: Option): Option; +}; +/** + * Lifts a `Predicate` or `Refinement` into the `Option` context, returning a + * `Some` of the input value if the predicate is satisfied, or `None` otherwise. + * + * **Details** + * + * This function transforms a `Predicate` (or a more specific `Refinement`) into + * a function that produces an `Option`. If the predicate evaluates to `true`, + * the input value is wrapped in a `Some`. If the predicate evaluates to + * `false`, the result is `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Check if a number is positive + * const isPositive = (n: number) => n > 0 + * + * // ┌─── (b: number) => Option + * // ▼ + * const parsePositive = Option.liftPredicate(isPositive) + * + * console.log(parsePositive(1)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(parsePositive(-1)) + * // OUtput: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Lifting + * @since 2.0.0 + */ +export declare const liftPredicate: { + (refinement: Refinement): (a: A) => Option; + /** + * Lifts a `Predicate` or `Refinement` into the `Option` context, returning a + * `Some` of the input value if the predicate is satisfied, or `None` otherwise. + * + * **Details** + * + * This function transforms a `Predicate` (or a more specific `Refinement`) into + * a function that produces an `Option`. If the predicate evaluates to `true`, + * the input value is wrapped in a `Some`. If the predicate evaluates to + * `false`, the result is `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Check if a number is positive + * const isPositive = (n: number) => n > 0 + * + * // ┌─── (b: number) => Option + * // ▼ + * const parsePositive = Option.liftPredicate(isPositive) + * + * console.log(parsePositive(1)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(parsePositive(-1)) + * // OUtput: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Lifting + * @since 2.0.0 + */ + (predicate: Predicate): (b: B) => Option; + /** + * Lifts a `Predicate` or `Refinement` into the `Option` context, returning a + * `Some` of the input value if the predicate is satisfied, or `None` otherwise. + * + * **Details** + * + * This function transforms a `Predicate` (or a more specific `Refinement`) into + * a function that produces an `Option`. If the predicate evaluates to `true`, + * the input value is wrapped in a `Some`. If the predicate evaluates to + * `false`, the result is `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Check if a number is positive + * const isPositive = (n: number) => n > 0 + * + * // ┌─── (b: number) => Option + * // ▼ + * const parsePositive = Option.liftPredicate(isPositive) + * + * console.log(parsePositive(1)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(parsePositive(-1)) + * // OUtput: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Lifting + * @since 2.0.0 + */ + (self: A, refinement: Refinement): Option; + /** + * Lifts a `Predicate` or `Refinement` into the `Option` context, returning a + * `Some` of the input value if the predicate is satisfied, or `None` otherwise. + * + * **Details** + * + * This function transforms a `Predicate` (or a more specific `Refinement`) into + * a function that produces an `Option`. If the predicate evaluates to `true`, + * the input value is wrapped in a `Some`. If the predicate evaluates to + * `false`, the result is `None`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * // Check if a number is positive + * const isPositive = (n: number) => n > 0 + * + * // ┌─── (b: number) => Option + * // ▼ + * const parsePositive = Option.liftPredicate(isPositive) + * + * console.log(parsePositive(1)) + * // Output: { _id: 'Option', _tag: 'Some', value: 1 } + * + * console.log(parsePositive(-1)) + * // OUtput: { _id: 'Option', _tag: 'None' } + * ``` + * + * @category Lifting + * @since 2.0.0 + */ + (self: B, predicate: Predicate): Option; +}; +/** + * Returns a function that checks if an `Option` contains a specified value, + * using a provided equivalence function. + * + * **Details** + * + * This function allows you to check whether an `Option` contains a specific + * value. It uses an equivalence function `isEquivalent` to compare the value + * inside the `Option` to the provided value. If the `Option` is `Some` and the + * equivalence function returns `true`, the result is `true`. If the `Option` is + * `None` or the values are not equivalent, the result is `false`. + * + * @example + * ```ts + * import { Number, Option } from "effect" + * + * const contains = Option.containsWith(Number.Equivalence) + * + * console.log(Option.some(2).pipe(contains(2))) + * // Output: true + * + * console.log(Option.some(1).pipe(contains(2))) + * // Output: false + * + * console.log(Option.none().pipe(contains(2))) + * // Output: false + * ``` + * + * @see {@link contains} for a version that uses the default `Equivalence`. + * + * @category Elements + * @since 2.0.0 + */ +export declare const containsWith: (isEquivalent: (self: A, that: A) => boolean) => { + (a: A): (self: Option) => boolean; + (self: Option, a: A): boolean; +}; +/** + * Returns a function that checks if an `Option` contains a specified value + * using the default `Equivalence`. + * + * **Details** + * + * This function allows you to check whether an `Option` contains a specific + * value. It uses the default `Equivalence` for equality comparison. If the + * `Option` is `Some` and its value is equivalent to the provided value, the + * result is `true`. If the `Option` is `None` or the values are not equivalent, + * the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.some(2).pipe(Option.contains(2))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.contains(2))) + * // Output: false + * + * console.log(Option.none().pipe(Option.contains(2))) + * // Output: false + * ``` + * + * @see {@link containsWith} for a version that allows you to specify a custom equivalence function. + * + * @category Elements + * @since 2.0.0 + */ +export declare const contains: { + /** + * Returns a function that checks if an `Option` contains a specified value + * using the default `Equivalence`. + * + * **Details** + * + * This function allows you to check whether an `Option` contains a specific + * value. It uses the default `Equivalence` for equality comparison. If the + * `Option` is `Some` and its value is equivalent to the provided value, the + * result is `true`. If the `Option` is `None` or the values are not equivalent, + * the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.some(2).pipe(Option.contains(2))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.contains(2))) + * // Output: false + * + * console.log(Option.none().pipe(Option.contains(2))) + * // Output: false + * ``` + * + * @see {@link containsWith} for a version that allows you to specify a custom equivalence function. + * + * @category Elements + * @since 2.0.0 + */ + (a: A): (self: Option) => boolean; + /** + * Returns a function that checks if an `Option` contains a specified value + * using the default `Equivalence`. + * + * **Details** + * + * This function allows you to check whether an `Option` contains a specific + * value. It uses the default `Equivalence` for equality comparison. If the + * `Option` is `Some` and its value is equivalent to the provided value, the + * result is `true`. If the `Option` is `None` or the values are not equivalent, + * the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * console.log(Option.some(2).pipe(Option.contains(2))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.contains(2))) + * // Output: false + * + * console.log(Option.none().pipe(Option.contains(2))) + * // Output: false + * ``` + * + * @see {@link containsWith} for a version that allows you to specify a custom equivalence function. + * + * @category Elements + * @since 2.0.0 + */ + (self: Option, a: A): boolean; +}; +/** + * Checks if a value in an `Option` satisfies a given predicate or refinement. + * + * **Details** + * + * This function allows you to check if a value inside a `Some` meets a + * specified condition. If the `Option` is `None`, the result is `false`. If the + * `Option` is `Some`, the provided predicate or refinement is applied to the + * value: + * + * - If the condition is met, the result is `true`. + * - If the condition is not met, the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const isEven = (n: number) => n % 2 === 0 + * + * console.log(Option.some(2).pipe(Option.exists(isEven))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.exists(isEven))) + * // Output: false + * + * console.log(Option.none().pipe(Option.exists(isEven))) + * // Output: false + * ``` + * + * @category Elements + * @since 2.0.0 + */ +export declare const exists: { + /** + * Checks if a value in an `Option` satisfies a given predicate or refinement. + * + * **Details** + * + * This function allows you to check if a value inside a `Some` meets a + * specified condition. If the `Option` is `None`, the result is `false`. If the + * `Option` is `Some`, the provided predicate or refinement is applied to the + * value: + * + * - If the condition is met, the result is `true`. + * - If the condition is not met, the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const isEven = (n: number) => n % 2 === 0 + * + * console.log(Option.some(2).pipe(Option.exists(isEven))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.exists(isEven))) + * // Output: false + * + * console.log(Option.none().pipe(Option.exists(isEven))) + * // Output: false + * ``` + * + * @category Elements + * @since 2.0.0 + */ + (refinement: Refinement, B>): (self: Option) => self is Option; + /** + * Checks if a value in an `Option` satisfies a given predicate or refinement. + * + * **Details** + * + * This function allows you to check if a value inside a `Some` meets a + * specified condition. If the `Option` is `None`, the result is `false`. If the + * `Option` is `Some`, the provided predicate or refinement is applied to the + * value: + * + * - If the condition is met, the result is `true`. + * - If the condition is not met, the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const isEven = (n: number) => n % 2 === 0 + * + * console.log(Option.some(2).pipe(Option.exists(isEven))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.exists(isEven))) + * // Output: false + * + * console.log(Option.none().pipe(Option.exists(isEven))) + * // Output: false + * ``` + * + * @category Elements + * @since 2.0.0 + */ + (predicate: Predicate>): (self: Option) => boolean; + /** + * Checks if a value in an `Option` satisfies a given predicate or refinement. + * + * **Details** + * + * This function allows you to check if a value inside a `Some` meets a + * specified condition. If the `Option` is `None`, the result is `false`. If the + * `Option` is `Some`, the provided predicate or refinement is applied to the + * value: + * + * - If the condition is met, the result is `true`. + * - If the condition is not met, the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const isEven = (n: number) => n % 2 === 0 + * + * console.log(Option.some(2).pipe(Option.exists(isEven))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.exists(isEven))) + * // Output: false + * + * console.log(Option.none().pipe(Option.exists(isEven))) + * // Output: false + * ``` + * + * @category Elements + * @since 2.0.0 + */ + (self: Option, refinement: Refinement): self is Option; + /** + * Checks if a value in an `Option` satisfies a given predicate or refinement. + * + * **Details** + * + * This function allows you to check if a value inside a `Some` meets a + * specified condition. If the `Option` is `None`, the result is `false`. If the + * `Option` is `Some`, the provided predicate or refinement is applied to the + * value: + * + * - If the condition is met, the result is `true`. + * - If the condition is not met, the result is `false`. + * + * @example + * ```ts + * import { Option } from "effect" + * + * const isEven = (n: number) => n % 2 === 0 + * + * console.log(Option.some(2).pipe(Option.exists(isEven))) + * // Output: true + * + * console.log(Option.some(1).pipe(Option.exists(isEven))) + * // Output: false + * + * console.log(Option.none().pipe(Option.exists(isEven))) + * // Output: false + * ``` + * + * @category Elements + * @since 2.0.0 + */ + (self: Option, predicate: Predicate): boolean; +}; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ +export declare const bindTo: { + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (name: N): (self: Option) => Option<{ + [K in N]: A; + }>; + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (self: Option, name: N): Option<{ + [K in N]: A; + }>; +}; +declare const let_: { + (name: Exclude, f: (a: NoInfer) => B): (self: Option) => Option<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; + (self: Option, name: Exclude, f: (a: NoInfer) => B): Option<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; +}; +export { +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bind} + * @see {@link bindTo} + * + * @category Do notation + * @since 2.0.0 + */ +let_ as let }; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ +export declare const bind: { + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (name: Exclude, f: (a: NoInfer) => Option): (self: Option) => Option<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; + /** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link Do} + * @see {@link bindTo} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ + (self: Option, name: Exclude, f: (a: NoInfer) => Option): Option<{ + [K in N | keyof A]: K extends keyof A ? A[K] : B; + }>; +}; +/** + * The "do simulation" in Effect allows you to write code in a more declarative style, similar to the "do notation" in other programming languages. It provides a way to define variables and perform operations on them using functions like `bind` and `let`. + * + * Here's how the do simulation works: + * + * 1. Start the do simulation using the `Do` value + * 2. Within the do simulation scope, you can use the `bind` function to define variables and bind them to `Option` values + * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope + * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values + * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Option, pipe } from "effect" + * + * const result = pipe( + * Option.Do, + * Option.bind("x", () => Option.some(2)), + * Option.bind("y", () => Option.some(3)), + * Option.let("sum", ({ x, y }) => x + y), + * Option.filter(({ x, y }) => x * y > 5) + * ) + * assert.deepStrictEqual(result, Option.some({ x: 2, y: 3, sum: 5 })) + * ``` + * + * @see {@link bindTo} + * @see {@link bind} + * @see {@link let_ let} + * + * @category Do notation + * @since 2.0.0 + */ +export declare const Do: Option<{}>; +/** + * Similar to `Effect.gen`, `Option.gen` provides a more readable, + * generator-based syntax for working with `Option` values, making code that + * involves `Option` easier to write and understand. This approach is similar to + * using `async/await` but tailored for `Option`. + * + * **Example** (Using `Option.gen` to Create a Combined Value) + * + * ```ts + * import { Option } from "effect" + * + * const maybeName: Option.Option = Option.some("John") + * const maybeAge: Option.Option = Option.some(25) + * + * const person = Option.gen(function* () { + * const name = (yield* maybeName).toUpperCase() + * const age = yield* maybeAge + * return { name, age } + * }) + * + * console.log(person) + * // Output: + * // { _id: 'Option', _tag: 'Some', value: { name: 'JOHN', age: 25 } } + * ``` + * + * @category Generators + * @since 2.0.0 + */ +export declare const gen: Gen.Gen>; +//# sourceMappingURL=Option.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Order.d.ts.map b/backend/node_modules/effect/dist/dts/Order.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..89265c397408d2626108bcb2b3af086eabd1ebb1 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Order.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Order.d.ts","sourceRoot":"","sources":["../../src/Order.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C;;;GAGG;AACH,MAAM,WAAW,KAAK,CAAC,EAAE,CAAC,CAAC;IACzB,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAA;CACrC;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,KACxC,KAAK,CAAC,CAAC,CAC6C,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,MAAM,CAA8C,CAAA;AAE/E;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,MAAM,CAA8C,CAAA;AAE/E;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,KAAK,CAAC,OAAO,CAA8C,CAAA;AAEjF;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,MAAM,CAA8C,CAAA;AAE/E;;GAEG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,CAAwC,CAAA;AAExF;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAA;IACjD;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;CAQ1C,CAAA;AAEL;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;OAGG;IACH,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAA;IACjE;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;CAc1D,CAAA;AAEL;;GAEG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,OAAK,KAAK,CAAC,CAAC,CAAkB,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,YAAY,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,CAAqC,CAAA;AAE3G;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAA;IACpD;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;CAIjD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,KAAK,CAAC,IAAI,CAA8C,CAAA;AAE3E;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAClE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CAK3D,CAAA;AAEL;;;GAGG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,YAAY,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAgB7E,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACzF,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CAOrF,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACvD,GAAG,UAAU,CAAC,KACb,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,GAAE,CAAC,CAAyB,CAAA;AAE3G;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAYzD,CAAA;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS;IAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;CAAE,EACnE,QAAQ,CAAC,KACR,KAAK,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,GAAE,CAWvE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IACxC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;IAC/B,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAA;CAC2B,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IAC3C,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;IAC/B,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAA;CAC0B,CAAA;AAEvD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IACjD,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;IAC/B,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAA;CAC0B,CAAA;AAEvD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IACpD,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;IAC/B,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAA;CAC2B,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IACnC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAA;CAC6D,CAAA;AAEpF;;;;GAIG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IACnC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAA;CAC8D,CAAA;AAErF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IACrC,CAAC,OAAO,EAAE;QACR,OAAO,EAAE,CAAC,CAAA;QACV,OAAO,EAAE,CAAC,CAAA;KACX,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;IAClB,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE;QACjB,OAAO,EAAE,CAAC,CAAA;QACV,OAAO,EAAE,CAAC,CAAA;KACX,GAAG,CAAC,CAAA;CAQJ,CAAA;AAEH;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAG;IACvC,CAAC,OAAO,EAAE;QACR,OAAO,EAAE,CAAC,CAAA;QACV,OAAO,EAAE,CAAC,CAAA;KACX,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;IACxB,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE;QACjB,OAAO,EAAE,CAAC,CAAA;QACV,OAAO,EAAE,CAAC,CAAA;KACX,GAAG,OAAO,CAAA;CAQV,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Ordering.d.ts b/backend/node_modules/effect/dist/dts/Ordering.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b3f262c3319882450aadded7b1dfab0083638ada --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Ordering.d.ts @@ -0,0 +1,144 @@ +/** + * @since 2.0.0 + */ +import type { LazyArg } from "./Function.js"; +/** + * @category model + * @since 2.0.0 + */ +export type Ordering = -1 | 0 | 1; +/** + * Inverts the ordering of the input `Ordering`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { reverse } from "effect/Ordering" + * + * assert.deepStrictEqual(reverse(1), -1) + * assert.deepStrictEqual(reverse(-1), 1) + * assert.deepStrictEqual(reverse(0), 0) + * ``` + * + * @since 2.0.0 + */ +export declare const reverse: (o: Ordering) => Ordering; +/** + * Depending on the `Ordering` parameter given to it, returns a value produced by one of the 3 functions provided as parameters. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Ordering } from "effect" + * import { constant } from "effect/Function" + * + * const toMessage = Ordering.match({ + * onLessThan: constant('less than'), + * onEqual: constant('equal'), + * onGreaterThan: constant('greater than') + * }) + * + * assert.deepStrictEqual(toMessage(-1), "less than") + * assert.deepStrictEqual(toMessage(0), "equal") + * assert.deepStrictEqual(toMessage(1), "greater than") + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ +export declare const match: { + /** + * Depending on the `Ordering` parameter given to it, returns a value produced by one of the 3 functions provided as parameters. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Ordering } from "effect" + * import { constant } from "effect/Function" + * + * const toMessage = Ordering.match({ + * onLessThan: constant('less than'), + * onEqual: constant('equal'), + * onGreaterThan: constant('greater than') + * }) + * + * assert.deepStrictEqual(toMessage(-1), "less than") + * assert.deepStrictEqual(toMessage(0), "equal") + * assert.deepStrictEqual(toMessage(1), "greater than") + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (options: { + readonly onLessThan: LazyArg; + readonly onEqual: LazyArg; + readonly onGreaterThan: LazyArg; + }): (self: Ordering) => A | B | C; + /** + * Depending on the `Ordering` parameter given to it, returns a value produced by one of the 3 functions provided as parameters. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Ordering } from "effect" + * import { constant } from "effect/Function" + * + * const toMessage = Ordering.match({ + * onLessThan: constant('less than'), + * onEqual: constant('equal'), + * onGreaterThan: constant('greater than') + * }) + * + * assert.deepStrictEqual(toMessage(-1), "less than") + * assert.deepStrictEqual(toMessage(0), "equal") + * assert.deepStrictEqual(toMessage(1), "greater than") + * ``` + * + * @category pattern matching + * @since 2.0.0 + */ + (o: Ordering, options: { + readonly onLessThan: LazyArg; + readonly onEqual: LazyArg; + readonly onGreaterThan: LazyArg; + }): A | B | C; +}; +/** + * @category combining + * @since 2.0.0 + */ +export declare const combine: { + /** + * @category combining + * @since 2.0.0 + */ + (that: Ordering): (self: Ordering) => Ordering; + /** + * @category combining + * @since 2.0.0 + */ + (self: Ordering, that: Ordering): Ordering; +}; +/** + * @category combining + * @since 2.0.0 + */ +export declare const combineMany: { + /** + * @category combining + * @since 2.0.0 + */ + (collection: Iterable): (self: Ordering) => Ordering; + /** + * @category combining + * @since 2.0.0 + */ + (self: Ordering, collection: Iterable): Ordering; +}; +/** + * @category combining + * @since 2.0.0 + */ +export declare const combineAll: (collection: Iterable) => Ordering; +//# sourceMappingURL=Ordering.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Ordering.d.ts.map b/backend/node_modules/effect/dist/dts/Ordering.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..9faa37c04b1537ac69f96228f04b0dfad8097b32 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Ordering.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Ordering.d.ts","sourceRoot":"","sources":["../../src/Ordering.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAG5C;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAEjC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,QAAQ,KAAG,QAA6C,CAAA;AAEnF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EACV,OAAO,EAAE;QACP,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC5B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;KACnC,GACA,CAAC,IAAI,EAAE,QAAQ,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAChC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EACV,CAAC,EAAE,QAAQ,EACX,OAAO,EAAE;QACP,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC5B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;KACnC,GACA,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;CAQwE,CAAA;AAEtF;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAA;IAC9C;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;CACuC,CAAA;AAEnF;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;OAGG;IACH,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAA;IAC9D;;;OAGG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAA;CAY1D,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,YAAY,QAAQ,CAAC,QAAQ,CAAC,KAAG,QAAsC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ParseResult.d.ts b/backend/node_modules/effect/dist/dts/ParseResult.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1ace9480619a6b4f9551ba54b7726ad44e0bbbb2 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ParseResult.d.ts @@ -0,0 +1,560 @@ +/** + * @since 3.10.0 + */ +import * as Arr from "./Array.js"; +import * as Cause from "./Cause.js"; +import * as Effect from "./Effect.js"; +import * as Either from "./Either.js"; +import type { LazyArg } from "./Function.js"; +import * as Inspectable from "./Inspectable.js"; +import * as Option from "./Option.js"; +import type * as Schema from "./Schema.js"; +import * as AST from "./SchemaAST.js"; +/** + * `ParseIssue` is a type that represents the different types of errors that can occur when decoding/encoding a value. + * + * @category model + * @since 3.10.0 + */ +export type ParseIssue = Type | Missing | Unexpected | Forbidden | Pointer | Refinement | Transformation | Composite; +/** + * @category model + * @since 3.10.0 + */ +export type SingleOrNonEmpty = A | Arr.NonEmptyReadonlyArray; +/** + * @category model + * @since 3.10.0 + */ +export type Path = SingleOrNonEmpty; +/** + * @category model + * @since 3.10.0 + */ +export declare class Pointer { + readonly path: Path; + readonly actual: unknown; + readonly issue: ParseIssue; + /** + * @since 3.10.0 + */ + readonly _tag = "Pointer"; + constructor(path: Path, actual: unknown, issue: ParseIssue); +} +/** + * Error that occurs when an unexpected key or index is present. + * + * @category model + * @since 3.10.0 + */ +export declare class Unexpected { + readonly actual: unknown; + /** + * @since 3.10.0 + */ + readonly message?: string | undefined; + /** + * @since 3.10.0 + */ + readonly _tag = "Unexpected"; + constructor(actual: unknown, + /** + * @since 3.10.0 + */ + message?: string | undefined); +} +/** + * Error that occurs when a required key or index is missing. + * + * @category model + * @since 3.10.0 + */ +export declare class Missing { + /** + * @since 3.10.0 + */ + readonly ast: AST.Type; + /** + * @since 3.10.0 + */ + readonly message?: string | undefined; + /** + * @since 3.10.0 + */ + readonly _tag = "Missing"; + /** + * @since 3.10.0 + */ + readonly actual: undefined; + constructor( + /** + * @since 3.10.0 + */ + ast: AST.Type, + /** + * @since 3.10.0 + */ + message?: string | undefined); +} +/** + * Error that contains multiple issues. + * + * @category model + * @since 3.10.0 + */ +export declare class Composite { + readonly ast: AST.AST; + readonly actual: unknown; + readonly issues: SingleOrNonEmpty; + readonly output?: unknown | undefined; + /** + * @since 3.10.0 + */ + readonly _tag = "Composite"; + constructor(ast: AST.AST, actual: unknown, issues: SingleOrNonEmpty, output?: unknown | undefined); +} +/** + * Error that occurs when a refinement has an error. + * + * @category model + * @since 3.10.0 + */ +export declare class Refinement { + readonly ast: AST.Refinement; + readonly actual: unknown; + readonly kind: "From" | "Predicate"; + readonly issue: ParseIssue; + /** + * @since 3.10.0 + */ + readonly _tag = "Refinement"; + constructor(ast: AST.Refinement, actual: unknown, kind: "From" | "Predicate", issue: ParseIssue); +} +/** + * Error that occurs when a transformation has an error. + * + * @category model + * @since 3.10.0 + */ +export declare class Transformation { + readonly ast: AST.Transformation; + readonly actual: unknown; + readonly kind: "Encoded" | "Transformation" | "Type"; + readonly issue: ParseIssue; + /** + * @since 3.10.0 + */ + readonly _tag = "Transformation"; + constructor(ast: AST.Transformation, actual: unknown, kind: "Encoded" | "Transformation" | "Type", issue: ParseIssue); +} +/** + * The `Type` variant of the `ParseIssue` type represents an error that occurs when the `actual` value is not of the expected type. + * The `ast` field specifies the expected type, and the `actual` field contains the value that caused the error. + * + * @category model + * @since 3.10.0 + */ +export declare class Type { + readonly ast: AST.AST; + readonly actual: unknown; + readonly message?: string | undefined; + /** + * @since 3.10.0 + */ + readonly _tag = "Type"; + constructor(ast: AST.AST, actual: unknown, message?: string | undefined); +} +/** + * The `Forbidden` variant of the `ParseIssue` type represents a forbidden operation, such as when encountering an Effect that is not allowed to execute (e.g., using `runSync`). + * + * @category model + * @since 3.10.0 + */ +export declare class Forbidden { + readonly ast: AST.AST; + readonly actual: unknown; + readonly message?: string | undefined; + /** + * @since 3.10.0 + */ + readonly _tag = "Forbidden"; + constructor(ast: AST.AST, actual: unknown, message?: string | undefined); +} +/** + * @category type id + * @since 3.10.0 + */ +export declare const ParseErrorTypeId: unique symbol; +/** + * @category type id + * @since 3.10.0 + */ +export type ParseErrorTypeId = typeof ParseErrorTypeId; +/** + * @since 3.10.0 + */ +export declare const isParseError: (u: unknown) => u is ParseError; +declare const ParseError_base: new = {}>(args: import("./Types.js").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & { + readonly _tag: "ParseError"; +} & Readonly; +/** + * @since 3.10.0 + */ +export declare class ParseError extends ParseError_base<{ + readonly issue: ParseIssue; +}> { + /** + * @since 3.10.0 + */ + readonly [ParseErrorTypeId]: symbol; + get message(): string; + /** + * @since 3.10.0 + */ + toString(): string; + /** + * @since 3.10.0 + */ + toJSON(): { + _id: string; + message: string; + }; + /** + * @since 3.10.0 + */ + [Inspectable.NodeInspectSymbol](): { + _id: string; + message: string; + }; +} +/** + * @category constructors + * @since 3.10.0 + */ +export declare const parseError: (issue: ParseIssue) => ParseError; +/** + * @category constructors + * @since 3.10.0 + */ +export declare const succeed: (a: A) => Either.Either; +/** + * @category constructors + * @since 3.10.0 + */ +export declare const fail: (issue: ParseIssue) => Either.Either; +declare const _try: (options: { + try: LazyArg; + catch: (e: unknown) => ParseIssue; +}) => Either.Either; +export { +/** + * @category constructors + * @since 3.10.0 + */ +_try as try }; +/** + * @category constructors + * @since 3.10.0 + */ +export declare const fromOption: { + /** + * @category constructors + * @since 3.10.0 + */ + (onNone: () => ParseIssue): (self: Option.Option) => Either.Either; + /** + * @category constructors + * @since 3.10.0 + */ + (self: Option.Option, onNone: () => ParseIssue): Either.Either; +}; +/** + * @category optimisation + * @since 3.10.0 + */ +export declare const flatMap: { + /** + * @category optimisation + * @since 3.10.0 + */ + (f: (a: A) => Effect.Effect): (self: Effect.Effect) => Effect.Effect; + /** + * @category optimisation + * @since 3.10.0 + */ + (self: Effect.Effect, f: (a: A) => Effect.Effect): Effect.Effect; +}; +/** + * @category optimisation + * @since 3.10.0 + */ +export declare const map: { + /** + * @category optimisation + * @since 3.10.0 + */ + (f: (a: A) => B): (self: Effect.Effect) => Effect.Effect; + /** + * @category optimisation + * @since 3.10.0 + */ + (self: Effect.Effect, f: (a: A) => B): Effect.Effect; +}; +/** + * @category optimisation + * @since 3.10.0 + */ +export declare const mapError: { + /** + * @category optimisation + * @since 3.10.0 + */ + (f: (e: E) => E2): (self: Effect.Effect) => Effect.Effect; + /** + * @category optimisation + * @since 3.10.0 + */ + (self: Effect.Effect, f: (e: E) => E2): Effect.Effect; +}; +/** + * @category optimisation + * @since 3.10.0 + */ +export declare const eitherOrUndefined: (self: Effect.Effect) => Either.Either | undefined; +/** + * @category optimisation + * @since 3.10.0 + */ +export declare const mapBoth: { + /** + * @category optimisation + * @since 3.10.0 + */ + (options: { + readonly onFailure: (e: E) => E2; + readonly onSuccess: (a: A) => A2; + }): (self: Effect.Effect) => Effect.Effect; + /** + * @category optimisation + * @since 3.10.0 + */ + (self: Effect.Effect, options: { + readonly onFailure: (e: E) => E2; + readonly onSuccess: (a: A) => A2; + }): Effect.Effect; +}; +/** + * @category optimisation + * @since 3.10.0 + */ +export declare const orElse: { + /** + * @category optimisation + * @since 3.10.0 + */ + (f: (e: E) => Effect.Effect): (self: Effect.Effect) => Effect.Effect; + /** + * @category optimisation + * @since 3.10.0 + */ + (self: Effect.Effect, f: (e: E) => Effect.Effect): Effect.Effect; +}; +/** + * @since 3.10.0 + */ +export type DecodeUnknown = (u: unknown, options?: AST.ParseOptions) => Effect.Effect; +/** + * @since 3.10.0 + */ +export type DeclarationDecodeUnknown = (u: unknown, options: AST.ParseOptions, ast: AST.Declaration) => Effect.Effect; +/** + * @throws `ParseError` + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknownSync: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => A; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknownOption: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Option.Option; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknownEither: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Either.Either; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknownPromise: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Promise; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknown: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Effect.Effect; +/** + * @throws `ParseError` + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknownSync: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => I; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknownOption: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Option.Option; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknownEither: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Either.Either; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknownPromise: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Promise; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknown: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Effect.Effect; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeSync: (schema: Schema.Schema, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => A; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeOption: (schema: Schema.Schema, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Option.Option; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeEither: (schema: Schema.Schema, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Either.Either; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodePromise: (schema: Schema.Schema, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Promise; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decode: (schema: Schema.Schema, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Effect.Effect; +/** + * @throws `ParseError` + * @category validation + * @since 3.10.0 + */ +export declare const validateSync: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => A; +/** + * @category validation + * @since 3.10.0 + */ +export declare const validateOption: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Option.Option; +/** + * @category validation + * @since 3.10.0 + */ +export declare const validateEither: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Either.Either; +/** + * @category validation + * @since 3.10.0 + */ +export declare const validatePromise: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => Promise; +/** + * @category validation + * @since 3.10.0 + */ +export declare const validate: (schema: Schema.Schema, options?: AST.ParseOptions) => (a: unknown, overrideOptions?: AST.ParseOptions) => Effect.Effect; +/** + * By default the option `exact` is set to `true`. + * + * @category validation + * @since 3.10.0 + */ +export declare const is: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions | number) => u is A; +/** + * By default the option `exact` is set to `true`. + * + * @throws `ParseError` + * @category validation + * @since 3.10.0 + */ +export declare const asserts: (schema: Schema.Schema, options?: AST.ParseOptions) => (u: unknown, overrideOptions?: AST.ParseOptions) => asserts u is A; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeSync: (schema: Schema.Schema, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => I; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeOption: (schema: Schema.Schema, options?: AST.ParseOptions) => (input: A, overrideOptions?: AST.ParseOptions) => Option.Option; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeEither: (schema: Schema.Schema, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => Either.Either; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodePromise: (schema: Schema.Schema, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => Promise; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encode: (schema: Schema.Schema, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => Effect.Effect; +/** + * @category formatting + * @since 3.10.0 + */ +export interface ParseResultFormatter { + readonly formatIssue: (issue: ParseIssue) => Effect.Effect; + readonly formatIssueSync: (issue: ParseIssue) => A; + readonly formatError: (error: ParseError) => Effect.Effect; + readonly formatErrorSync: (error: ParseError) => A; +} +/** + * @category formatting + * @since 3.10.0 + */ +export declare const TreeFormatter: ParseResultFormatter; +/** + * Returns `true` if the value is a `Composite`. + * + * @category guards + * @since 3.10.0 + */ +export declare const isComposite: (issue: ParseIssue) => issue is Composite; +/** + * Represents an issue returned by the {@link ArrayFormatter} formatter. + * + * @category model + * @since 3.10.0 + */ +export interface ArrayFormatterIssue { + /** + * The tag identifying the type of parse issue. + */ + readonly _tag: ParseIssue["_tag"]; + /** + * The path to the property where the issue occurred. + */ + readonly path: ReadonlyArray; + /** + * A descriptive message explaining the issue. + */ + readonly message: string; +} +/** + * @category formatting + * @since 3.10.0 + */ +export declare const ArrayFormatter: ParseResultFormatter>; +//# sourceMappingURL=ParseResult.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/PartitionedSemaphore.d.ts b/backend/node_modules/effect/dist/dts/PartitionedSemaphore.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..446feb7c11a64df74aa3666995a3a39236f4fea0 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/PartitionedSemaphore.d.ts @@ -0,0 +1,76 @@ +/** + * @since 3.19.4 + * @experimental + */ +import * as Effect from "./Effect.js"; +/** + * @since 3.19.4 + * @category Models + * @experimental + */ +export declare const TypeId: TypeId; +/** + * @since 3.19.4 + * @category Models + * @experimental + */ +export type TypeId = "~effect/PartitionedSemaphore"; +/** + * A `PartitionedSemaphore` is a concurrency primitive that can be used to + * control concurrent access to a resource across multiple partitions identified + * by keys. + * + * The total number of permits is shared across all partitions, with waiting + * permits equally distributed among partitions using a round-robin strategy. + * + * This is useful when you want to limit the total number of concurrent accesses + * to a resource, while still allowing for fair distribution of access across + * different partitions. + * + * @since 3.19.4 + * @category Models + * @experimental + */ +export interface PartitionedSemaphore { + readonly [TypeId]: TypeId; + readonly withPermits: (key: K, permits: number) => (effect: Effect.Effect) => Effect.Effect; +} +/** + * A `PartitionedSemaphore` is a concurrency primitive that can be used to + * control concurrent access to a resource across multiple partitions identified + * by keys. + * + * The total number of permits is shared across all partitions, with waiting + * permits equally distributed among partitions using a round-robin strategy. + * + * This is useful when you want to limit the total number of concurrent accesses + * to a resource, while still allowing for fair distribution of access across + * different partitions. + * + * @since 3.19.4 + * @category Constructors + * @experimental + */ +export declare const makeUnsafe: (options: { + readonly permits: number; +}) => PartitionedSemaphore; +/** + * A `PartitionedSemaphore` is a concurrency primitive that can be used to + * control concurrent access to a resource across multiple partitions identified + * by keys. + * + * The total number of permits is shared across all partitions, with waiting + * permits equally distributed among partitions using a round-robin strategy. + * + * This is useful when you want to limit the total number of concurrent accesses + * to a resource, while still allowing for fair distribution of access across + * different partitions. + * + * @since 3.19.4 + * @category Constructors + * @experimental + */ +export declare const make: (options: { + readonly permits: number; +}) => Effect.Effect>; +//# sourceMappingURL=PartitionedSemaphore.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Pipeable.d.ts.map b/backend/node_modules/effect/dist/dts/Pipeable.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..9aefe4891877d8e375ae9c61b01b7fc68d1489f3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Pipeable.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Pipeable.d.ts","sourceRoot":"","sources":["../../src/Pipeable.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Pool.d.ts b/backend/node_modules/effect/dist/dts/Pool.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a9de488a100c03fdab4df6e90ac3b0e2277347a6 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Pool.d.ts @@ -0,0 +1,201 @@ +/** + * @since 2.0.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Scope from "./Scope.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const PoolTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type PoolTypeId = typeof PoolTypeId; +/** + * A `Pool` is a pool of items of type `A`, each of which may be + * associated with the acquisition and release of resources. An attempt to get + * an item `A` from a pool may fail with an error of type `E`. + * + * @since 2.0.0 + * @category models + */ +export interface Pool extends Pool.Variance, Effect.Effect, Pipeable { + /** + * Retrieves an item from the pool in a scoped effect. Note that if + * acquisition fails, then the returned effect will fail for that same reason. + * Retrying a failed acquisition attempt will repeat the acquisition attempt. + */ + readonly get: Effect.Effect; + /** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + */ + invalidate(item: A): Effect.Effect; + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: PoolUnify; + readonly [Unify.ignoreSymbol]?: PoolUnifyIgnore; +} +/** + * @category models + * @since 3.9.0 + */ +export interface PoolUnify extends Effect.EffectUnify { + Pool?: () => Extract> extends Pool | infer _ ? A0 extends any ? Extract> extends Pool ? Pool : never : never : never; +} +/** + * @category models + * @since 3.9.0 + */ +export interface PoolUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * @since 2.0.0 + */ +export declare namespace Pool { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [PoolTypeId]: { + readonly _A: Types.Invariant; + readonly _E: Types.Covariant; + }; + } +} +/** + * Returns `true` if the specified value is a `Pool`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isPool: (u: unknown) => u is Pool; +/** + * Makes a new pool of the specified fixed size. The pool is returned in a + * `Scope`, which governs the lifetime of the pool. When the pool is shutdown + * because the `Scope` is closed, the individual items allocated by the pool + * will be released in some unspecified order. + * + * By setting the `concurrency` parameter, you can control the level of concurrent + * access per pool item. By default, the number of permits is set to `1`. + * + * `targetUtilization` determines when to create new pool items. It is a value + * between 0 and 1, where 1 means only create new pool items when all the existing + * items are fully utilized. + * + * A `targetUtilization` of 0.5 will create new pool items when the existing items are + * 50% utilized. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (options: { + readonly acquire: Effect.Effect; + readonly size: number; + readonly concurrency?: number | undefined; + readonly targetUtilization?: number | undefined; +}) => Effect.Effect, never, Scope.Scope | R>; +/** + * Makes a new pool with the specified minimum and maximum sizes and time to + * live before a pool whose excess items are not being used will be shrunk + * down to the minimum size. The pool is returned in a `Scope`, which governs + * the lifetime of the pool. When the pool is shutdown because the `Scope` is + * used, the individual items allocated by the pool will be released in some + * unspecified order. + * + * By setting the `concurrency` parameter, you can control the level of concurrent + * access per pool item. By default, the number of permits is set to `1`. + * + * `targetUtilization` determines when to create new pool items. It is a value + * between 0 and 1, where 1 means only create new pool items when all the existing + * items are fully utilized. + * + * A `targetUtilization` of 0.5 will create new pool items when the existing items are + * 50% utilized. + * + * The `timeToLiveStrategy` determines how items are invalidated. If set to + * "creation", then items are invalidated based on their creation time. If set + * to "usage", then items are invalidated based on pool usage. + * + * By default, the `timeToLiveStrategy` is set to "usage". + * + * ```ts skip-type-checking + * import { createConnection } from "mysql2"; + * import { Duration, Effect, Pool } from "effect" + * + * const acquireDBConnection = Effect.acquireRelease( + * Effect.sync(() => createConnection('mysql://...')), + * (connection) => Effect.sync(() => connection.end(() => {})), + * ) + * + * const connectionPool = Effect.flatMap( + * Pool.makeWithTTL({ + * acquire: acquireDBConnection, + * min: 10, + * max: 20, + * timeToLive: Duration.seconds(60) + * }), + * (pool) => pool.get + * ) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeWithTTL: (options: { + readonly acquire: Effect.Effect; + readonly min: number; + readonly max: number; + readonly concurrency?: number | undefined; + readonly targetUtilization?: number | undefined; + readonly timeToLive: Duration.DurationInput; + readonly timeToLiveStrategy?: "creation" | "usage" | undefined; +}) => Effect.Effect, never, Scope.Scope | R>; +/** + * Retrieves an item from the pool in a scoped effect. Note that if + * acquisition fails, then the returned effect will fail for that same reason. + * Retrying a failed acquisition attempt will repeat the acquisition attempt. + * + * @since 2.0.0 + * @category getters + */ +export declare const get: (self: Pool) => Effect.Effect; +/** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + * + * @since 2.0.0 + * @category combinators + */ +export declare const invalidate: { + /** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + * + * @since 2.0.0 + * @category combinators + */ + (value: A): (self: Pool) => Effect.Effect; + /** + * Invalidates the specified item. This will cause the pool to eventually + * reallocate the item, although this reallocation may occur lazily rather + * than eagerly. + * + * @since 2.0.0 + * @category combinators + */ + (self: Pool, value: A): Effect.Effect; +}; +//# sourceMappingURL=Pool.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Pool.d.ts.map b/backend/node_modules/effect/dist/dts/Pool.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..ad5aabd0fe00193b3348a242c4b413b9dea71f9f --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Pool.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Pool.d.ts","sourceRoot":"","sources":["../../src/Pool.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Predicate.d.ts b/backend/node_modules/effect/dist/dts/Predicate.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..edf239d76edc80315efe394e2322736c84999b4a --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Predicate.d.ts @@ -0,0 +1,2197 @@ +import type { TypeLambda } from "./HKT.js"; +import type { TupleOf, TupleOfAtLeast } from "./Types.js"; +/** + * Represents a function that takes a value of type `A` and returns `true` if the value + * satisfies some condition, `false` otherwise. + * + * @example + * ```ts + * import { Predicate } from "effect" + * import * as assert from "node:assert" + * + * const isEven: Predicate.Predicate = (n) => n % 2 === 0 + * + * assert.strictEqual(isEven(2), true) + * assert.strictEqual(isEven(3), false) + * ``` + * + * @category models + * @since 2.0.0 + */ +export interface Predicate { + (a: A): boolean; +} +/** + * A `TypeLambda` for `Predicate`. This is used to support higher-kinded types + * and allows `Predicate` to be used in generic contexts within the `effect` ecosystem. + * + * @category type lambdas + * @since 2.0.0 + */ +export interface PredicateTypeLambda extends TypeLambda { + readonly type: Predicate; +} +/** + * Represents a function that serves as a type guard. + * + * A `Refinement` is a function that takes a value of type `A` and returns a + * type predicate `a is B`, where `B` is a subtype of `A`. If the function returns + * `true`, TypeScript will narrow the type of the input variable to `B`. + * + * @example + * ```ts + * import { Predicate } from "effect" + * import * as assert from "node:assert" + * + * const isString: Predicate.Refinement = (u): u is string => typeof u === "string" + * + * const value: unknown = "hello" + * + * if (isString(value)) { + * // value is now known to be a string + * assert.strictEqual(value.toUpperCase(), "HELLO") + * } + * ``` + * + * @category models + * @since 2.0.0 + */ +export interface Refinement { + (a: A): a is B; +} +/** + * A namespace for type-level utilities for `Predicate`. + * + * @since 3.6.0 + * @category type-level + */ +export declare namespace Predicate { + /** + * Extracts the input type `A` from a `Predicate`. + * + * @example + * ```ts + * import { type Predicate } from "effect" + * + * type T = Predicate.Predicate.In> // T is string + * ``` + * + * @since 3.6.0 + * @category type-level + */ + type In = [T] extends [Predicate] ? _A : never; + /** + * A type representing any `Predicate`. + * + * @since 3.6.0 + * @category type-level + */ + type Any = Predicate; +} +/** + * A namespace for type-level utilities for `Refinement`. + * + * @since 3.6.0 + * @category type-level + */ +export declare namespace Refinement { + /** + * Extracts the input type `A` from a `Refinement`. + * + * @example + * ```ts + * import { type Predicate } from "effect" + * + * type IsString = Predicate.Refinement + * type T = Predicate.Refinement.In // T is unknown + * ``` + * + * @since 3.6.0 + * @category type-level + */ + type In = [T] extends [Refinement] ? _A : never; + /** + * Extracts the output (refined) type `B` from a `Refinement`. + * + * @example + * ```ts + * import { type Predicate } from "effect" + * + * type IsString = Predicate.Refinement + * type T = Predicate.Refinement.Out // T is string + * ``` + * + * @since 3.6.0 + * @category type-level + */ + type Out = [T] extends [Refinement] ? _B : never; + /** + * A type representing any `Refinement`. + * + * @since 3.6.0 + * @category type-level + */ + type Any = Refinement; +} +/** + * Transforms a `Predicate` into a `Predicate` by applying a function `(b: B) => A` + * to the input before passing it to the predicate. This is also known as "contramap" or + * "pre-composition". + * + * @example + * ```ts + * import { Predicate, Number } from "effect" + * import * as assert from "node:assert" + * + * // A predicate on numbers + * const isPositive: Predicate.Predicate = Number.greaterThan(0) + * + * // A function from `string` to `number` + * const stringLength = (s: string): number => s.length + * + * // Create a new predicate on strings by mapping the input + * const hasPositiveLength = Predicate.mapInput(isPositive, stringLength) + * + * assert.strictEqual(hasPositiveLength("hello"), true) + * assert.strictEqual(hasPositiveLength(""), false) + * ``` + * + * @category combinators + * @since 2.0.0 + */ +export declare const mapInput: { + /** + * Transforms a `Predicate` into a `Predicate` by applying a function `(b: B) => A` + * to the input before passing it to the predicate. This is also known as "contramap" or + * "pre-composition". + * + * @example + * ```ts + * import { Predicate, Number } from "effect" + * import * as assert from "node:assert" + * + * // A predicate on numbers + * const isPositive: Predicate.Predicate = Number.greaterThan(0) + * + * // A function from `string` to `number` + * const stringLength = (s: string): number => s.length + * + * // Create a new predicate on strings by mapping the input + * const hasPositiveLength = Predicate.mapInput(isPositive, stringLength) + * + * assert.strictEqual(hasPositiveLength("hello"), true) + * assert.strictEqual(hasPositiveLength(""), false) + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (f: (b: B) => A): (self: Predicate) => Predicate; + /** + * Transforms a `Predicate` into a `Predicate` by applying a function `(b: B) => A` + * to the input before passing it to the predicate. This is also known as "contramap" or + * "pre-composition". + * + * @example + * ```ts + * import { Predicate, Number } from "effect" + * import * as assert from "node:assert" + * + * // A predicate on numbers + * const isPositive: Predicate.Predicate = Number.greaterThan(0) + * + * // A function from `string` to `number` + * const stringLength = (s: string): number => s.length + * + * // Create a new predicate on strings by mapping the input + * const hasPositiveLength = Predicate.mapInput(isPositive, stringLength) + * + * assert.strictEqual(hasPositiveLength("hello"), true) + * assert.strictEqual(hasPositiveLength(""), false) + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (self: Predicate, f: (b: B) => A): Predicate; +}; +/** + * A refinement that checks if a `ReadonlyArray` is a tuple with exactly `N` elements. + * If the check is successful, the type is narrowed to `TupleOf`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTupleOf } from "effect/Predicate" + * + * const isTupleOf3 = isTupleOf(3) + * + * assert.strictEqual(isTupleOf3([1, 2, 3]), true); + * assert.strictEqual(isTupleOf3([1, 2]), false); + * + * const arr: number[] = [1, 2, 3]; + * if (isTupleOf(arr, 3)) { + * // The type of arr is now [number, number, number] + * const [a, b, c] = arr; + * assert.deepStrictEqual([a, b, c], [1, 2, 3]) + * } + * ``` + * + * @category guards + * @since 3.3.0 + */ +export declare const isTupleOf: { + /** + * A refinement that checks if a `ReadonlyArray` is a tuple with exactly `N` elements. + * If the check is successful, the type is narrowed to `TupleOf`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTupleOf } from "effect/Predicate" + * + * const isTupleOf3 = isTupleOf(3) + * + * assert.strictEqual(isTupleOf3([1, 2, 3]), true); + * assert.strictEqual(isTupleOf3([1, 2]), false); + * + * const arr: number[] = [1, 2, 3]; + * if (isTupleOf(arr, 3)) { + * // The type of arr is now [number, number, number] + * const [a, b, c] = arr; + * assert.deepStrictEqual([a, b, c], [1, 2, 3]) + * } + * ``` + * + * @category guards + * @since 3.3.0 + */ + (n: N): (self: ReadonlyArray) => self is TupleOf; + /** + * A refinement that checks if a `ReadonlyArray` is a tuple with exactly `N` elements. + * If the check is successful, the type is narrowed to `TupleOf`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTupleOf } from "effect/Predicate" + * + * const isTupleOf3 = isTupleOf(3) + * + * assert.strictEqual(isTupleOf3([1, 2, 3]), true); + * assert.strictEqual(isTupleOf3([1, 2]), false); + * + * const arr: number[] = [1, 2, 3]; + * if (isTupleOf(arr, 3)) { + * // The type of arr is now [number, number, number] + * const [a, b, c] = arr; + * assert.deepStrictEqual([a, b, c], [1, 2, 3]) + * } + * ``` + * + * @category guards + * @since 3.3.0 + */ + (self: ReadonlyArray, n: N): self is TupleOf; +}; +/** + * A refinement that checks if a `ReadonlyArray` is a tuple with at least `N` elements. + * If the check is successful, the type is narrowed to `TupleOfAtLeast`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTupleOfAtLeast } from "effect/Predicate" + * + * const isTupleOfAtLeast3 = isTupleOfAtLeast(3) + * + * assert.strictEqual(isTupleOfAtLeast3([1, 2, 3]), true); + * assert.strictEqual(isTupleOfAtLeast3([1, 2, 3, 4]), true); + * assert.strictEqual(isTupleOfAtLeast3([1, 2]), false); + * + * const arr: number[] = [1, 2, 3, 4]; + * if (isTupleOfAtLeast(arr, 3)) { + * // The type of arr is now [number, number, number, ...number[]] + * const [a, b, c] = arr; + * assert.deepStrictEqual([a, b, c], [1, 2, 3]) + * } + * ``` + * + * @category guards + * @since 3.3.0 + */ +export declare const isTupleOfAtLeast: { + /** + * A refinement that checks if a `ReadonlyArray` is a tuple with at least `N` elements. + * If the check is successful, the type is narrowed to `TupleOfAtLeast`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTupleOfAtLeast } from "effect/Predicate" + * + * const isTupleOfAtLeast3 = isTupleOfAtLeast(3) + * + * assert.strictEqual(isTupleOfAtLeast3([1, 2, 3]), true); + * assert.strictEqual(isTupleOfAtLeast3([1, 2, 3, 4]), true); + * assert.strictEqual(isTupleOfAtLeast3([1, 2]), false); + * + * const arr: number[] = [1, 2, 3, 4]; + * if (isTupleOfAtLeast(arr, 3)) { + * // The type of arr is now [number, number, number, ...number[]] + * const [a, b, c] = arr; + * assert.deepStrictEqual([a, b, c], [1, 2, 3]) + * } + * ``` + * + * @category guards + * @since 3.3.0 + */ + (n: N): (self: ReadonlyArray) => self is TupleOfAtLeast; + /** + * A refinement that checks if a `ReadonlyArray` is a tuple with at least `N` elements. + * If the check is successful, the type is narrowed to `TupleOfAtLeast`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTupleOfAtLeast } from "effect/Predicate" + * + * const isTupleOfAtLeast3 = isTupleOfAtLeast(3) + * + * assert.strictEqual(isTupleOfAtLeast3([1, 2, 3]), true); + * assert.strictEqual(isTupleOfAtLeast3([1, 2, 3, 4]), true); + * assert.strictEqual(isTupleOfAtLeast3([1, 2]), false); + * + * const arr: number[] = [1, 2, 3, 4]; + * if (isTupleOfAtLeast(arr, 3)) { + * // The type of arr is now [number, number, number, ...number[]] + * const [a, b, c] = arr; + * assert.deepStrictEqual([a, b, c], [1, 2, 3]) + * } + * ``` + * + * @category guards + * @since 3.3.0 + */ + (self: ReadonlyArray, n: N): self is TupleOfAtLeast; +}; +/** + * A predicate that checks if a value is "truthy" in JavaScript. + * Fails for `false`, `0`, `-0`, `0n`, `""`, `null`, `undefined`, and `NaN`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTruthy } from "effect/Predicate" + * + * assert.strictEqual(isTruthy(1), true) + * assert.strictEqual(isTruthy("hello"), true) + * assert.strictEqual(isTruthy({}), true) + * + * assert.strictEqual(isTruthy(0), false) + * assert.strictEqual(isTruthy(""), false) + * assert.strictEqual(isTruthy(null), false) + * assert.strictEqual(isTruthy(undefined), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isTruthy: (input: unknown) => boolean; +/** + * A refinement that checks if a value is a `Set`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isSet } from "effect/Predicate" + * + * assert.strictEqual(isSet(new Set([1, 2])), true) + * assert.strictEqual(isSet(new Set()), true) + * + * assert.strictEqual(isSet({}), false) + * assert.strictEqual(isSet([1, 2]), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isSet: (input: unknown) => input is Set; +/** + * A refinement that checks if a value is a `Map`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isMap } from "effect/Predicate" + * + * assert.strictEqual(isMap(new Map()), true) + * + * assert.strictEqual(isMap({}), false) + * assert.strictEqual(isMap(new Set()), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isMap: (input: unknown) => input is Map; +/** + * A refinement that checks if a value is a `string`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isString } from "effect/Predicate" + * + * assert.strictEqual(isString("hello"), true) + * assert.strictEqual(isString(""), true) + * + * assert.strictEqual(isString(123), false) + * assert.strictEqual(isString(null), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isString: (input: unknown) => input is string; +/** + * A refinement that checks if a value is a `number`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNumber } from "effect/Predicate" + * + * assert.strictEqual(isNumber(123), true) + * assert.strictEqual(isNumber(0), true) + * assert.strictEqual(isNumber(-1.5), true) + * assert.strictEqual(isNumber(NaN), true) + * + * assert.strictEqual(isNumber("123"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isNumber: (input: unknown) => input is number; +/** + * A refinement that checks if a value is a `boolean`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isBoolean } from "effect/Predicate" + * + * assert.strictEqual(isBoolean(true), true) + * assert.strictEqual(isBoolean(false), true) + * + * assert.strictEqual(isBoolean("true"), false) + * assert.strictEqual(isBoolean(0), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isBoolean: (input: unknown) => input is boolean; +/** + * A refinement that checks if a value is a `bigint`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isBigInt } from "effect/Predicate" + * + * assert.strictEqual(isBigInt(1n), true) + * + * assert.strictEqual(isBigInt(1), false) + * assert.strictEqual(isBigInt("1"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isBigInt: (input: unknown) => input is bigint; +/** + * A refinement that checks if a value is a `symbol`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isSymbol } from "effect/Predicate" + * + * assert.strictEqual(isSymbol(Symbol.for("a")), true) + * + * assert.strictEqual(isSymbol("a"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isSymbol: (input: unknown) => input is symbol; +/** + * A refinement that checks if a value is a `Function`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isFunction } from "effect/Predicate" + * + * assert.strictEqual(isFunction(() => {}), true) + * assert.strictEqual(isFunction(isFunction), true) + * + * assert.strictEqual(isFunction("function"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isFunction: (input: unknown) => input is Function; +/** + * A refinement that checks if a value is `undefined`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isUndefined } from "effect/Predicate" + * + * assert.strictEqual(isUndefined(undefined), true) + * + * assert.strictEqual(isUndefined(null), false) + * assert.strictEqual(isUndefined("undefined"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isUndefined: (input: unknown) => input is undefined; +/** + * A refinement that checks if a value is not `undefined`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNotUndefined } from "effect/Predicate" + * + * assert.strictEqual(isNotUndefined(null), true) + * assert.strictEqual(isNotUndefined("value"), true) + * + * assert.strictEqual(isNotUndefined(undefined), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isNotUndefined: (input: A) => input is Exclude; +/** + * A refinement that checks if a value is `null`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNull } from "effect/Predicate" + * + * assert.strictEqual(isNull(null), true) + * + * assert.strictEqual(isNull(undefined), false) + * assert.strictEqual(isNull("null"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isNull: (input: unknown) => input is null; +/** + * A refinement that checks if a value is not `null`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNotNull } from "effect/Predicate" + * + * assert.strictEqual(isNotNull(undefined), true) + * assert.strictEqual(isNotNull("value"), true) + * + * assert.strictEqual(isNotNull(null), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isNotNull: (input: A) => input is Exclude; +/** + * A refinement that always returns `false`. The type is narrowed to `never`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNever } from "effect/Predicate" + * + * assert.strictEqual(isNever(1), false) + * assert.strictEqual(isNever(null), false) + * assert.strictEqual(isNever({}), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isNever: (input: unknown) => input is never; +/** + * A refinement that always returns `true`. The type is narrowed to `unknown`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isUnknown } from "effect/Predicate" + * + * assert.strictEqual(isUnknown(1), true) + * assert.strictEqual(isUnknown(null), true) + * assert.strictEqual(isUnknown({}), true) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isUnknown: (input: unknown) => input is unknown; +/** + * A refinement that checks if a value is an `object`. Note that in JavaScript, + * arrays and functions are also considered objects. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isObject } from "effect/Predicate" + * + * assert.strictEqual(isObject({}), true) + * assert.strictEqual(isObject([]), true) + * assert.strictEqual(isObject(() => {}), true) + * + * assert.strictEqual(isObject(null), false) + * assert.strictEqual(isObject("hello"), false) + * ``` + * + * @category guards + * @since 2.0.0 + * @see isRecord to check for plain objects (excluding arrays and functions). + */ +export declare const isObject: (input: unknown) => input is object; +/** + * A refinement that checks if a value is an object-like value and has a specific property key. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { hasProperty } from "effect/Predicate" + * + * assert.strictEqual(hasProperty({ a: 1 }, "a"), true) + * assert.strictEqual(hasProperty({ a: 1 }, "b"), false) + * + * const value: unknown = { name: "Alice" }; + * if (hasProperty(value, "name")) { + * // The type of `value` is narrowed to `{ name: unknown }` + * // and we can safely access `value.name` + * console.log(value.name) + * } + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const hasProperty: { + /** + * A refinement that checks if a value is an object-like value and has a specific property key. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { hasProperty } from "effect/Predicate" + * + * assert.strictEqual(hasProperty({ a: 1 }, "a"), true) + * assert.strictEqual(hasProperty({ a: 1 }, "b"), false) + * + * const value: unknown = { name: "Alice" }; + * if (hasProperty(value, "name")) { + * // The type of `value` is narrowed to `{ name: unknown }` + * // and we can safely access `value.name` + * console.log(value.name) + * } + * ``` + * + * @category guards + * @since 2.0.0 + */ +

(property: P): (self: unknown) => self is { + [K in P]: unknown; + }; + /** + * A refinement that checks if a value is an object-like value and has a specific property key. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { hasProperty } from "effect/Predicate" + * + * assert.strictEqual(hasProperty({ a: 1 }, "a"), true) + * assert.strictEqual(hasProperty({ a: 1 }, "b"), false) + * + * const value: unknown = { name: "Alice" }; + * if (hasProperty(value, "name")) { + * // The type of `value` is narrowed to `{ name: unknown }` + * // and we can safely access `value.name` + * console.log(value.name) + * } + * ``` + * + * @category guards + * @since 2.0.0 + */ +

(self: unknown, property: P): self is { + [K in P]: unknown; + }; +}; +/** + * A refinement that checks if a value is an object with a `_tag` property + * that matches the given tag. This is a powerful tool for working with + * discriminated union types. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTagged } from "effect/Predicate" + * + * type Shape = { _tag: "circle"; radius: number } | { _tag: "square"; side: number } + * + * const isCircle = isTagged("circle") + * + * const shape1: Shape = { _tag: "circle", radius: 10 } + * const shape2: Shape = { _tag: "square", side: 5 } + * + * assert.strictEqual(isCircle(shape1), true) + * assert.strictEqual(isCircle(shape2), false) + * + * if (isCircle(shape1)) { + * // shape1 is now narrowed to { _tag: "circle"; radius: number } + * assert.strictEqual(shape1.radius, 10) + * } + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isTagged: { + /** + * A refinement that checks if a value is an object with a `_tag` property + * that matches the given tag. This is a powerful tool for working with + * discriminated union types. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTagged } from "effect/Predicate" + * + * type Shape = { _tag: "circle"; radius: number } | { _tag: "square"; side: number } + * + * const isCircle = isTagged("circle") + * + * const shape1: Shape = { _tag: "circle", radius: 10 } + * const shape2: Shape = { _tag: "square", side: 5 } + * + * assert.strictEqual(isCircle(shape1), true) + * assert.strictEqual(isCircle(shape2), false) + * + * if (isCircle(shape1)) { + * // shape1 is now narrowed to { _tag: "circle"; radius: number } + * assert.strictEqual(shape1.radius, 10) + * } + * ``` + * + * @category guards + * @since 2.0.0 + */ + (tag: K): (self: unknown) => self is { + _tag: K; + }; + /** + * A refinement that checks if a value is an object with a `_tag` property + * that matches the given tag. This is a powerful tool for working with + * discriminated union types. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isTagged } from "effect/Predicate" + * + * type Shape = { _tag: "circle"; radius: number } | { _tag: "square"; side: number } + * + * const isCircle = isTagged("circle") + * + * const shape1: Shape = { _tag: "circle", radius: 10 } + * const shape2: Shape = { _tag: "square", side: 5 } + * + * assert.strictEqual(isCircle(shape1), true) + * assert.strictEqual(isCircle(shape2), false) + * + * if (isCircle(shape1)) { + * // shape1 is now narrowed to { _tag: "circle"; radius: number } + * assert.strictEqual(shape1.radius, 10) + * } + * ``` + * + * @category guards + * @since 2.0.0 + */ + (self: unknown, tag: K): self is { + _tag: K; + }; +}; +/** + * A refinement that checks if a value is either `null` or `undefined`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNullable } from "effect/Predicate" + * + * assert.strictEqual(isNullable(null), true) + * assert.strictEqual(isNullable(undefined), true) + * + * assert.strictEqual(isNullable(0), false) + * assert.strictEqual(isNullable(""), false) + * ``` + * + * @category guards + * @since 2.0.0 + * @see isNotNullable + */ +export declare const isNullable: (input: A) => input is Extract; +/** + * A refinement that checks if a value is neither `null` nor `undefined`. + * The type is narrowed to `NonNullable`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isNotNullable } from "effect/Predicate" + * + * assert.strictEqual(isNotNullable(0), true) + * assert.strictEqual(isNotNullable("hello"), true) + * + * assert.strictEqual(isNotNullable(null), false) + * assert.strictEqual(isNotNullable(undefined), false) + * ``` + * + * @category guards + * @since 2.0.0 + * @see isNullable + */ +export declare const isNotNullable: (input: A) => input is NonNullable; +/** + * A refinement that checks if a value is an instance of `Error`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isError } from "effect/Predicate" + * + * assert.strictEqual(isError(new Error("boom")), true) + * assert.strictEqual(isError(new TypeError("boom")), true) + * + * assert.strictEqual(isError({ message: "boom" }), false) + * assert.strictEqual(isError("boom"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isError: (input: unknown) => input is Error; +/** + * A refinement that checks if a value is a `Uint8Array`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isUint8Array } from "effect/Predicate" + * + * assert.strictEqual(isUint8Array(new Uint8Array()), true) + * + * assert.strictEqual(isUint8Array(new Uint16Array()), false) + * assert.strictEqual(isUint8Array([1, 2, 3]), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isUint8Array: (input: unknown) => input is Uint8Array; +/** + * A refinement that checks if a value is a `Date` object. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isDate } from "effect/Predicate" + * + * assert.strictEqual(isDate(new Date()), true) + * + * assert.strictEqual(isDate(Date.now()), false) // `Date.now()` returns a number + * assert.strictEqual(isDate("2023-01-01"), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isDate: (input: unknown) => input is Date; +/** + * A refinement that checks if a value is an `Iterable`. + * Many built-in types are iterable, such as `Array`, `string`, `Map`, and `Set`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isIterable } from "effect/Predicate" + * + * assert.strictEqual(isIterable([]), true) + * assert.strictEqual(isIterable("hello"), true) + * assert.strictEqual(isIterable(new Set()), true) + * + * assert.strictEqual(isIterable({}), false) + * assert.strictEqual(isIterable(123), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isIterable: (input: unknown) => input is Iterable; +/** + * A refinement that checks if a value is a record (i.e., a plain object). + * This check returns `false` for arrays, `null`, and functions. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isRecord } from "effect/Predicate" + * + * assert.strictEqual(isRecord({}), true) + * assert.strictEqual(isRecord({ a: 1 }), true) + * + * assert.strictEqual(isRecord([]), false) + * assert.strictEqual(isRecord(new Date()), false) + * assert.strictEqual(isRecord(null), false) + * assert.strictEqual(isRecord(() => null), false) + * ``` + * + * @category guards + * @since 2.0.0 + * @see isObject + */ +export declare const isRecord: (input: unknown) => input is { + [x: string | symbol]: unknown; +}; +/** + * A refinement that checks if a value is a readonly record (i.e., a plain object). + * This check returns `false` for arrays, `null`, and functions. + * + * This is an alias for `isRecord`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isReadonlyRecord } from "effect/Predicate" + * + * assert.strictEqual(isReadonlyRecord({}), true) + * assert.strictEqual(isReadonlyRecord({ a: 1 }), true) + * + * assert.strictEqual(isReadonlyRecord([]), false) + * assert.strictEqual(isReadonlyRecord(null), false) + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isReadonlyRecord: (input: unknown) => input is { + readonly [x: string | symbol]: unknown; +}; +/** + * A refinement that checks if a value is a `Promise`. It performs a duck-typing check + * for `.then` and `.catch` methods. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isPromise } from "effect/Predicate" + * + * assert.strictEqual(isPromise(Promise.resolve(1)), true) + * assert.strictEqual(isPromise(new Promise(() => {})), true) + * + * assert.strictEqual(isPromise({ then() {} }), false) // Missing .catch + * assert.strictEqual(isPromise({}), false) + * ``` + * + * @category guards + * @since 2.0.0 + * @see isPromiseLike + */ +export declare const isPromise: (input: unknown) => input is Promise; +/** + * A refinement that checks if a value is `PromiseLike`. It performs a duck-typing + * check for a `.then` method. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isPromiseLike } from "effect/Predicate" + * + * assert.strictEqual(isPromiseLike(Promise.resolve(1)), true) + * assert.strictEqual(isPromiseLike({ then: () => {} }), true) + * + * assert.strictEqual(isPromiseLike({}), false) + * ``` + * + * @category guards + * @since 2.0.0 + * @see isPromise + */ +export declare const isPromiseLike: (input: unknown) => input is PromiseLike; +/** + * A refinement that checks if a value is a `RegExp`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * assert.strictEqual(Predicate.isRegExp(/a/), true) + * assert.strictEqual(Predicate.isRegExp(new RegExp("a")), true) + * + * assert.strictEqual(Predicate.isRegExp("/a/"), false) + * ``` + * + * @category guards + * @since 3.9.0 + */ +export declare const isRegExp: (input: unknown) => input is RegExp; +/** + * Composes a `Refinement` with another `Refinement` or `Predicate`. + * + * This can be used to chain checks. The first refinement is applied, and if it + * passes, the second check is applied to the same value, potentially refining + * the type further. + * + * @example + * ```ts + * import { Predicate } from "effect" + * import * as assert from "node:assert" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const minLength = (n: number) => (s: string): boolean => s.length >= n + * + * // Create a refinement that checks for a string with a minimum length of 3 + * const isLongString = Predicate.compose(isString, minLength(3)) + * + * let value: unknown = "hello" + * + * assert.strictEqual(isLongString(value), true) + * if (isLongString(value)) { + * // value is narrowed to string + * assert.strictEqual(value.toUpperCase(), "HELLO") + * } + * assert.strictEqual(isLongString("hi"), false) + * ``` + * + * @since 2.0.0 + */ +export declare const compose: { + /** + * Composes a `Refinement` with another `Refinement` or `Predicate`. + * + * This can be used to chain checks. The first refinement is applied, and if it + * passes, the second check is applied to the same value, potentially refining + * the type further. + * + * @example + * ```ts + * import { Predicate } from "effect" + * import * as assert from "node:assert" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const minLength = (n: number) => (s: string): boolean => s.length >= n + * + * // Create a refinement that checks for a string with a minimum length of 3 + * const isLongString = Predicate.compose(isString, minLength(3)) + * + * let value: unknown = "hello" + * + * assert.strictEqual(isLongString(value), true) + * if (isLongString(value)) { + * // value is narrowed to string + * assert.strictEqual(value.toUpperCase(), "HELLO") + * } + * assert.strictEqual(isLongString("hi"), false) + * ``` + * + * @since 2.0.0 + */ + (bc: Refinement): (ab: Refinement) => Refinement; + /** + * Composes a `Refinement` with another `Refinement` or `Predicate`. + * + * This can be used to chain checks. The first refinement is applied, and if it + * passes, the second check is applied to the same value, potentially refining + * the type further. + * + * @example + * ```ts + * import { Predicate } from "effect" + * import * as assert from "node:assert" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const minLength = (n: number) => (s: string): boolean => s.length >= n + * + * // Create a refinement that checks for a string with a minimum length of 3 + * const isLongString = Predicate.compose(isString, minLength(3)) + * + * let value: unknown = "hello" + * + * assert.strictEqual(isLongString(value), true) + * if (isLongString(value)) { + * // value is narrowed to string + * assert.strictEqual(value.toUpperCase(), "HELLO") + * } + * assert.strictEqual(isLongString("hi"), false) + * ``` + * + * @since 2.0.0 + */ + (bc: Predicate>): (ab: Refinement) => Refinement; + /** + * Composes a `Refinement` with another `Refinement` or `Predicate`. + * + * This can be used to chain checks. The first refinement is applied, and if it + * passes, the second check is applied to the same value, potentially refining + * the type further. + * + * @example + * ```ts + * import { Predicate } from "effect" + * import * as assert from "node:assert" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const minLength = (n: number) => (s: string): boolean => s.length >= n + * + * // Create a refinement that checks for a string with a minimum length of 3 + * const isLongString = Predicate.compose(isString, minLength(3)) + * + * let value: unknown = "hello" + * + * assert.strictEqual(isLongString(value), true) + * if (isLongString(value)) { + * // value is narrowed to string + * assert.strictEqual(value.toUpperCase(), "HELLO") + * } + * assert.strictEqual(isLongString("hi"), false) + * ``` + * + * @since 2.0.0 + */ + (ab: Refinement, bc: Refinement): Refinement; + /** + * Composes a `Refinement` with another `Refinement` or `Predicate`. + * + * This can be used to chain checks. The first refinement is applied, and if it + * passes, the second check is applied to the same value, potentially refining + * the type further. + * + * @example + * ```ts + * import { Predicate } from "effect" + * import * as assert from "node:assert" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const minLength = (n: number) => (s: string): boolean => s.length >= n + * + * // Create a refinement that checks for a string with a minimum length of 3 + * const isLongString = Predicate.compose(isString, minLength(3)) + * + * let value: unknown = "hello" + * + * assert.strictEqual(isLongString(value), true) + * if (isLongString(value)) { + * // value is narrowed to string + * assert.strictEqual(value.toUpperCase(), "HELLO") + * } + * assert.strictEqual(isLongString("hi"), false) + * ``` + * + * @since 2.0.0 + */ + (ab: Refinement, bc: Predicate>): Refinement; +}; +/** + * Combines two predicates to test a tuple of two values. The first predicate tests the + * first element of the tuple, and the second predicate tests the second element. + * + * @category combining + * @since 2.0.0 + */ +export declare const product: (self: Predicate, that: Predicate) => Predicate; +/** + * Takes an iterable of predicates and returns a new predicate that tests an array of values. + * The new predicate returns `true` if each predicate at a given index is satisfied by the + * value at the same index in the array. The check stops at the length of the shorter of + * the two iterables (predicates or values). + * + * @category combining + * @since 2.0.0 + * @see tuple for a more powerful, variadic version. + */ +export declare const all: (collection: Iterable>) => Predicate>; +/** + * Combines a predicate for a single value and an iterable of predicates for the rest of an array. + * Useful for checking the head and tail of an array separately. + * + * @category combining + * @since 2.0.0 + */ +export declare const productMany: (self: Predicate, collection: Iterable>) => Predicate]>; +/** + * Combines an array of predicates into a single predicate that tests an array of values. + * This function is highly type-aware and will produce a `Refinement` if any of the provided + * predicates are `Refinement`s, allowing for powerful type-narrowing of tuples. + * + * - If all predicates are `Predicate`, the result is `Predicate<[T, T, ...]>`. + * - If any predicate is a `Refinement`, the result is a `Refinement` that narrows + * the input tuple type to a more specific tuple type. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * // Create a refinement for a [string, number] tuple + * const isStringNumberTuple = Predicate.tuple(isString, isNumber) + * + * const value: [unknown, unknown] = ["hello", 123] + * if (isStringNumberTuple(value)) { + * // value is narrowed to [string, number] + * const [s, n] = value + * assert.strictEqual(s.toUpperCase(), "HELLO") + * assert.strictEqual(n.toFixed(2), "123.00") + * } + * assert.strictEqual(isStringNumberTuple(["hello", "123"]), false) + * ``` + * + * @since 2.0.0 + */ +export declare const tuple: { + /** + * Combines an array of predicates into a single predicate that tests an array of values. + * This function is highly type-aware and will produce a `Refinement` if any of the provided + * predicates are `Refinement`s, allowing for powerful type-narrowing of tuples. + * + * - If all predicates are `Predicate`, the result is `Predicate<[T, T, ...]>`. + * - If any predicate is a `Refinement`, the result is a `Refinement` that narrows + * the input tuple type to a more specific tuple type. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * // Create a refinement for a [string, number] tuple + * const isStringNumberTuple = Predicate.tuple(isString, isNumber) + * + * const value: [unknown, unknown] = ["hello", 123] + * if (isStringNumberTuple(value)) { + * // value is narrowed to [string, number] + * const [s, n] = value + * assert.strictEqual(s.toUpperCase(), "HELLO") + * assert.strictEqual(n.toFixed(2), "123.00") + * } + * assert.strictEqual(isStringNumberTuple(["hello", "123"]), false) + * ``` + * + * @since 2.0.0 + */ + >(...elements: T): [Extract] extends [never] ? Predicate<{ + readonly [I in keyof T]: Predicate.In; + }> : Refinement<{ + readonly [I in keyof T]: T[I] extends Refinement.Any ? Refinement.In : Predicate.In; + }, { + readonly [I in keyof T]: T[I] extends Refinement.Any ? Refinement.Out : Predicate.In; + }>; +}; +/** + * Combines a record of predicates into a single predicate that tests a record of values. + * This function is highly type-aware and will produce a `Refinement` if any of the provided + * predicates are `Refinement`s, allowing for powerful type-narrowing of structs. + * + * - If all predicates are `Predicate`, the result is `Predicate<{ k: T, ... }>`. + * - If any predicate is a `Refinement`, the result is a `Refinement` that narrows + * the input record type to a more specific record type. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * const personPredicate = Predicate.struct({ + * name: isString, + * age: isNumber + * }) + * + * const value: { name: unknown; age: unknown } = { name: "Alice", age: 30 } + * if (personPredicate(value)) { + * // value is narrowed to { name: string; age: number } + * assert.strictEqual(value.name.toUpperCase(), "ALICE") + * assert.strictEqual(value.age.toFixed(0), "30") + * } + * assert.strictEqual(personPredicate({ name: "Bob", age: "40" }), false) + * ``` + * + * @since 2.0.0 + */ +export declare const struct: { + /** + * Combines a record of predicates into a single predicate that tests a record of values. + * This function is highly type-aware and will produce a `Refinement` if any of the provided + * predicates are `Refinement`s, allowing for powerful type-narrowing of structs. + * + * - If all predicates are `Predicate`, the result is `Predicate<{ k: T, ... }>`. + * - If any predicate is a `Refinement`, the result is a `Refinement` that narrows + * the input record type to a more specific record type. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * const personPredicate = Predicate.struct({ + * name: isString, + * age: isNumber + * }) + * + * const value: { name: unknown; age: unknown } = { name: "Alice", age: 30 } + * if (personPredicate(value)) { + * // value is narrowed to { name: string; age: number } + * assert.strictEqual(value.name.toUpperCase(), "ALICE") + * assert.strictEqual(value.age.toFixed(0), "30") + * } + * assert.strictEqual(personPredicate({ name: "Bob", age: "40" }), false) + * ``` + * + * @since 2.0.0 + */ + >(fields: R): [Extract] extends [never] ? Predicate<{ + readonly [K in keyof R]: Predicate.In; + }> : Refinement<{ + readonly [K in keyof R]: R[K] extends Refinement.Any ? Refinement.In : Predicate.In; + }, { + readonly [K in keyof R]: R[K] extends Refinement.Any ? Refinement.Out : Predicate.In; + }>; +}; +/** + * Returns a new predicate that is the logical negation of the given predicate. + * + * **Note**: If the input is a `Refinement`, the resulting predicate will be a + * simple `Predicate`, as TypeScript cannot infer the negative type. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate, Number } from "effect" + * + * const isNonPositive = Predicate.not(Number.greaterThan(0)) + * + * assert.strictEqual(isNonPositive(-1), true) + * assert.strictEqual(isNonPositive(0), true) + * assert.strictEqual(isNonPositive(1), false) + * ``` + * + * @category combinators + * @since 2.0.0 + */ +export declare const not: (self: Predicate) => Predicate; +/** + * Combines two predicates with a logical "OR". The resulting predicate returns `true` + * if at least one of the predicates returns `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * union of their target types (`B | C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * const isStringOrNumber = Predicate.or(isString, isNumber) + * + * assert.strictEqual(isStringOrNumber("hello"), true) + * assert.strictEqual(isStringOrNumber(123), true) + * assert.strictEqual(isStringOrNumber(null), false) + * + * const value: unknown = "world" + * if (isStringOrNumber(value)) { + * // value is narrowed to string | number + * console.log(value) + * } + * ``` + * + * @category combinators + * @since 2.0.0 + */ +export declare const or: { + /** + * Combines two predicates with a logical "OR". The resulting predicate returns `true` + * if at least one of the predicates returns `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * union of their target types (`B | C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * const isStringOrNumber = Predicate.or(isString, isNumber) + * + * assert.strictEqual(isStringOrNumber("hello"), true) + * assert.strictEqual(isStringOrNumber(123), true) + * assert.strictEqual(isStringOrNumber(null), false) + * + * const value: unknown = "world" + * if (isStringOrNumber(value)) { + * // value is narrowed to string | number + * console.log(value) + * } + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (that: Refinement): (self: Refinement) => Refinement; + /** + * Combines two predicates with a logical "OR". The resulting predicate returns `true` + * if at least one of the predicates returns `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * union of their target types (`B | C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * const isStringOrNumber = Predicate.or(isString, isNumber) + * + * assert.strictEqual(isStringOrNumber("hello"), true) + * assert.strictEqual(isStringOrNumber(123), true) + * assert.strictEqual(isStringOrNumber(null), false) + * + * const value: unknown = "world" + * if (isStringOrNumber(value)) { + * // value is narrowed to string | number + * console.log(value) + * } + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (self: Refinement, that: Refinement): Refinement; + /** + * Combines two predicates with a logical "OR". The resulting predicate returns `true` + * if at least one of the predicates returns `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * union of their target types (`B | C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * const isStringOrNumber = Predicate.or(isString, isNumber) + * + * assert.strictEqual(isStringOrNumber("hello"), true) + * assert.strictEqual(isStringOrNumber(123), true) + * assert.strictEqual(isStringOrNumber(null), false) + * + * const value: unknown = "world" + * if (isStringOrNumber(value)) { + * // value is narrowed to string | number + * console.log(value) + * } + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (that: Predicate): (self: Predicate) => Predicate; + /** + * Combines two predicates with a logical "OR". The resulting predicate returns `true` + * if at least one of the predicates returns `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * union of their target types (`B | C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isString = (u: unknown): u is string => typeof u === "string" + * const isNumber = (u: unknown): u is number => typeof u === "number" + * + * const isStringOrNumber = Predicate.or(isString, isNumber) + * + * assert.strictEqual(isStringOrNumber("hello"), true) + * assert.strictEqual(isStringOrNumber(123), true) + * assert.strictEqual(isStringOrNumber(null), false) + * + * const value: unknown = "world" + * if (isStringOrNumber(value)) { + * // value is narrowed to string | number + * console.log(value) + * } + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (self: Predicate, that: Predicate): Predicate; +}; +/** + * Combines two predicates with a logical "AND". The resulting predicate returns `true` + * only if both of the predicates return `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * intersection of their target types (`B & C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type Person = { name: string } + * type Employee = { id: number } + * + * const hasName = (u: unknown): u is Person => Predicate.hasProperty(u, "name") && typeof (u as any).name === "string" + * const hasId = (u: unknown): u is Employee => Predicate.hasProperty(u, "id") && typeof (u as any).id === "number" + * + * const isPersonAndEmployee = Predicate.and(hasName, hasId) + * + * const val: unknown = { name: "Alice", id: 123 } + * if (isPersonAndEmployee(val)) { + * // val is narrowed to Person & Employee + * assert.strictEqual(val.name, "Alice") + * assert.strictEqual(val.id, 123) + * } + * + * assert.strictEqual(isPersonAndEmployee({ name: "Bob" }), false) // Missing id + * assert.strictEqual(isPersonAndEmployee({ id: 456 }), false) // Missing name + * ``` + * + * @category combinators + * @since 2.0.0 + */ +export declare const and: { + /** + * Combines two predicates with a logical "AND". The resulting predicate returns `true` + * only if both of the predicates return `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * intersection of their target types (`B & C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type Person = { name: string } + * type Employee = { id: number } + * + * const hasName = (u: unknown): u is Person => Predicate.hasProperty(u, "name") && typeof (u as any).name === "string" + * const hasId = (u: unknown): u is Employee => Predicate.hasProperty(u, "id") && typeof (u as any).id === "number" + * + * const isPersonAndEmployee = Predicate.and(hasName, hasId) + * + * const val: unknown = { name: "Alice", id: 123 } + * if (isPersonAndEmployee(val)) { + * // val is narrowed to Person & Employee + * assert.strictEqual(val.name, "Alice") + * assert.strictEqual(val.id, 123) + * } + * + * assert.strictEqual(isPersonAndEmployee({ name: "Bob" }), false) // Missing id + * assert.strictEqual(isPersonAndEmployee({ id: 456 }), false) // Missing name + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (that: Refinement): (self: Refinement) => Refinement; + /** + * Combines two predicates with a logical "AND". The resulting predicate returns `true` + * only if both of the predicates return `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * intersection of their target types (`B & C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type Person = { name: string } + * type Employee = { id: number } + * + * const hasName = (u: unknown): u is Person => Predicate.hasProperty(u, "name") && typeof (u as any).name === "string" + * const hasId = (u: unknown): u is Employee => Predicate.hasProperty(u, "id") && typeof (u as any).id === "number" + * + * const isPersonAndEmployee = Predicate.and(hasName, hasId) + * + * const val: unknown = { name: "Alice", id: 123 } + * if (isPersonAndEmployee(val)) { + * // val is narrowed to Person & Employee + * assert.strictEqual(val.name, "Alice") + * assert.strictEqual(val.id, 123) + * } + * + * assert.strictEqual(isPersonAndEmployee({ name: "Bob" }), false) // Missing id + * assert.strictEqual(isPersonAndEmployee({ id: 456 }), false) // Missing name + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (self: Refinement, that: Refinement): Refinement; + /** + * Combines two predicates with a logical "AND". The resulting predicate returns `true` + * only if both of the predicates return `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * intersection of their target types (`B & C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type Person = { name: string } + * type Employee = { id: number } + * + * const hasName = (u: unknown): u is Person => Predicate.hasProperty(u, "name") && typeof (u as any).name === "string" + * const hasId = (u: unknown): u is Employee => Predicate.hasProperty(u, "id") && typeof (u as any).id === "number" + * + * const isPersonAndEmployee = Predicate.and(hasName, hasId) + * + * const val: unknown = { name: "Alice", id: 123 } + * if (isPersonAndEmployee(val)) { + * // val is narrowed to Person & Employee + * assert.strictEqual(val.name, "Alice") + * assert.strictEqual(val.id, 123) + * } + * + * assert.strictEqual(isPersonAndEmployee({ name: "Bob" }), false) // Missing id + * assert.strictEqual(isPersonAndEmployee({ id: 456 }), false) // Missing name + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (that: Predicate): (self: Predicate) => Predicate; + /** + * Combines two predicates with a logical "AND". The resulting predicate returns `true` + * only if both of the predicates return `true`. + * + * If both predicates are `Refinement`s, the resulting predicate is a `Refinement` to the + * intersection of their target types (`B & C`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type Person = { name: string } + * type Employee = { id: number } + * + * const hasName = (u: unknown): u is Person => Predicate.hasProperty(u, "name") && typeof (u as any).name === "string" + * const hasId = (u: unknown): u is Employee => Predicate.hasProperty(u, "id") && typeof (u as any).id === "number" + * + * const isPersonAndEmployee = Predicate.and(hasName, hasId) + * + * const val: unknown = { name: "Alice", id: 123 } + * if (isPersonAndEmployee(val)) { + * // val is narrowed to Person & Employee + * assert.strictEqual(val.name, "Alice") + * assert.strictEqual(val.id, 123) + * } + * + * assert.strictEqual(isPersonAndEmployee({ name: "Bob" }), false) // Missing id + * assert.strictEqual(isPersonAndEmployee({ id: 456 }), false) // Missing name + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (self: Predicate, that: Predicate): Predicate; +}; +/** + * Combines two predicates with a logical "XOR" (exclusive OR). The resulting predicate + * returns `true` if one of the predicates returns `true`, but not both. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isPositive = (n: number) => n > 0 + * const isEven = (n: number) => n % 2 === 0 + * + * const isPositiveXorEven = Predicate.xor(isPositive, isEven) + * + * assert.strictEqual(isPositiveXorEven(4), false) // both true -> false + * assert.strictEqual(isPositiveXorEven(3), true) // one true -> true + * assert.strictEqual(isPositiveXorEven(-2), true) // one true -> true + * assert.strictEqual(isPositiveXorEven(-1), false) // both false -> false + * ``` + * + * @category combinators + * @since 2.0.0 + */ +export declare const xor: { + /** + * Combines two predicates with a logical "XOR" (exclusive OR). The resulting predicate + * returns `true` if one of the predicates returns `true`, but not both. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isPositive = (n: number) => n > 0 + * const isEven = (n: number) => n % 2 === 0 + * + * const isPositiveXorEven = Predicate.xor(isPositive, isEven) + * + * assert.strictEqual(isPositiveXorEven(4), false) // both true -> false + * assert.strictEqual(isPositiveXorEven(3), true) // one true -> true + * assert.strictEqual(isPositiveXorEven(-2), true) // one true -> true + * assert.strictEqual(isPositiveXorEven(-1), false) // both false -> false + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (that: Predicate): (self: Predicate) => Predicate; + /** + * Combines two predicates with a logical "XOR" (exclusive OR). The resulting predicate + * returns `true` if one of the predicates returns `true`, but not both. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isPositive = (n: number) => n > 0 + * const isEven = (n: number) => n % 2 === 0 + * + * const isPositiveXorEven = Predicate.xor(isPositive, isEven) + * + * assert.strictEqual(isPositiveXorEven(4), false) // both true -> false + * assert.strictEqual(isPositiveXorEven(3), true) // one true -> true + * assert.strictEqual(isPositiveXorEven(-2), true) // one true -> true + * assert.strictEqual(isPositiveXorEven(-1), false) // both false -> false + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (self: Predicate, that: Predicate): Predicate; +}; +/** + * Combines two predicates with a logical "EQV" (equivalence). The resulting predicate + * returns `true` if both predicates return the same boolean value (both `true` or both `false`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isPositive = (n: number) => n > 0 + * const isEven = (n: number) => n % 2 === 0 + * + * const isPositiveEqvEven = Predicate.eqv(isPositive, isEven) + * + * assert.strictEqual(isPositiveEqvEven(4), true) // both true -> true + * assert.strictEqual(isPositiveEqvEven(3), false) // different -> false + * assert.strictEqual(isPositiveEqvEven(-2), false) // different -> false + * assert.strictEqual(isPositiveEqvEven(-1), true) // both false -> true + * ``` + * + * @category combinators + * @since 2.0.0 + */ +export declare const eqv: { + /** + * Combines two predicates with a logical "EQV" (equivalence). The resulting predicate + * returns `true` if both predicates return the same boolean value (both `true` or both `false`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isPositive = (n: number) => n > 0 + * const isEven = (n: number) => n % 2 === 0 + * + * const isPositiveEqvEven = Predicate.eqv(isPositive, isEven) + * + * assert.strictEqual(isPositiveEqvEven(4), true) // both true -> true + * assert.strictEqual(isPositiveEqvEven(3), false) // different -> false + * assert.strictEqual(isPositiveEqvEven(-2), false) // different -> false + * assert.strictEqual(isPositiveEqvEven(-1), true) // both false -> true + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (that: Predicate): (self: Predicate) => Predicate; + /** + * Combines two predicates with a logical "EQV" (equivalence). The resulting predicate + * returns `true` if both predicates return the same boolean value (both `true` or both `false`). + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isPositive = (n: number) => n > 0 + * const isEven = (n: number) => n % 2 === 0 + * + * const isPositiveEqvEven = Predicate.eqv(isPositive, isEven) + * + * assert.strictEqual(isPositiveEqvEven(4), true) // both true -> true + * assert.strictEqual(isPositiveEqvEven(3), false) // different -> false + * assert.strictEqual(isPositiveEqvEven(-2), false) // different -> false + * assert.strictEqual(isPositiveEqvEven(-1), true) // both false -> true + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (self: Predicate, that: Predicate): Predicate; +}; +/** + * Creates a predicate that represents a logical "if-then" rule. + * + * Think of it as a conditional promise: **"If `antecedent` holds true, then I promise `consequent` will also be true."** + * + * This function is invaluable for defining complex validation logic where one condition dictates another. + * + * ### How It Works + * + * The rule only fails (returns `false`) when the "if" part is `true`, but the "then" part is `false`. + * In all other cases, the promise is considered kept, and the result is `true`. + * + * This includes the concept of **"vacuous truth"**: if the "if" part is `false`, the rule doesn't apply, + * so the promise isn't broken, and the result is `true`. (e.g., "If it rains, I'll bring an umbrella." + * If it doesn't rain, you haven't broken your promise, no matter what). + * + * ### Key Details + * + * - **Logical Equivalence**: `implies(p, q)` is the same as `not(p).or(q)`, or simply `!p || q` + * in plain JavaScript. This can be a helpful way to reason about its behavior. + * + * - **Type-Safety Warning**: This function always returns a `Predicate`, never a type-narrowing + * `Refinement`. A `true` result doesn't guarantee the `consequent` passed (it could be `true` + * simply because the `antecedent` was `false`), so it cannot be used to safely narrow a type. + * + * @example + * ```ts + * // Rule: A user can only be an admin if they also belong to the "staff" group. + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type User = { + * isStaff: boolean + * isAdmin: boolean + * } + * + * const isValidUserPermission = Predicate.implies( + * // antecedent: "if" the user is an admin... + * (user: User) => user.isAdmin, + * // consequent: "then" they must be staff. + * (user: User) => user.isStaff + * ) + * + * // A non-admin who is not staff. Rule doesn't apply (antecedent is false). + * assert.strictEqual(isValidUserPermission({ isStaff: false, isAdmin: false }), true) + * + * // A staff member who is not an admin. Rule doesn't apply (antecedent is false). + * assert.strictEqual(isValidUserPermission({ isStaff: true, isAdmin: false }), true) + * + * // An admin who is also staff. The rule was followed. + * assert.strictEqual(isValidUserPermission({ isStaff: true, isAdmin: true }), true) + * + * // An admin who is NOT staff. The rule was broken! + * assert.strictEqual(isValidUserPermission({ isStaff: false, isAdmin: true }), false) + * ``` + * + * @category combinators + * @since 2.0.0 + */ +export declare const implies: { + /** + * Creates a predicate that represents a logical "if-then" rule. + * + * Think of it as a conditional promise: **"If `antecedent` holds true, then I promise `consequent` will also be true."** + * + * This function is invaluable for defining complex validation logic where one condition dictates another. + * + * ### How It Works + * + * The rule only fails (returns `false`) when the "if" part is `true`, but the "then" part is `false`. + * In all other cases, the promise is considered kept, and the result is `true`. + * + * This includes the concept of **"vacuous truth"**: if the "if" part is `false`, the rule doesn't apply, + * so the promise isn't broken, and the result is `true`. (e.g., "If it rains, I'll bring an umbrella." + * If it doesn't rain, you haven't broken your promise, no matter what). + * + * ### Key Details + * + * - **Logical Equivalence**: `implies(p, q)` is the same as `not(p).or(q)`, or simply `!p || q` + * in plain JavaScript. This can be a helpful way to reason about its behavior. + * + * - **Type-Safety Warning**: This function always returns a `Predicate`, never a type-narrowing + * `Refinement`. A `true` result doesn't guarantee the `consequent` passed (it could be `true` + * simply because the `antecedent` was `false`), so it cannot be used to safely narrow a type. + * + * @example + * ```ts + * // Rule: A user can only be an admin if they also belong to the "staff" group. + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type User = { + * isStaff: boolean + * isAdmin: boolean + * } + * + * const isValidUserPermission = Predicate.implies( + * // antecedent: "if" the user is an admin... + * (user: User) => user.isAdmin, + * // consequent: "then" they must be staff. + * (user: User) => user.isStaff + * ) + * + * // A non-admin who is not staff. Rule doesn't apply (antecedent is false). + * assert.strictEqual(isValidUserPermission({ isStaff: false, isAdmin: false }), true) + * + * // A staff member who is not an admin. Rule doesn't apply (antecedent is false). + * assert.strictEqual(isValidUserPermission({ isStaff: true, isAdmin: false }), true) + * + * // An admin who is also staff. The rule was followed. + * assert.strictEqual(isValidUserPermission({ isStaff: true, isAdmin: true }), true) + * + * // An admin who is NOT staff. The rule was broken! + * assert.strictEqual(isValidUserPermission({ isStaff: false, isAdmin: true }), false) + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (consequent: Predicate): (antecedent: Predicate) => Predicate; + /** + * Creates a predicate that represents a logical "if-then" rule. + * + * Think of it as a conditional promise: **"If `antecedent` holds true, then I promise `consequent` will also be true."** + * + * This function is invaluable for defining complex validation logic where one condition dictates another. + * + * ### How It Works + * + * The rule only fails (returns `false`) when the "if" part is `true`, but the "then" part is `false`. + * In all other cases, the promise is considered kept, and the result is `true`. + * + * This includes the concept of **"vacuous truth"**: if the "if" part is `false`, the rule doesn't apply, + * so the promise isn't broken, and the result is `true`. (e.g., "If it rains, I'll bring an umbrella." + * If it doesn't rain, you haven't broken your promise, no matter what). + * + * ### Key Details + * + * - **Logical Equivalence**: `implies(p, q)` is the same as `not(p).or(q)`, or simply `!p || q` + * in plain JavaScript. This can be a helpful way to reason about its behavior. + * + * - **Type-Safety Warning**: This function always returns a `Predicate`, never a type-narrowing + * `Refinement`. A `true` result doesn't guarantee the `consequent` passed (it could be `true` + * simply because the `antecedent` was `false`), so it cannot be used to safely narrow a type. + * + * @example + * ```ts + * // Rule: A user can only be an admin if they also belong to the "staff" group. + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * type User = { + * isStaff: boolean + * isAdmin: boolean + * } + * + * const isValidUserPermission = Predicate.implies( + * // antecedent: "if" the user is an admin... + * (user: User) => user.isAdmin, + * // consequent: "then" they must be staff. + * (user: User) => user.isStaff + * ) + * + * // A non-admin who is not staff. Rule doesn't apply (antecedent is false). + * assert.strictEqual(isValidUserPermission({ isStaff: false, isAdmin: false }), true) + * + * // A staff member who is not an admin. Rule doesn't apply (antecedent is false). + * assert.strictEqual(isValidUserPermission({ isStaff: true, isAdmin: false }), true) + * + * // An admin who is also staff. The rule was followed. + * assert.strictEqual(isValidUserPermission({ isStaff: true, isAdmin: true }), true) + * + * // An admin who is NOT staff. The rule was broken! + * assert.strictEqual(isValidUserPermission({ isStaff: false, isAdmin: true }), false) + * ``` + * + * @category combinators + * @since 2.0.0 + */ + (antecedent: Predicate, consequent: Predicate): Predicate; +}; +/** + * Combines two predicates with a logical "NOR" (negated OR). The resulting predicate + * returns `true` only if both predicates return `false`. + * This is equivalent to `not(or(p, q))`. + * + * @category combinators + * @since 2.0.0 + */ +export declare const nor: { + /** + * Combines two predicates with a logical "NOR" (negated OR). The resulting predicate + * returns `true` only if both predicates return `false`. + * This is equivalent to `not(or(p, q))`. + * + * @category combinators + * @since 2.0.0 + */ + (that: Predicate): (self: Predicate) => Predicate; + /** + * Combines two predicates with a logical "NOR" (negated OR). The resulting predicate + * returns `true` only if both predicates return `false`. + * This is equivalent to `not(or(p, q))`. + * + * @category combinators + * @since 2.0.0 + */ + (self: Predicate, that: Predicate): Predicate; +}; +/** + * Combines two predicates with a logical "NAND" (negated AND). The resulting predicate + * returns `true` if at least one of the predicates returns `false`. + * This is equivalent to `not(and(p, q))`. + * + * @category combinators + * @since 2.0.0 + */ +export declare const nand: { + /** + * Combines two predicates with a logical "NAND" (negated AND). The resulting predicate + * returns `true` if at least one of the predicates returns `false`. + * This is equivalent to `not(and(p, q))`. + * + * @category combinators + * @since 2.0.0 + */ + (that: Predicate): (self: Predicate) => Predicate; + /** + * Combines two predicates with a logical "NAND" (negated AND). The resulting predicate + * returns `true` if at least one of the predicates returns `false`. + * This is equivalent to `not(and(p, q))`. + * + * @category combinators + * @since 2.0.0 + */ + (self: Predicate, that: Predicate): Predicate; +}; +/** + * Takes an iterable of predicates and returns a new predicate. The new predicate + * returns `true` if all predicates in the collection return `true` for a given value. + * + * This is like `Array.prototype.every` but for a collection of predicates. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isPositive = (n: number) => n > 0 + * const isEven = (n: number) => n % 2 === 0 + * + * const isPositiveAndEven = Predicate.every([isPositive, isEven]) + * + * assert.strictEqual(isPositiveAndEven(4), true) + * assert.strictEqual(isPositiveAndEven(3), false) + * assert.strictEqual(isPositiveAndEven(-2), false) + * ``` + * + * @category elements + * @since 2.0.0 + * @see some + */ +export declare const every: (collection: Iterable>) => Predicate; +/** + * Takes an iterable of predicates and returns a new predicate. The new predicate + * returns `true` if at least one predicate in the collection returns `true` for a given value. + * + * This is like `Array.prototype.some` but for a collection of predicates. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Predicate } from "effect" + * + * const isNegative = (n: number) => n < 0 + * const isOdd = (n: number) => n % 2 !== 0 + * + * const isNegativeOrOdd = Predicate.some([isNegative, isOdd]) + * + * assert.strictEqual(isNegativeOrOdd(-2), true) // isNegative is true + * assert.strictEqual(isNegativeOrOdd(3), true) // isOdd is true + * assert.strictEqual(isNegativeOrOdd(4), false) // both are false + * ``` + * + * @category elements + * @since 2.0.0 + * @see every + */ +export declare const some: (collection: Iterable>) => Predicate; +//# sourceMappingURL=Predicate.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Predicate.d.ts.map b/backend/node_modules/effect/dist/dts/Predicate.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..eb5ed68881b47384aa8a688353f4774afba03a00 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Predicate.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Predicate.d.ts","sourceRoot":"","sources":["../../src/Predicate.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Pretty.d.ts b/backend/node_modules/effect/dist/dts/Pretty.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..174a34a9d41d8f8bdeaa0d522c11106f3a99c6d8 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Pretty.d.ts @@ -0,0 +1,26 @@ +import type * as Schema from "./Schema.js"; +import * as AST from "./SchemaAST.js"; +/** + * @category model + * @since 3.10.0 + */ +export interface Pretty { + (a: To): string; +} +/** + * @category annotations + * @since 3.10.0 + */ +export type PrettyAnnotation = readonly []> = (...pretties: { + readonly [K in keyof TypeParameters]: Pretty; +}) => Pretty; +/** + * @category prettify + * @since 3.10.0 + */ +export declare const make: (schema: Schema.Schema) => (a: A) => string; +/** + * @since 3.10.0 + */ +export declare const match: AST.Match>; +//# sourceMappingURL=Pretty.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Pretty.d.ts.map b/backend/node_modules/effect/dist/dts/Pretty.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..a12b8dc20adbf983adaf4f53ce96d8ca65ec9ba6 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Pretty.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Pretty.d.ts","sourceRoot":"","sources":["../../src/Pretty.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAA;AAErC;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,EAAE;IACxB,CAAC,CAAC,EAAE,EAAE,GAAG,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,cAAc,SAAS,aAAa,CAAC,GAAG,CAAC,GAAG,SAAS,EAAE,IAAI,CACzF,GAAG,QAAQ,EAAE;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CAAE,KAC7E,MAAM,CAAC,CAAC,CAAC,CAAA;AAEd;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,CAAC,CAAC,EAAE,CAAC,KAAK,MAAiC,CAAA;AAgB1G;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAuJxC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/PrimaryKey.d.ts b/backend/node_modules/effect/dist/dts/PrimaryKey.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a6bbcfa49e65482870145e8d0872e52c1b389fa4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/PrimaryKey.d.ts @@ -0,0 +1,21 @@ +/** + * @since 2.0.0 + */ +/** + * @since 2.0.0 + * @category symbols + */ +export declare const symbol: unique symbol; +/** + * @since 2.0.0 + * @category models + */ +export interface PrimaryKey { + [symbol](): string; +} +/** + * @since 2.0.0 + * @category accessors + */ +export declare const value: (self: PrimaryKey) => string; +//# sourceMappingURL=PrimaryKey.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/PrimaryKey.d.ts.map b/backend/node_modules/effect/dist/dts/PrimaryKey.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..6168187e7febe1aacdcf05dcf37b4be3fa902ad5 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/PrimaryKey.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"PrimaryKey.d.ts","sourceRoot":"","sources":["../../src/PrimaryKey.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,MAAwC,CAAA;AAEpE;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,CAAC,MAAM,CAAC,IAAI,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,UAAU,KAAG,MAAwB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/PubSub.d.ts b/backend/node_modules/effect/dist/dts/PubSub.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..47f862ee7a4eb124ba813000744e5e220f45298e --- /dev/null +++ b/backend/node_modules/effect/dist/dts/PubSub.d.ts @@ -0,0 +1,197 @@ +/** + * @since 2.0.0 + */ +import type * as Effect from "./Effect.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Queue from "./Queue.js"; +import type * as Scope from "./Scope.js"; +/** + * A `PubSub` is an asynchronous message hub into which publishers can publish + * messages of type `A` and subscribers can subscribe to take messages of type + * `A`. + * + * @since 2.0.0 + * @category models + */ +export interface PubSub extends Queue.Enqueue, Pipeable { + /** + * Publishes a message to the `PubSub`, returning whether the message was published + * to the `PubSub`. + */ + publish(value: A): Effect.Effect; + /** + * Publishes all of the specified messages to the `PubSub`, returning whether they + * were published to the `PubSub`. + */ + publishAll(elements: Iterable): Effect.Effect; + /** + * Subscribes to receive messages from the `PubSub`. The resulting subscription can + * be evaluated multiple times within the scope to take a message from the `PubSub` + * each time. + */ + readonly subscribe: Effect.Effect, never, Scope.Scope>; +} +/** + * Creates a bounded `PubSub` with the back pressure strategy. The `PubSub` will retain + * messages until they have been taken by all subscribers, applying back + * pressure to publishers if the `PubSub` is at capacity. + * + * For best performance use capacities that are powers of two. + * + * @since 2.0.0 + * @category constructors + */ +export declare const bounded: (capacity: number | { + readonly capacity: number; + readonly replay?: number | undefined; +}) => Effect.Effect>; +/** + * Creates a bounded `PubSub` with the dropping strategy. The `PubSub` will drop new + * messages if the `PubSub` is at capacity. + * + * For best performance use capacities that are powers of two. + * + * @since 2.0.0 + * @category constructors + */ +export declare const dropping: (capacity: number | { + readonly capacity: number; + readonly replay?: number | undefined; +}) => Effect.Effect>; +/** + * Creates a bounded `PubSub` with the sliding strategy. The `PubSub` will add new + * messages and drop old messages if the `PubSub` is at capacity. + * + * For best performance use capacities that are powers of two. + * + * @since 2.0.0 + * @category constructors + */ +export declare const sliding: (capacity: number | { + readonly capacity: number; + readonly replay?: number | undefined; +}) => Effect.Effect>; +/** + * Creates an unbounded `PubSub`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const unbounded: (options?: { + readonly replay?: number | undefined; +}) => Effect.Effect>; +/** + * Returns the number of elements the queue can hold. + * + * @since 2.0.0 + * @category getters + */ +export declare const capacity: (self: PubSub) => number; +/** + * Retrieves the size of the queue, which is equal to the number of elements + * in the queue. This may be negative if fibers are suspended waiting for + * elements to be added to the queue. + * + * @since 2.0.0 + * @category getters + */ +export declare const size: (self: PubSub) => Effect.Effect; +/** + * Returns `true` if the `Queue` contains at least one element, `false` + * otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const isFull: (self: PubSub) => Effect.Effect; +/** + * Returns `true` if the `Queue` contains zero elements, `false` otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const isEmpty: (self: PubSub) => Effect.Effect; +/** + * Interrupts any fibers that are suspended on `offer` or `take`. Future calls + * to `offer*` and `take*` will be interrupted immediately. + * + * @since 2.0.0 + * @category utils + */ +export declare const shutdown: (self: PubSub) => Effect.Effect; +/** + * Returns `true` if `shutdown` has been called, otherwise returns `false`. + * + * @since 2.0.0 + * @category getters + */ +export declare const isShutdown: (self: PubSub) => Effect.Effect; +/** + * Waits until the queue is shutdown. The `Effect` returned by this method will + * not resume until the queue has been shutdown. If the queue is already + * shutdown, the `Effect` will resume right away. + * + * @since 2.0.0 + * @category utils + */ +export declare const awaitShutdown: (self: PubSub) => Effect.Effect; +/** + * Publishes a message to the `PubSub`, returning whether the message was published + * to the `PubSub`. + * + * @since 2.0.0 + * @category utils + */ +export declare const publish: { + /** + * Publishes a message to the `PubSub`, returning whether the message was published + * to the `PubSub`. + * + * @since 2.0.0 + * @category utils + */ + (value: A): (self: PubSub) => Effect.Effect; + /** + * Publishes a message to the `PubSub`, returning whether the message was published + * to the `PubSub`. + * + * @since 2.0.0 + * @category utils + */ + (self: PubSub, value: A): Effect.Effect; +}; +/** + * Publishes all of the specified messages to the `PubSub`, returning whether they + * were published to the `PubSub`. + * + * @since 2.0.0 + * @category utils + */ +export declare const publishAll: { + /** + * Publishes all of the specified messages to the `PubSub`, returning whether they + * were published to the `PubSub`. + * + * @since 2.0.0 + * @category utils + */ + (elements: Iterable): (self: PubSub) => Effect.Effect; + /** + * Publishes all of the specified messages to the `PubSub`, returning whether they + * were published to the `PubSub`. + * + * @since 2.0.0 + * @category utils + */ + (self: PubSub, elements: Iterable): Effect.Effect; +}; +/** + * Subscribes to receive messages from the `PubSub`. The resulting subscription can + * be evaluated multiple times within the scope to take a message from the `PubSub` + * each time. + * + * @since 2.0.0 + * @category utils + */ +export declare const subscribe: (self: PubSub) => Effect.Effect, never, Scope.Scope>; +//# sourceMappingURL=PubSub.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Queue.d.ts b/backend/node_modules/effect/dist/dts/Queue.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..83e54da1972ba21930a2d64bfb317930ceeadeaf --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Queue.d.ts @@ -0,0 +1,664 @@ +/** + * @since 2.0.0 + */ +import type * as Chunk from "./Chunk.js"; +import type * as Deferred from "./Deferred.js"; +import type * as Effect from "./Effect.js"; +import type * as MutableQueue from "./MutableQueue.js"; +import type * as MutableRef from "./MutableRef.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const EnqueueTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type EnqueueTypeId = typeof EnqueueTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const DequeueTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type DequeueTypeId = typeof DequeueTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const QueueStrategyTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type QueueStrategyTypeId = typeof QueueStrategyTypeId; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const BackingQueueTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type BackingQueueTypeId = typeof BackingQueueTypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface Queue extends Enqueue, Dequeue { + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: QueueUnify; + readonly [Unify.ignoreSymbol]?: QueueUnifyIgnore; +} +/** + * @category models + * @since 3.8.0 + */ +export interface QueueUnify extends DequeueUnify { + Queue?: () => Extract>; +} +/** + * @category models + * @since 3.8.0 + */ +export interface QueueUnifyIgnore extends DequeueUnifyIgnore { + Dequeue?: true; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Enqueue extends Queue.EnqueueVariance, BaseQueue, Pipeable { + /** + * Places one value in the queue. + */ + offer(value: A): Effect.Effect; + /** + * Places one value in the queue when possible without needing the fiber runtime. + */ + unsafeOffer(value: A): boolean; + /** + * For Bounded Queue: uses the `BackPressure` Strategy, places the values in + * the queue and always returns true. If the queue has reached capacity, then + * the fiber performing the `offerAll` will be suspended until there is room + * in the queue. + * + * For Unbounded Queue: Places all values in the queue and returns true. + * + * For Sliding Queue: uses `Sliding` Strategy If there is room in the queue, + * it places the values otherwise it removes the old elements and enqueues the + * new ones. Always returns true. + * + * For Dropping Queue: uses `Dropping` Strategy, It places the values in the + * queue but if there is no room it will not enqueue them and return false. + */ + offerAll(iterable: Iterable): Effect.Effect; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Dequeue extends Effect.Effect, Queue.DequeueVariance, BaseQueue { + /** + * Takes the oldest value in the queue. If the queue is empty, this will return + * a computation that resumes when an item has been added to the queue. + */ + readonly take: Effect.Effect; + /** + * Takes all the values in the queue and returns the values. If the queue is + * empty returns an empty collection. + */ + readonly takeAll: Effect.Effect>; + /** + * Takes up to max number of values from the queue. + */ + takeUpTo(max: number): Effect.Effect>; + /** + * Takes a number of elements from the queue between the specified minimum and + * maximum. If there are fewer than the minimum number of elements available, + * suspends until at least the minimum number of elements have been collected. + */ + takeBetween(min: number, max: number): Effect.Effect>; + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: DequeueUnify; + readonly [Unify.ignoreSymbol]?: DequeueUnifyIgnore; +} +/** + * @category models + * @since 3.8.0 + */ +export interface DequeueUnify extends Effect.EffectUnify { + Dequeue?: () => A[Unify.typeSymbol] extends Dequeue | infer _ ? Dequeue : never; +} +/** + * @category models + * @since 3.8.0 + */ +export interface DequeueUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * The base interface that all `Queue`s must implement. + * + * @since 2.0.0 + * @category models + */ +export interface BaseQueue { + /** + * Returns the number of elements the queue can hold. + */ + capacity(): number; + /** + * Returns false if shutdown has been called. + */ + isActive(): boolean; + /** + * Retrieves the size of the queue, which is equal to the number of elements + * in the queue. This may be negative if fibers are suspended waiting for + * elements to be added to the queue. + */ + readonly size: Effect.Effect; + /** + * Retrieves the size of the queue, which is equal to the number of elements + * in the queue. This may be negative if fibers are suspended waiting for + * elements to be added to the queue. Returns None if shutdown has been called + */ + unsafeSize(): Option.Option; + /** + * Returns `true` if the `Queue` contains at least one element, `false` + * otherwise. + */ + readonly isFull: Effect.Effect; + /** + * Returns `true` if the `Queue` contains zero elements, `false` otherwise. + */ + readonly isEmpty: Effect.Effect; + /** + * Interrupts any fibers that are suspended on `offer` or `take`. Future calls + * to `offer*` and `take*` will be interrupted immediately. + */ + readonly shutdown: Effect.Effect; + /** + * Returns `true` if `shutdown` has been called, otherwise returns `false`. + */ + readonly isShutdown: Effect.Effect; + /** + * Waits until the queue is shutdown. The `Effect` returned by this method will + * not resume until the queue has been shutdown. If the queue is already + * shutdown, the `Effect` will resume right away. + */ + readonly awaitShutdown: Effect.Effect; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Strategy extends Queue.StrategyVariance { + /** + * Returns the number of surplus values that were unable to be added to the + * `Queue` + */ + surplusSize(): number; + /** + * Determines how the `Queue.Strategy` should shut down when the `Queue` is + * shut down. + */ + readonly shutdown: Effect.Effect; + /** + * Determines the behavior of the `Queue.Strategy` when there are surplus + * values that could not be added to the `Queue` following an `offer` + * operation. + */ + handleSurplus(iterable: Iterable, queue: BackingQueue, takers: MutableQueue.MutableQueue>, isShutdown: MutableRef.MutableRef): Effect.Effect; + /** + * It is called when the backing queue is empty but there are some + * takers that can be completed + */ + onCompleteTakersWithEmptyQueue(takers: MutableQueue.MutableQueue>): void; + /** + * Determines the behavior of the `Queue.Strategy` when the `Queue` has empty + * slots following a `take` operation. + */ + unsafeOnQueueEmptySpace(queue: BackingQueue, takers: MutableQueue.MutableQueue>): void; +} +/** + * @since 2.0.0 + * @category models + */ +export interface BackingQueue extends Queue.BackingQueueVariance { + /** + * Dequeues an element from the queue. + * Returns either an element from the queue, or the `def` param. + */ + poll(def: Def): A | Def; + /** + * Dequeues up to `limit` elements from the queue. + */ + pollUpTo(limit: number): Chunk.Chunk; + /** + * Enqueues a collection of values into the queue. + * + * Returns a `Chunk` of the values that were **not** able to be enqueued. + */ + offerAll(elements: Iterable): Chunk.Chunk; + /** + * Offers an element to the queue. + * + * Returns whether the enqueue was successful or not. + */ + offer(element: A): boolean; + /** + * The **maximum** number of elements that a queue can hold. + * + * **Note**: unbounded queues can still implement this interface with + * `capacity = Infinity`. + */ + capacity(): number; + /** + * Returns the number of elements currently in the queue + */ + length(): number; +} +/** + * @since 2.0.0 + */ +export declare namespace Queue { + /** + * @since 2.0.0 + * @category models + */ + interface EnqueueVariance { + readonly [EnqueueTypeId]: { + readonly _In: Types.Contravariant; + }; + } + /** + * @since 2.0.0 + * @category models + */ + interface DequeueVariance { + readonly [DequeueTypeId]: { + readonly _Out: Types.Covariant; + }; + } + /** + * @since 2.0.0 + * @category models + */ + interface StrategyVariance { + readonly [QueueStrategyTypeId]: { + readonly _A: Types.Invariant; + }; + } + /** + * @since 2.0.0 + * @category models + */ + interface BackingQueueVariance { + readonly [BackingQueueTypeId]: { + readonly _A: Types.Invariant; + }; + } +} +/** + * Returns `true` if the specified value is a `Queue`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isQueue: (u: unknown) => u is Queue; +/** + * Returns `true` if the specified value is a `Dequeue`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isDequeue: (u: unknown) => u is Dequeue; +/** + * Returns `true` if the specified value is a `Enqueue`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isEnqueue: (u: unknown) => u is Enqueue; +/** + * @since 2.0.0 + * @category strategies + */ +export declare const backPressureStrategy: () => Strategy; +/** + * @since 2.0.0 + * @category strategies + */ +export declare const droppingStrategy: () => Strategy; +/** + * @since 2.0.0 + * @category strategies + */ +export declare const slidingStrategy: () => Strategy; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (queue: BackingQueue, strategy: Strategy) => Effect.Effect>; +/** + * Makes a new bounded `Queue`. When the capacity of the queue is reached, any + * additional calls to `offer` will be suspended until there is more room in + * the queue. + * + * **Note**: When possible use only power of 2 capacities; this will provide + * better performance by utilising an optimised version of the underlying + * `RingBuffer`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const bounded: (requestedCapacity: number) => Effect.Effect>; +/** + * Makes a new bounded `Queue` with the dropping strategy. + * + * When the capacity of the queue is reached, new elements will be dropped and the + * old elements will remain. + * + * **Note**: When possible use only power of 2 capacities; this will provide + * better performance by utilising an optimised version of the underlying + * `RingBuffer`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const dropping: (requestedCapacity: number) => Effect.Effect>; +/** + * Makes a new bounded `Queue` with the sliding strategy. + * + * When the capacity of the queue is reached, new elements will be added and the + * old elements will be dropped. + * + * **Note**: When possible use only power of 2 capacities; this will provide + * better performance by utilising an optimised version of the underlying + * `RingBuffer`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const sliding: (requestedCapacity: number) => Effect.Effect>; +/** + * Creates a new unbounded `Queue`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const unbounded: () => Effect.Effect>; +/** + * Returns the number of elements the queue can hold. + * + * @since 2.0.0 + * @category getters + */ +export declare const capacity: (self: Dequeue | Enqueue) => number; +/** + * Retrieves the size of the queue, which is equal to the number of elements + * in the queue. This may be negative if fibers are suspended waiting for + * elements to be added to the queue. + * + * @since 2.0.0 + * @category getters + */ +export declare const size: (self: Dequeue | Enqueue) => Effect.Effect; +/** + * Returns `true` if the `Queue` contains zero elements, `false` otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const isEmpty: (self: Dequeue | Enqueue) => Effect.Effect; +/** + * Returns `true` if the `Queue` contains at least one element, `false` + * otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const isFull: (self: Dequeue | Enqueue) => Effect.Effect; +/** + * Returns `true` if `shutdown` has been called, otherwise returns `false`. + * + * @since 2.0.0 + * @category getters + */ +export declare const isShutdown: (self: Dequeue | Enqueue) => Effect.Effect; +/** + * Waits until the queue is shutdown. The `Effect` returned by this method will + * not resume until the queue has been shutdown. If the queue is already + * shutdown, the `Effect` will resume right away. + * + * @since 2.0.0 + * @category utils + */ +export declare const awaitShutdown: (self: Dequeue | Enqueue) => Effect.Effect; +/** + * Interrupts any fibers that are suspended on `offer` or `take`. Future calls + * to `offer*` and `take*` will be interrupted immediately. + * + * @since 2.0.0 + * @category utils + */ +export declare const shutdown: (self: Dequeue | Enqueue) => Effect.Effect; +/** + * Places one value in the queue. + * + * @since 2.0.0 + * @category utils + */ +export declare const offer: { + /** + * Places one value in the queue. + * + * @since 2.0.0 + * @category utils + */ + (value: A): (self: Enqueue) => Effect.Effect; + /** + * Places one value in the queue. + * + * @since 2.0.0 + * @category utils + */ + (self: Enqueue, value: A): Effect.Effect; +}; +/** + * Places one value in the queue. + * + * @since 2.0.0 + * @category utils + */ +export declare const unsafeOffer: { + /** + * Places one value in the queue. + * + * @since 2.0.0 + * @category utils + */ + (value: A): (self: Enqueue) => boolean; + /** + * Places one value in the queue. + * + * @since 2.0.0 + * @category utils + */ + (self: Enqueue, value: A): boolean; +}; +/** + * For Bounded Queue: uses the `BackPressure` Strategy, places the values in + * the queue and always returns true. If the queue has reached capacity, then + * the fiber performing the `offerAll` will be suspended until there is room + * in the queue. + * + * For Unbounded Queue: Places all values in the queue and returns true. + * + * For Sliding Queue: uses `Sliding` Strategy If there is room in the queue, + * it places the values otherwise it removes the old elements and enqueues the + * new ones. Always returns true. + * + * For Dropping Queue: uses `Dropping` Strategy, It places the values in the + * queue but if there is no room it will not enqueue them and return false. + * + * @since 2.0.0 + * @category utils + */ +export declare const offerAll: { + /** + * For Bounded Queue: uses the `BackPressure` Strategy, places the values in + * the queue and always returns true. If the queue has reached capacity, then + * the fiber performing the `offerAll` will be suspended until there is room + * in the queue. + * + * For Unbounded Queue: Places all values in the queue and returns true. + * + * For Sliding Queue: uses `Sliding` Strategy If there is room in the queue, + * it places the values otherwise it removes the old elements and enqueues the + * new ones. Always returns true. + * + * For Dropping Queue: uses `Dropping` Strategy, It places the values in the + * queue but if there is no room it will not enqueue them and return false. + * + * @since 2.0.0 + * @category utils + */ + (iterable: Iterable): (self: Enqueue) => Effect.Effect; + /** + * For Bounded Queue: uses the `BackPressure` Strategy, places the values in + * the queue and always returns true. If the queue has reached capacity, then + * the fiber performing the `offerAll` will be suspended until there is room + * in the queue. + * + * For Unbounded Queue: Places all values in the queue and returns true. + * + * For Sliding Queue: uses `Sliding` Strategy If there is room in the queue, + * it places the values otherwise it removes the old elements and enqueues the + * new ones. Always returns true. + * + * For Dropping Queue: uses `Dropping` Strategy, It places the values in the + * queue but if there is no room it will not enqueue them and return false. + * + * @since 2.0.0 + * @category utils + */ + (self: Enqueue, iterable: Iterable): Effect.Effect; +}; +/** + * Returns the first value in the `Queue` as a `Some`, or `None` if the queue + * is empty. + * + * @since 2.0.0 + * @category utils + */ +export declare const poll: (self: Dequeue) => Effect.Effect>; +/** + * Takes the oldest value in the queue. If the queue is empty, this will return + * a computation that resumes when an item has been added to the queue. + * + * @since 2.0.0 + * @category utils + */ +export declare const take: (self: Dequeue) => Effect.Effect; +/** + * Takes all the values in the queue and returns the values. If the queue is + * empty returns an empty collection. + * + * @since 2.0.0 + * @category utils + */ +export declare const takeAll: (self: Dequeue) => Effect.Effect>; +/** + * Takes up to max number of values from the queue. + * + * @since 2.0.0 + * @category utils + */ +export declare const takeUpTo: { + /** + * Takes up to max number of values from the queue. + * + * @since 2.0.0 + * @category utils + */ + (max: number): (self: Dequeue) => Effect.Effect>; + /** + * Takes up to max number of values from the queue. + * + * @since 2.0.0 + * @category utils + */ + (self: Dequeue, max: number): Effect.Effect>; +}; +/** + * Takes a number of elements from the queue between the specified minimum and + * maximum. If there are fewer than the minimum number of elements available, + * suspends until at least the minimum number of elements have been collected. + * + * @since 2.0.0 + * @category utils + */ +export declare const takeBetween: { + /** + * Takes a number of elements from the queue between the specified minimum and + * maximum. If there are fewer than the minimum number of elements available, + * suspends until at least the minimum number of elements have been collected. + * + * @since 2.0.0 + * @category utils + */ + (min: number, max: number): (self: Dequeue) => Effect.Effect>; + /** + * Takes a number of elements from the queue between the specified minimum and + * maximum. If there are fewer than the minimum number of elements available, + * suspends until at least the minimum number of elements have been collected. + * + * @since 2.0.0 + * @category utils + */ + (self: Dequeue, min: number, max: number): Effect.Effect>; +}; +/** + * Takes the specified number of elements from the queue. If there are fewer + * than the specified number of elements available, it suspends until they + * become available. + * + * @since 2.0.0 + * @category utils + */ +export declare const takeN: { + /** + * Takes the specified number of elements from the queue. If there are fewer + * than the specified number of elements available, it suspends until they + * become available. + * + * @since 2.0.0 + * @category utils + */ + (n: number): (self: Dequeue) => Effect.Effect>; + /** + * Takes the specified number of elements from the queue. If there are fewer + * than the specified number of elements available, it suspends until they + * become available. + * + * @since 2.0.0 + * @category utils + */ + (self: Dequeue, n: number): Effect.Effect>; +}; +//# sourceMappingURL=Queue.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Queue.d.ts.map b/backend/node_modules/effect/dist/dts/Queue.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..377b96d11afc18c6c9f836e4c5c1d14994215553 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Queue.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Queue.d.ts","sourceRoot":"","sources":["../../src/Queue.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Random.d.ts b/backend/node_modules/effect/dist/dts/Random.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..abfb397a3debc60d4b1c421240279488fba53629 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Random.d.ts @@ -0,0 +1,183 @@ +/** + * @since 2.0.0 + */ +import type * as Array from "./Array.js"; +import type * as Cause from "./Cause.js"; +import type * as Chunk from "./Chunk.js"; +import type * as Context from "./Context.js"; +import type * as Effect from "./Effect.js"; +import type * as NonEmptyIterable from "./NonEmptyIterable.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const RandomTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type RandomTypeId = typeof RandomTypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface Random { + readonly [RandomTypeId]: RandomTypeId; + /** + * Returns the next numeric value from the pseudo-random number generator. + */ + readonly next: Effect.Effect; + /** + * Returns the next boolean value from the pseudo-random number generator. + */ + readonly nextBoolean: Effect.Effect; + /** + * Returns the next integer value from the pseudo-random number generator. + */ + readonly nextInt: Effect.Effect; + /** + * Returns the next numeric value in the specified range from the + * pseudo-random number generator. + */ + nextRange(min: number, max: number): Effect.Effect; + /** + * Returns the next integer value in the specified range from the + * pseudo-random number generator. + */ + nextIntBetween(min: number, max: number): Effect.Effect; + /** + * Uses the pseudo-random number generator to shuffle the specified iterable. + */ + shuffle(elements: Iterable): Effect.Effect>; +} +/** + * Returns the next numeric value from the pseudo-random number generator. + * + * @since 2.0.0 + * @category constructors + */ +export declare const next: Effect.Effect; +/** + * Returns the next integer value from the pseudo-random number generator. + * + * @since 2.0.0 + * @category constructors + */ +export declare const nextInt: Effect.Effect; +/** + * Returns the next boolean value from the pseudo-random number generator. + * + * @since 2.0.0 + * @category constructors + */ +export declare const nextBoolean: Effect.Effect; +/** + * Returns the next numeric value in the specified range from the + * pseudo-random number generator. + * + * @since 2.0.0 + * @category constructors + */ +export declare const nextRange: (min: number, max: number) => Effect.Effect; +/** + * Returns the next integer value in the specified range from the + * pseudo-random number generator. + * + * @since 2.0.0 + * @category constructors + */ +export declare const nextIntBetween: (min: number, max: number) => Effect.Effect; +/** + * Uses the pseudo-random number generator to shuffle the specified iterable. + * + * @since 2.0.0 + * @category constructors + */ +export declare const shuffle: (elements: Iterable) => Effect.Effect>; +/** + * Get a random element from an iterable. + * + * @example + * ```ts + * import { Effect, Random } from "effect" + * + * Effect.gen(function* () { + * const randomItem = yield* Random.choice([1, 2, 3]) + * console.log(randomItem) + * }) + * ``` + * + * @since 3.6.0 + * @category constructors + */ +export declare const choice: >(elements: Self) => Self extends NonEmptyIterable.NonEmptyIterable ? Effect.Effect : Self extends Array.NonEmptyReadonlyArray ? Effect.Effect : Self extends Iterable ? Effect.Effect : never; +/** + * Retreives the `Random` service from the context and uses it to run the + * specified workflow. + * + * @since 2.0.0 + * @category constructors + */ +export declare const randomWith: (f: (random: Random) => Effect.Effect) => Effect.Effect; +/** + * @since 2.0.0 + * @category context + */ +export declare const Random: Context.Tag; +/** + * Constructs the `Random` service, seeding the pseudo-random number generator + * with an hash of the specified seed. + * This constructor is useful for generating predictable sequences of random values for specific use cases. + * + * Example uses: + * - Generating random UI data for visual tests. + * - Creating data that needs to change daily but remain the same throughout a single day, such as using a date as the seed. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Effect, Random } from "effect" + * + * const random1 = Random.make("myseed") + * const random2 = Random.make("myseed") + * + * assert.equal(Effect.runSync(random1.next), Effect.runSync(random2.next)) + * ``` + * + * @since 3.5.0 + * @category constructors + */ +export declare const make: (seed: A) => Random; +/** + * Constructs the `Random` service from an array of literal values. + * The service will cycle through the provided values in order when generating random values. + * This constructor is useful for creating deterministic sequences for testing or when specific values need to be returned. + * + * @example + * ```ts + * import { Effect, Random } from "effect" + * + * Effect.gen(function* () { + * console.log(yield* Random.next) // 0.2 + * console.log(yield* Random.next) // 0.5 + * console.log(yield* Random.next) // 0.8 + * console.log(yield* Random.next) // 0.2 (cycles back) + * }).pipe(Effect.withRandom(Random.fixed([0.2, 0.5, 0.8]))) + * ``` + * + * @example + * ```ts + * import { Effect, Random } from "effect" + * + * Effect.gen(function* () { + * console.log(yield* Random.nextBoolean) // true + * console.log(yield* Random.nextBoolean) // false + * console.log(yield* Random.nextBoolean) // true + * }).pipe(Effect.withRandom(Random.fixed([true, false, true]))) + * ``` + * + * @since 3.11.0 + * @category constructors + */ +export declare const fixed: >(values: T) => Random; +//# sourceMappingURL=Random.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Random.d.ts.map b/backend/node_modules/effect/dist/dts/Random.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..63b150f1f6b8f31395a3ea18d531cc808bcb8acc --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Random.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Random.d.ts","sourceRoot":"","sources":["../../src/Random.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAG1C,OAAO,KAAK,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAE9D;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,OAAO,MAA8B,CAAA;AAEhE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAA;AAE9C;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,YAAY,CAAA;IACrC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACpC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IAC5C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACvC;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1D;;;OAGG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC/D;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;CACjE;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAwB,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAA2B,CAAA;AAErE;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAA+B,CAAA;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAA6B,CAAA;AAEvG;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAkC,CAAA;AAEjH;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAA2B,CAAA;AAE3G;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,IAAI,SAAS,QAAQ,CAAC,OAAO,CAAC,EAClD,QAAQ,EAAE,IAAI,KACX,IAAI,SAAS,gBAAgB,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAC3E,IAAI,SAAS,KAAK,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GACpE,IAAI,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,sBAAsB,CAAC,GAC/E,KAA8B,CAAA;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAC9E,CAAA;AAE5B;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAsB,CAAA;AAErE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,MAAsB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,SAAS,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,MAAuB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RateLimiter.d.ts b/backend/node_modules/effect/dist/dts/RateLimiter.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a912709406cbfa00e5a4ae373b43a44352d2a503 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RateLimiter.d.ts @@ -0,0 +1,134 @@ +/** + * Limits the number of calls to a resource to a maximum amount in some interval. + * + * @since 2.0.0 + */ +import type { DurationInput } from "./Duration.js"; +import type { Effect } from "./Effect.js"; +import type { Scope } from "./Scope.js"; +/** + * Limits the number of calls to a resource to a maximum amount in some interval. + * + * Note that only the moment of starting the effect is rate limited: the number + * of concurrent executions is not bounded. + * + * @since 2.0.0 + * @category models + */ +export interface RateLimiter { + (task: Effect): Effect; +} +/** + * @since 2.0.0 + */ +export declare namespace RateLimiter { + /** + * @since 2.0.0 + * @category models + */ + interface Options { + /** + * The maximum number of requests that should be allowed. + */ + readonly limit: number; + /** + * The interval to utilize for rate-limiting requests. The semantics of the + * specified `interval` vary depending on the chosen `algorithm`: + * + * `token-bucket`: The maximum number of requests will be spread out over + * the provided interval if no tokens are available. + * + * For example, for a `RateLimiter` using the `token-bucket` algorithm with + * a `limit` of `10` and an `interval` of `1 seconds`, `1` request can be + * made every `100 millis`. + * + * `fixed-window`: The maximum number of requests will be reset during each + * interval. For example, for a `RateLimiter` using the `fixed-window` + * algorithm with a `limit` of `10` and an `interval` of `1 seconds`, a + * maximum of `10` requests can be made each second. + */ + readonly interval: DurationInput; + /** + * The algorithm to utilize for rate-limiting requests. + * + * Defaults to `token-bucket`. + */ + readonly algorithm?: "fixed-window" | "token-bucket"; + } +} +/** + * Constructs a new `RateLimiter` which will utilize the specified algorithm + * to limit requests (defaults to `token-bucket`). + * + * Notes + * - Only the moment of starting the effect is rate limited. The number of concurrent executions is not bounded. + * - Instances of `RateLimiter` can be composed. + * - The "cost" per effect can be changed. See {@link withCost} + * + * @example + * ```ts + * import { Effect, RateLimiter } from "effect"; + * import { compose } from "effect/Function" + * + * const program = Effect.scoped( + * Effect.gen(function* ($) { + * const perMinuteRL = yield* $(RateLimiter.make({ limit: 30, interval: "1 minutes" })) + * const perSecondRL = yield* $(RateLimiter.make({ limit: 2, interval: "1 seconds" })) + * + * // This rate limiter respects both the 30 calls per minute + * // and the 2 calls per second constraints. + * const rateLimit = compose(perMinuteRL, perSecondRL) + * + * // simulate repeated calls + * for (let n = 0; n < 100; n++) { + * // wrap the effect we want to limit with rateLimit + * yield* $(rateLimit(Effect.log("Calling RateLimited Effect"))); + * } + * }) + * ); + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (options: RateLimiter.Options) => Effect; +/** + * Alters the per-effect cost of the rate-limiter. + * + * This can be used for "credit" based rate-limiting where different API endpoints + * cost a different number of credits within a time window. + * Eg: 1000 credits / hour, where a query costs 1 credit and a mutation costs 5 credits. + * + * @example + * ```ts + * import { Effect, RateLimiter } from "effect"; + * import { compose } from "effect/Function"; + * + * const program = Effect.scoped( + * Effect.gen(function* ($) { + * // Create a rate limiter that has an hourly limit of 1000 credits + * const rateLimiter = yield* $(RateLimiter.make({ limit: 1000, interval: "1 hours" })); + * // Query API costs 1 credit per call ( 1 is the default cost ) + * const queryAPIRL = compose(rateLimiter, RateLimiter.withCost(1)); + * // Mutation API costs 5 credits per call + * const mutationAPIRL = compose(rateLimiter, RateLimiter.withCost(5)); + + * // Use the pre-defined rate limiters + * yield* $(queryAPIRL(Effect.log("Sample Query"))); + * yield* $(mutationAPIRL(Effect.log("Sample Mutation"))); + * + * // Or set a cost on-the-fly + * yield* $( + * rateLimiter(Effect.log("Another query with a different cost")).pipe( + * RateLimiter.withCost(3) + * ) + * ); + * }) + * ); + * ``` + * + * @since 2.0.0 + * @category combinators + */ +export declare const withCost: (cost: number) => (effect: Effect) => Effect; +//# sourceMappingURL=RateLimiter.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RateLimiter.d.ts.map b/backend/node_modules/effect/dist/dts/RateLimiter.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..a12071bc77f01afa44cf52193cc78cb9c05c6129 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RateLimiter.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"RateLimiter.d.ts","sourceRoot":"","sources":["../../src/RateLimiter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAClD;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,WAAW,CAAC;IACnC;;;OAGG;IACH,UAAiB,OAAO;QACtB;;WAEG;QACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;QACtB;;;;;;;;;;;;;;;WAeG;QACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;QAChC;;;;WAIG;QACH,QAAQ,CAAC,SAAS,CAAC,EAAE,cAAc,GAAG,cAAc,CAAA;KACrD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,KAAK,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,CAAiB,CAAA;AAEtG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAqB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RcMap.d.ts b/backend/node_modules/effect/dist/dts/RcMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b5a1b6fc93e8880a130f28d7fceaf63db0b5f430 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RcMap.d.ts @@ -0,0 +1,234 @@ +/** + * @since 3.5.0 + */ +import type * as Cause from "./Cause.js"; +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import { type Pipeable } from "./Pipeable.js"; +import type * as Scope from "./Scope.js"; +import type * as Types from "./Types.js"; +/** + * @since 3.5.0 + * @category type ids + */ +export declare const TypeId: unique symbol; +/** + * @since 3.5.0 + * @category type ids + */ +export type TypeId = typeof TypeId; +/** + * @since 3.5.0 + * @category models + */ +export interface RcMap extends Pipeable { + readonly [TypeId]: RcMap.Variance; +} +/** + * @since 3.5.0 + * @category models + */ +export declare namespace RcMap { + /** + * @since 3.5.0 + * @category models + */ + interface Variance { + readonly _K: Types.Contravariant; + readonly _A: Types.Covariant; + readonly _E: Types.Covariant; + } +} +/** + * An `RcMap` can contain multiple reference counted resources that can be indexed + * by a key. The resources are lazily acquired on the first call to `get` and + * released when the last reference is released. + * + * Complex keys can extend `Equal` and `Hash` to allow lookups by value. + * + * **Options** + * + * - `capacity`: The maximum number of resources that can be held in the map. + * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration. + * Can be a static duration or a function that returns a duration based on the key. + * + * @since 3.5.0 + * @category models + * @example + * ```ts + * import { Effect, RcMap } from "effect" + * + * Effect.gen(function*() { + * const map = yield* RcMap.make({ + * lookup: (key: string) => + * Effect.acquireRelease( + * Effect.succeed(`acquired ${key}`), + * () => Effect.log(`releasing ${key}`) + * ) + * }) + * + * // Get "foo" from the map twice, which will only acquire it once. + * // It will then be released once the scope closes. + * yield* RcMap.get(map, "foo").pipe( + * Effect.andThen(RcMap.get(map, "foo")), + * Effect.scoped + * ) + * }) + * ``` + */ +export declare const make: { + /** + * An `RcMap` can contain multiple reference counted resources that can be indexed + * by a key. The resources are lazily acquired on the first call to `get` and + * released when the last reference is released. + * + * Complex keys can extend `Equal` and `Hash` to allow lookups by value. + * + * **Options** + * + * - `capacity`: The maximum number of resources that can be held in the map. + * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration. + * Can be a static duration or a function that returns a duration based on the key. + * + * @since 3.5.0 + * @category models + * @example + * ```ts + * import { Effect, RcMap } from "effect" + * + * Effect.gen(function*() { + * const map = yield* RcMap.make({ + * lookup: (key: string) => + * Effect.acquireRelease( + * Effect.succeed(`acquired ${key}`), + * () => Effect.log(`releasing ${key}`) + * ) + * }) + * + * // Get "foo" from the map twice, which will only acquire it once. + * // It will then be released once the scope closes. + * yield* RcMap.get(map, "foo").pipe( + * Effect.andThen(RcMap.get(map, "foo")), + * Effect.scoped + * ) + * }) + * ``` + */ + (options: { + readonly lookup: (key: K) => Effect.Effect; + readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined; + readonly capacity?: undefined; + }): Effect.Effect, never, Scope.Scope | R>; + /** + * An `RcMap` can contain multiple reference counted resources that can be indexed + * by a key. The resources are lazily acquired on the first call to `get` and + * released when the last reference is released. + * + * Complex keys can extend `Equal` and `Hash` to allow lookups by value. + * + * **Options** + * + * - `capacity`: The maximum number of resources that can be held in the map. + * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration. + * Can be a static duration or a function that returns a duration based on the key. + * + * @since 3.5.0 + * @category models + * @example + * ```ts + * import { Effect, RcMap } from "effect" + * + * Effect.gen(function*() { + * const map = yield* RcMap.make({ + * lookup: (key: string) => + * Effect.acquireRelease( + * Effect.succeed(`acquired ${key}`), + * () => Effect.log(`releasing ${key}`) + * ) + * }) + * + * // Get "foo" from the map twice, which will only acquire it once. + * // It will then be released once the scope closes. + * yield* RcMap.get(map, "foo").pipe( + * Effect.andThen(RcMap.get(map, "foo")), + * Effect.scoped + * ) + * }) + * ``` + */ + (options: { + readonly lookup: (key: K) => Effect.Effect; + readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined; + readonly capacity: number; + }): Effect.Effect, never, Scope.Scope | R>; +}; +/** + * @since 3.5.0 + * @category combinators + */ +export declare const get: { + /** + * @since 3.5.0 + * @category combinators + */ + (key: K): (self: RcMap) => Effect.Effect; + /** + * @since 3.5.0 + * @category combinators + */ + (self: RcMap, key: K): Effect.Effect; +}; +/** + * @since 3.17.7 + * @category combinators + */ +export declare const has: { + /** + * @since 3.17.7 + * @category combinators + */ + (key: K): (self: RcMap) => Effect.Effect; + /** + * @since 3.17.7 + * @category combinators + */ + (self: RcMap, key: K): Effect.Effect; +}; +/** + * @since 3.8.0 + * @category combinators + */ +export declare const keys: (self: RcMap) => Effect.Effect>; +/** + * @since 3.13.0 + * @category combinators + */ +export declare const invalidate: { + /** + * @since 3.13.0 + * @category combinators + */ + (key: K): (self: RcMap) => Effect.Effect; + /** + * @since 3.13.0 + * @category combinators + */ + (self: RcMap, key: K): Effect.Effect; +}; +/** + * @since 3.13.0 + * @category combinators + */ +export declare const touch: { + /** + * @since 3.13.0 + * @category combinators + */ + (key: K): (self: RcMap) => Effect.Effect; + /** + * @since 3.13.0 + * @category combinators + */ + (self: RcMap, key: K): Effect.Effect; +}; +//# sourceMappingURL=RcMap.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RcMap.d.ts.map b/backend/node_modules/effect/dist/dts/RcMap.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..13a07cdb053f56db06a568cf65e58717725cb078 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RcMap.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"RcMap.d.ts","sourceRoot":"","sources":["../../src/RcMap.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RcRef.d.ts b/backend/node_modules/effect/dist/dts/RcRef.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..70801674fe3feb6f5f4d4f866fae98290e5328ff --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RcRef.d.ts @@ -0,0 +1,111 @@ +/** + * @since 3.5.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import type * as Readable from "./Readable.js"; +import type * as Scope from "./Scope.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 3.5.0 + * @category type ids + */ +export declare const TypeId: unique symbol; +/** + * @since 3.5.0 + * @category type ids + */ +export type TypeId = typeof TypeId; +/** + * @since 3.5.0 + * @category models + */ +export interface RcRef extends Effect.Effect, Readable.Readable { + readonly [TypeId]: RcRef.Variance; + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: RcRefUnify; + readonly [Unify.ignoreSymbol]?: RcRefUnifyIgnore; +} +/** + * @category models + * @since 3.8.0 + */ +export interface RcRefUnify extends Effect.EffectUnify { + RcRef?: () => A[Unify.typeSymbol] extends RcRef | infer _ ? RcRef : never; +} +/** + * @category models + * @since 3.8.0 + */ +export interface RcRefUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * @since 3.5.0 + * @category models + */ +export declare namespace RcRef { + /** + * @since 3.5.0 + * @category models + */ + interface Variance { + readonly _A: Types.Covariant; + readonly _E: Types.Covariant; + } +} +/** + * Create an `RcRef` from an acquire `Effect`. + * + * An RcRef wraps a reference counted resource that can be acquired and released + * multiple times. + * + * The resource is lazily acquired on the first call to `get` and released when + * the last reference is released. + * + * @since 3.5.0 + * @category constructors + * @example + * ```ts + * import { Effect, RcRef } from "effect" + * + * Effect.gen(function*() { + * const ref = yield* RcRef.make({ + * acquire: Effect.acquireRelease( + * Effect.succeed("foo"), + * () => Effect.log("release foo") + * ) + * }) + * + * // will only acquire the resource once, and release it + * // when the scope is closed + * yield* RcRef.get(ref).pipe( + * Effect.andThen(RcRef.get(ref)), + * Effect.scoped + * ) + * }) + * ``` + */ +export declare const make: (options: { + readonly acquire: Effect.Effect; + /** + * When the reference count reaches zero, the resource will be released + * after this duration. + */ + readonly idleTimeToLive?: Duration.DurationInput | undefined; +}) => Effect.Effect, never, R | Scope.Scope>; +/** + * @since 3.5.0 + * @category combinators + */ +export declare const get: (self: RcRef) => Effect.Effect; +/** + * @since 3.19.6 + * @category combinators + * @experimental + */ +export declare const invalidate: (self: RcRef) => Effect.Effect; +//# sourceMappingURL=RcRef.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RcRef.d.ts.map b/backend/node_modules/effect/dist/dts/RcRef.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..249cb7b454a884ab038c3adef56d012e92a49e53 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RcRef.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"RcRef.d.ts","sourceRoot":"","sources":["../../src/RcRef.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Readable.d.ts b/backend/node_modules/effect/dist/dts/Readable.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a4f135fffcc7d3a8a131fe7f563a0aa57c84fd4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Readable.d.ts @@ -0,0 +1,72 @@ +/** + * @since 2.0.0 + */ +import type { Effect } from "./Effect.js"; +import { type Pipeable } from "./Pipeable.js"; +import type { NoInfer } from "./Types.js"; +/** + * @since 2.0.0 + * @category type ids + */ +export declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category type ids + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category models + */ +export interface Readable extends Pipeable { + readonly [TypeId]: TypeId; + readonly get: Effect; +} +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isReadable: (u: unknown) => u is Readable; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (get: Effect) => Readable; +/** + * @since 2.0.0 + * @category combinators + */ +export declare const map: { + /** + * @since 2.0.0 + * @category combinators + */ + (f: (a: NoInfer) => B): (fa: Readable) => Readable; + /** + * @since 2.0.0 + * @category combinators + */ + (self: Readable, f: (a: NoInfer) => B): Readable; +}; +/** + * @since 2.0.0 + * @category combinators + */ +export declare const mapEffect: { + /** + * @since 2.0.0 + * @category combinators + */ + (f: (a: NoInfer) => Effect): (fa: Readable) => Readable; + /** + * @since 2.0.0 + * @category combinators + */ + (self: Readable, f: (a: NoInfer) => Effect): Readable; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const unwrap: (effect: Effect, E1, R1>) => Readable; +//# sourceMappingURL=Readable.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Readable.d.ts.map b/backend/node_modules/effect/dist/dts/Readable.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..1a5c60e5390b097ed7e8d9a86b1771468749ceb1 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Readable.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Readable.d.ts","sourceRoot":"","sources":["../../src/Readable.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Record.d.ts b/backend/node_modules/effect/dist/dts/Record.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ebfa6e851de40fa63f4d07fe46ff1ec8b712a4ed --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Record.d.ts @@ -0,0 +1,1547 @@ +/** + * This module provides utility functions for working with records in TypeScript. + * + * @since 2.0.0 + */ +import type { Either } from "./Either.js"; +import type { Equivalence } from "./Equivalence.js"; +import type { TypeLambda } from "./HKT.js"; +import * as Option from "./Option.js"; +import type { NoInfer } from "./Types.js"; +/** + * @category models + * @since 2.0.0 + */ +export type ReadonlyRecord = { + readonly [P in K]: A; +}; +/** + * @since 2.0.0 + */ +export declare namespace ReadonlyRecord { + type IsFiniteString = T extends "" ? true : [ + T + ] extends [`${infer Head}${infer Rest}`] ? string extends Head ? false : `${number}` extends Head ? false : Rest extends "" ? true : IsFiniteString : false; + /** + * @since 2.0.0 + */ + type NonLiteralKey = K extends string ? IsFiniteString extends true ? string : K : symbol; + /** + * @since 2.0.0 + */ + type IntersectKeys = [string] extends [K1 | K2] ? NonLiteralKey & NonLiteralKey : K1 & K2; +} +/** + * @category type lambdas + * @since 2.0.0 + */ +export interface ReadonlyRecordTypeLambda extends TypeLambda { + readonly type: ReadonlyRecord; +} +/** + * Creates a new, empty record. + * + * @category constructors + * @since 2.0.0 + */ +export declare const empty: () => Record, V>; +/** + * Determine if a record is empty. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isEmptyRecord } from "effect/Record" + * + * assert.deepStrictEqual(isEmptyRecord({}), true); + * assert.deepStrictEqual(isEmptyRecord({ a: 3 }), false); + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isEmptyRecord: (self: Record) => self is Record; +/** + * Determine if a record is empty. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { isEmptyReadonlyRecord } from "effect/Record" + * + * assert.deepStrictEqual(isEmptyReadonlyRecord({}), true); + * assert.deepStrictEqual(isEmptyReadonlyRecord({ a: 3 }), false); + * ``` + * + * @category guards + * @since 2.0.0 + */ +export declare const isEmptyReadonlyRecord: (self: ReadonlyRecord) => self is ReadonlyRecord; +/** + * Takes an iterable and a projection function and returns a record. + * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { fromIterableWith } from "effect/Record" + * + * const input = [1, 2, 3, 4] + * + * assert.deepStrictEqual( + * fromIterableWith(input, a => [String(a), a * 2]), + * { '1': 2, '2': 4, '3': 6, '4': 8 } + * ) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const fromIterableWith: { + /** + * Takes an iterable and a projection function and returns a record. + * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { fromIterableWith } from "effect/Record" + * + * const input = [1, 2, 3, 4] + * + * assert.deepStrictEqual( + * fromIterableWith(input, a => [String(a), a * 2]), + * { '1': 2, '2': 4, '3': 6, '4': 8 } + * ) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (f: (a: A) => readonly [K, B]): (self: Iterable) => Record, B>; + /** + * Takes an iterable and a projection function and returns a record. + * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { fromIterableWith } from "effect/Record" + * + * const input = [1, 2, 3, 4] + * + * assert.deepStrictEqual( + * fromIterableWith(input, a => [String(a), a * 2]), + * { '1': 2, '2': 4, '3': 6, '4': 8 } + * ) + * ``` + * + * @category constructors + * @since 2.0.0 + */ + (self: Iterable, f: (a: A) => readonly [K, B]): Record, B>; +}; +/** + * Creates a new record from an iterable, utilizing the provided function to determine the key for each element. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { fromIterableBy } from "effect/Record" + * + * const users = [ + * { id: "2", name: "name2" }, + * { id: "1", name: "name1" } + * ] + * + * assert.deepStrictEqual( + * fromIterableBy(users, user => user.id), + * { + * "2": { id: "2", name: "name2" }, + * "1": { id: "1", name: "name1" } + * } + * ) + * ``` + * + * @category constructors + * @since 2.0.0 + */ +export declare const fromIterableBy: (items: Iterable, f: (a: A) => K) => Record, A>; +/** + * Builds a record from an iterable of key-value pairs. + * + * If there are conflicting keys when using `fromEntries`, the last occurrence of the key/value pair will overwrite the + * previous ones. So the resulting record will only have the value of the last occurrence of each key. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { fromEntries } from "effect/Record" + * + * const input: Array<[string, number]> = [["a", 1], ["b", 2]] + * + * assert.deepStrictEqual(fromEntries(input), { a: 1, b: 2 }) + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromEntries: (entries: Iterable) => Record, Entry[1]>; +/** + * Transforms the values of a record into an `Array` with a custom mapping function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { collect } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3 } + * assert.deepStrictEqual(collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]]) + * ``` + * + * @category conversions + * @since 2.0.0 + */ +export declare const collect: { + /** + * Transforms the values of a record into an `Array` with a custom mapping function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { collect } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3 } + * assert.deepStrictEqual(collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]]) + * ``` + * + * @category conversions + * @since 2.0.0 + */ + (f: (key: K, a: A) => B): (self: ReadonlyRecord) => Array; + /** + * Transforms the values of a record into an `Array` with a custom mapping function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { collect } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3 } + * assert.deepStrictEqual(collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]]) + * ``` + * + * @category conversions + * @since 2.0.0 + */ + (self: ReadonlyRecord, f: (key: K, a: A) => B): Array; +}; +/** + * Takes a record and returns an array of tuples containing its keys and values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { toEntries } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3 } + * assert.deepStrictEqual(toEntries(x), [["a", 1], ["b", 2], ["c", 3]]) + * ``` + * + * @category conversions + * @since 2.0.0 + */ +export declare const toEntries: (self: ReadonlyRecord) => Array<[K, A]>; +/** + * Returns the number of key/value pairs in a record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { size } from "effect/Record"; + * + * assert.deepStrictEqual(size({ a: "a", b: 1, c: true }), 3); + * ``` + * + * @since 2.0.0 + */ +export declare const size: (self: ReadonlyRecord) => number; +/** + * Check if a given `key` exists in a record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { empty, has } from "effect/Record" + * + * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true); + * assert.deepStrictEqual(has(empty(), "c"), false); + * ``` + * + * @since 2.0.0 + */ +export declare const has: { + /** + * Check if a given `key` exists in a record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { empty, has } from "effect/Record" + * + * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true); + * assert.deepStrictEqual(has(empty(), "c"), false); + * ``` + * + * @since 2.0.0 + */ + (key: NoInfer): (self: ReadonlyRecord) => boolean; + /** + * Check if a given `key` exists in a record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { empty, has } from "effect/Record" + * + * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true); + * assert.deepStrictEqual(has(empty(), "c"), false); + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: NoInfer): boolean; +}; +/** + * Retrieve a value at a particular key from a record, returning it wrapped in an `Option`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * const person: Record = { name: "John Doe", age: 35 } + * + * assert.deepStrictEqual(R.get(person, "name"), Option.some("John Doe")) + * assert.deepStrictEqual(R.get(person, "email"), Option.none()) + * ``` + * + * @since 2.0.0 + */ +export declare const get: { + /** + * Retrieve a value at a particular key from a record, returning it wrapped in an `Option`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * const person: Record = { name: "John Doe", age: 35 } + * + * assert.deepStrictEqual(R.get(person, "name"), Option.some("John Doe")) + * assert.deepStrictEqual(R.get(person, "email"), Option.none()) + * ``` + * + * @since 2.0.0 + */ + (key: NoInfer): (self: ReadonlyRecord) => Option.Option; + /** + * Retrieve a value at a particular key from a record, returning it wrapped in an `Option`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * const person: Record = { name: "John Doe", age: 35 } + * + * assert.deepStrictEqual(R.get(person, "name"), Option.some("John Doe")) + * assert.deepStrictEqual(R.get(person, "email"), Option.none()) + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: NoInfer): Option.Option; +}; +/** + * Apply a function to the element at the specified key, creating a new record. + * If the key does not exist, the record is returned unchanged. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R } from "effect" + * + * const f = (x: number) => x * 2 + * + * assert.deepStrictEqual( + * R.modify({ a: 3 }, 'a', f), + * { a: 6 } + * ) + * assert.deepStrictEqual( + * R.modify({ a: 3 } as Record, 'b', f), + * { a: 3 } + * ) + * ``` + * + * @since 2.0.0 + */ +export declare const modify: { + /** + * Apply a function to the element at the specified key, creating a new record. + * If the key does not exist, the record is returned unchanged. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R } from "effect" + * + * const f = (x: number) => x * 2 + * + * assert.deepStrictEqual( + * R.modify({ a: 3 }, 'a', f), + * { a: 6 } + * ) + * assert.deepStrictEqual( + * R.modify({ a: 3 } as Record, 'b', f), + * { a: 3 } + * ) + * ``` + * + * @since 2.0.0 + */ + (key: NoInfer, f: (a: A) => B): (self: ReadonlyRecord) => Record; + /** + * Apply a function to the element at the specified key, creating a new record. + * If the key does not exist, the record is returned unchanged. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R } from "effect" + * + * const f = (x: number) => x * 2 + * + * assert.deepStrictEqual( + * R.modify({ a: 3 }, 'a', f), + * { a: 6 } + * ) + * assert.deepStrictEqual( + * R.modify({ a: 3 } as Record, 'b', f), + * { a: 3 } + * ) + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: NoInfer, f: (a: A) => B): Record; +}; +/** + * Apply a function to the element at the specified key, creating a new record, + * or return `None` if the key doesn't exist. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * const f = (x: number) => x * 2 + * + * assert.deepStrictEqual( + * R.modifyOption({ a: 3 }, 'a', f), + * Option.some({ a: 6 }) + * ) + * assert.deepStrictEqual( + * R.modifyOption({ a: 3 } as Record, 'b', f), + * Option.none() + * ) + * ``` + * + * @since 2.0.0 + */ +export declare const modifyOption: { + /** + * Apply a function to the element at the specified key, creating a new record, + * or return `None` if the key doesn't exist. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * const f = (x: number) => x * 2 + * + * assert.deepStrictEqual( + * R.modifyOption({ a: 3 }, 'a', f), + * Option.some({ a: 6 }) + * ) + * assert.deepStrictEqual( + * R.modifyOption({ a: 3 } as Record, 'b', f), + * Option.none() + * ) + * ``` + * + * @since 2.0.0 + */ + (key: NoInfer, f: (a: A) => B): (self: ReadonlyRecord) => Option.Option>; + /** + * Apply a function to the element at the specified key, creating a new record, + * or return `None` if the key doesn't exist. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * const f = (x: number) => x * 2 + * + * assert.deepStrictEqual( + * R.modifyOption({ a: 3 }, 'a', f), + * Option.some({ a: 6 }) + * ) + * assert.deepStrictEqual( + * R.modifyOption({ a: 3 } as Record, 'b', f), + * Option.none() + * ) + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: NoInfer, f: (a: A) => B): Option.Option>; +}; +/** + * Replaces a value in the record with the new value passed as parameter. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Option } from "effect" + * + * assert.deepStrictEqual( + * Record.replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10), + * Option.some({ a: 10, b: 2, c: 3 }) + * ) + * assert.deepStrictEqual(Record.replaceOption(Record.empty(), 'a', 10), Option.none()) + * ``` + * + * @since 2.0.0 + */ +export declare const replaceOption: { + /** + * Replaces a value in the record with the new value passed as parameter. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Option } from "effect" + * + * assert.deepStrictEqual( + * Record.replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10), + * Option.some({ a: 10, b: 2, c: 3 }) + * ) + * assert.deepStrictEqual(Record.replaceOption(Record.empty(), 'a', 10), Option.none()) + * ``` + * + * @since 2.0.0 + */ + (key: NoInfer, b: B): (self: ReadonlyRecord) => Option.Option>; + /** + * Replaces a value in the record with the new value passed as parameter. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Option } from "effect" + * + * assert.deepStrictEqual( + * Record.replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10), + * Option.some({ a: 10, b: 2, c: 3 }) + * ) + * assert.deepStrictEqual(Record.replaceOption(Record.empty(), 'a', 10), Option.none()) + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: NoInfer, b: B): Option.Option>; +}; +/** + * If the given key exists in the record, returns a new record with the key removed, + * otherwise returns a copy of the original record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { remove } from "effect/Record" + * + * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 }) + * ``` + * + * @since 2.0.0 + */ +export declare const remove: { + /** + * If the given key exists in the record, returns a new record with the key removed, + * otherwise returns a copy of the original record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { remove } from "effect/Record" + * + * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 }) + * ``` + * + * @since 2.0.0 + */ + (key: X): (self: ReadonlyRecord) => Record, A>; + /** + * If the given key exists in the record, returns a new record with the key removed, + * otherwise returns a copy of the original record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { remove } from "effect/Record" + * + * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 }) + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: X): Record, A>; +}; +/** + * Retrieves the value of the property with the given `key` from a record and returns an `Option` + * of a tuple with the value and the record with the removed property. + * If the key is not present, returns `O.none`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * assert.deepStrictEqual(R.pop({ a: 1, b: 2 }, "a"), Option.some([1, { b: 2 }])) + * assert.deepStrictEqual(R.pop({ a: 1, b: 2 } as Record, "c"), Option.none()) + * ``` + * + * @category record + * @since 2.0.0 + */ +export declare const pop: { + /** + * Retrieves the value of the property with the given `key` from a record and returns an `Option` + * of a tuple with the value and the record with the removed property. + * If the key is not present, returns `O.none`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * assert.deepStrictEqual(R.pop({ a: 1, b: 2 }, "a"), Option.some([1, { b: 2 }])) + * assert.deepStrictEqual(R.pop({ a: 1, b: 2 } as Record, "c"), Option.none()) + * ``` + * + * @category record + * @since 2.0.0 + */ + (key: X): (self: ReadonlyRecord) => Option.Option<[A, Record, A>]>; + /** + * Retrieves the value of the property with the given `key` from a record and returns an `Option` + * of a tuple with the value and the record with the removed property. + * If the key is not present, returns `O.none`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record as R, Option } from "effect" + * + * assert.deepStrictEqual(R.pop({ a: 1, b: 2 }, "a"), Option.some([1, { b: 2 }])) + * assert.deepStrictEqual(R.pop({ a: 1, b: 2 } as Record, "c"), Option.none()) + * ``` + * + * @category record + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: X): Option.Option<[A, Record, A>]>; +}; +/** + * Maps a record into another record by applying a transformation function to each of its values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { map } from "effect/Record" + * + * const f = (n: number) => `-${n}` + * + * assert.deepStrictEqual(map({ a: 3, b: 5 }, f), { a: "-3", b: "-5" }) + * + * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}` + * + * assert.deepStrictEqual(map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ +export declare const map: { + /** + * Maps a record into another record by applying a transformation function to each of its values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { map } from "effect/Record" + * + * const f = (n: number) => `-${n}` + * + * assert.deepStrictEqual(map({ a: 3, b: 5 }, f), { a: "-3", b: "-5" }) + * + * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}` + * + * assert.deepStrictEqual(map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ + (f: (a: A, key: NoInfer) => B): (self: ReadonlyRecord) => Record; + /** + * Maps a record into another record by applying a transformation function to each of its values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { map } from "effect/Record" + * + * const f = (n: number) => `-${n}` + * + * assert.deepStrictEqual(map({ a: 3, b: 5 }, f), { a: "-3", b: "-5" }) + * + * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}` + * + * assert.deepStrictEqual(map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ + (self: ReadonlyRecord, f: (a: A, key: NoInfer) => B): Record; +}; +/** + * Maps the keys of a `ReadonlyRecord` while preserving the corresponding values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { mapKeys } from "effect/Record" + * + * assert.deepStrictEqual(mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()), { A: 3, B: 5 }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ +export declare const mapKeys: { + /** + * Maps the keys of a `ReadonlyRecord` while preserving the corresponding values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { mapKeys } from "effect/Record" + * + * assert.deepStrictEqual(mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()), { A: 3, B: 5 }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ + (f: (key: K, a: A) => K2): (self: ReadonlyRecord) => Record; + /** + * Maps the keys of a `ReadonlyRecord` while preserving the corresponding values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { mapKeys } from "effect/Record" + * + * assert.deepStrictEqual(mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()), { A: 3, B: 5 }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ + (self: ReadonlyRecord, f: (key: K, a: A) => K2): Record; +}; +/** + * Maps entries of a `ReadonlyRecord` using the provided function, allowing modification of both keys and corresponding values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { mapEntries } from "effect/Record" + * + * assert.deepStrictEqual(mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]), { A: 4, B: 6 }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ +export declare const mapEntries: { + /** + * Maps entries of a `ReadonlyRecord` using the provided function, allowing modification of both keys and corresponding values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { mapEntries } from "effect/Record" + * + * assert.deepStrictEqual(mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]), { A: 4, B: 6 }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ + (f: (a: A, key: K) => readonly [K2, B]): (self: ReadonlyRecord) => Record; + /** + * Maps entries of a `ReadonlyRecord` using the provided function, allowing modification of both keys and corresponding values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { mapEntries } from "effect/Record" + * + * assert.deepStrictEqual(mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]), { A: 4, B: 6 }) + * ``` + * + * @category mapping + * @since 2.0.0 + */ + (self: ReadonlyRecord, f: (a: A, key: K) => [K2, B]): Record; +}; +/** + * Transforms a record into a record by applying the function `f` to each key and value in the original record. + * If the function returns `Some`, the key-value pair is included in the output record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Option } from "effect" + * + * const x = { a: 1, b: 2, c: 3 } + * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none() + * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 }) + * ``` + * + * @since 2.0.0 + */ +export declare const filterMap: { + /** + * Transforms a record into a record by applying the function `f` to each key and value in the original record. + * If the function returns `Some`, the key-value pair is included in the output record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Option } from "effect" + * + * const x = { a: 1, b: 2, c: 3 } + * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none() + * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 }) + * ``` + * + * @since 2.0.0 + */ + (f: (a: A, key: K) => Option.Option): (self: ReadonlyRecord) => Record, B>; + /** + * Transforms a record into a record by applying the function `f` to each key and value in the original record. + * If the function returns `Some`, the key-value pair is included in the output record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Option } from "effect" + * + * const x = { a: 1, b: 2, c: 3 } + * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none() + * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 }) + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, f: (a: A, key: K) => Option.Option): Record, B>; +}; +/** + * Selects properties from a record whose values match the given predicate. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { filter } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3, d: 4 } + * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 }) + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const filter: { + /** + * Selects properties from a record whose values match the given predicate. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { filter } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3, d: 4 } + * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 }) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (refinement: (a: NoInfer, key: K) => a is B): (self: ReadonlyRecord) => Record, B>; + /** + * Selects properties from a record whose values match the given predicate. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { filter } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3, d: 4 } + * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 }) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (predicate: (A: NoInfer, key: K) => boolean): (self: ReadonlyRecord) => Record, A>; + /** + * Selects properties from a record whose values match the given predicate. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { filter } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3, d: 4 } + * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 }) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: ReadonlyRecord, refinement: (a: A, key: K) => a is B): Record, B>; + /** + * Selects properties from a record whose values match the given predicate. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { filter } from "effect/Record" + * + * const x = { a: 1, b: 2, c: 3, d: 4 } + * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 }) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: ReadonlyRecord, predicate: (a: A, key: K) => boolean): Record, A>; +}; +/** + * Given a record with `Option` values, returns a new record containing only the `Some` values, preserving the original keys. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Option } from "effect" + * + * assert.deepStrictEqual( + * Record.getSomes({ a: Option.some(1), b: Option.none(), c: Option.some(2) }), + * { a: 1, c: 2 } + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const getSomes: (self: ReadonlyRecord>) => Record, A>; +/** + * Given a record with `Either` values, returns a new record containing only the `Left` values, preserving the original keys. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Either } from "effect" + * + * assert.deepStrictEqual( + * Record.getLefts({ a: Either.right(1), b: Either.left("err"), c: Either.right(2) }), + * { b: "err" } + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const getLefts: (self: ReadonlyRecord>) => Record, L>; +/** + * Given a record with `Either` values, returns a new record containing only the `Right` values, preserving the original keys. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Either } from "effect" + * + * assert.deepStrictEqual( + * Record.getRights({ a: Either.right(1), b: Either.left("err"), c: Either.right(2) }), + * { a: 1, c: 2 } + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const getRights: (self: ReadonlyRecord>) => Record; +/** + * Partitions the elements of a record into two groups: those that match a predicate, and those that don't. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Either } from "effect" + * + * const x = { a: 1, b: 2, c: 3 } + * const f = (n: number) => (n % 2 === 0 ? Either.right(n) : Either.left(n)) + * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2}]) + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const partitionMap: { + /** + * Partitions the elements of a record into two groups: those that match a predicate, and those that don't. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Either } from "effect" + * + * const x = { a: 1, b: 2, c: 3 } + * const f = (n: number) => (n % 2 === 0 ? Either.right(n) : Either.left(n)) + * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2}]) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (f: (a: A, key: K) => Either): (self: ReadonlyRecord) => [left: Record, B>, right: Record, C>]; + /** + * Partitions the elements of a record into two groups: those that match a predicate, and those that don't. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Either } from "effect" + * + * const x = { a: 1, b: 2, c: 3 } + * const f = (n: number) => (n % 2 === 0 ? Either.right(n) : Either.left(n)) + * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2}]) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: ReadonlyRecord, f: (a: A, key: K) => Either): [left: Record, B>, right: Record, C>]; +}; +/** + * Partitions a record of `Either` values into two separate records, + * one with the `Left` values and one with the `Right` values. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record, Either } from "effect" + * + * assert.deepStrictEqual( + * Record.separate({ a: Either.left("e"), b: Either.right(1) }), + * [{ a: "e" }, { b: 1 }] + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const separate: (self: ReadonlyRecord>) => [Record, A>, Record, B>]; +/** + * Partitions a record into two separate records based on the result of a predicate function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { partition } from "effect/Record" + * + * assert.deepStrictEqual( + * partition({ a: 1, b: 3 }, (n) => n > 2), + * [{ a: 1 }, { b: 3 }] + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ +export declare const partition: { + /** + * Partitions a record into two separate records based on the result of a predicate function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { partition } from "effect/Record" + * + * assert.deepStrictEqual( + * partition({ a: 1, b: 3 }, (n) => n > 2), + * [{ a: 1 }, { b: 3 }] + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (refinement: (a: NoInfer, key: K) => a is B): (self: ReadonlyRecord) => [ + excluded: Record, Exclude>, + satisfying: Record, B> + ]; + /** + * Partitions a record into two separate records based on the result of a predicate function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { partition } from "effect/Record" + * + * assert.deepStrictEqual( + * partition({ a: 1, b: 3 }, (n) => n > 2), + * [{ a: 1 }, { b: 3 }] + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (predicate: (a: NoInfer, key: K) => boolean): (self: ReadonlyRecord) => [excluded: Record, A>, satisfying: Record, A>]; + /** + * Partitions a record into two separate records based on the result of a predicate function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { partition } from "effect/Record" + * + * assert.deepStrictEqual( + * partition({ a: 1, b: 3 }, (n) => n > 2), + * [{ a: 1 }, { b: 3 }] + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: ReadonlyRecord, refinement: (a: A, key: K) => a is B): [ + excluded: Record, Exclude>, + satisfying: Record, B> + ]; + /** + * Partitions a record into two separate records based on the result of a predicate function. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { partition } from "effect/Record" + * + * assert.deepStrictEqual( + * partition({ a: 1, b: 3 }, (n) => n > 2), + * [{ a: 1 }, { b: 3 }] + * ) + * ``` + * + * @category filtering + * @since 2.0.0 + */ + (self: ReadonlyRecord, predicate: (a: A, key: K) => boolean): [excluded: Record, A>, satisfying: Record, A>]; +}; +/** + * Retrieve the keys of a given record as an array. + * + * @since 2.0.0 + */ +export declare const keys: (self: ReadonlyRecord) => Array; +/** + * Retrieve the values of a given record as an array. + * + * @since 2.0.0 + */ +export declare const values: (self: ReadonlyRecord) => Array; +/** + * Add a new key-value pair or update an existing key's value in a record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { set } from "effect/Record" + * + * assert.deepStrictEqual(set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 }); + * assert.deepStrictEqual(set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 }); + * ``` + * + * @since 2.0.0 + */ +export declare const set: { + /** + * Add a new key-value pair or update an existing key's value in a record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { set } from "effect/Record" + * + * assert.deepStrictEqual(set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 }); + * assert.deepStrictEqual(set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 }); + * ``` + * + * @since 2.0.0 + */ + (key: K1, value: B): (self: ReadonlyRecord) => Record; + /** + * Add a new key-value pair or update an existing key's value in a record. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { set } from "effect/Record" + * + * assert.deepStrictEqual(set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 }); + * assert.deepStrictEqual(set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 }); + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: K1, value: B): Record; +}; +/** + * Replace a key's value in a record and return the updated record. + * If the key does not exist in the record, a copy of the original record is returned. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record } from "effect" + * + * assert.deepStrictEqual(Record.replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 }); + * assert.deepStrictEqual(Record.replace("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 }); + * ``` + * + * @since 2.0.0 + */ +export declare const replace: { + /** + * Replace a key's value in a record and return the updated record. + * If the key does not exist in the record, a copy of the original record is returned. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record } from "effect" + * + * assert.deepStrictEqual(Record.replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 }); + * assert.deepStrictEqual(Record.replace("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 }); + * ``` + * + * @since 2.0.0 + */ + (key: NoInfer, value: B): (self: ReadonlyRecord) => Record; + /** + * Replace a key's value in a record and return the updated record. + * If the key does not exist in the record, a copy of the original record is returned. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Record } from "effect" + * + * assert.deepStrictEqual(Record.replace("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 }); + * assert.deepStrictEqual(Record.replace("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 }); + * ``` + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, key: NoInfer, value: B): Record; +}; +/** + * Check if all the keys and values in one record are also found in another record. + * + * @since 2.0.0 + */ +export declare const isSubrecordBy: (equivalence: Equivalence) => { + (that: ReadonlyRecord): (self: ReadonlyRecord) => boolean; + (self: ReadonlyRecord, that: ReadonlyRecord): boolean; +}; +/** + * Check if one record is a subrecord of another, meaning it contains all the keys and values found in the second record. + * This comparison uses default equality checks (`Equal.equivalence()`). + * + * @since 2.0.0 + */ +export declare const isSubrecord: { + /** + * Check if one record is a subrecord of another, meaning it contains all the keys and values found in the second record. + * This comparison uses default equality checks (`Equal.equivalence()`). + * + * @since 2.0.0 + */ + (that: ReadonlyRecord): (self: ReadonlyRecord) => boolean; + /** + * Check if one record is a subrecord of another, meaning it contains all the keys and values found in the second record. + * This comparison uses default equality checks (`Equal.equivalence()`). + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, that: ReadonlyRecord): boolean; +}; +/** + * Reduce a record to a single value by combining its entries with a specified function. + * + * @category folding + * @since 2.0.0 + */ +export declare const reduce: { + /** + * Reduce a record to a single value by combining its entries with a specified function. + * + * @category folding + * @since 2.0.0 + */ + (zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: ReadonlyRecord) => Z; + /** + * Reduce a record to a single value by combining its entries with a specified function. + * + * @category folding + * @since 2.0.0 + */ + (self: ReadonlyRecord, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z; +}; +/** + * Check if all entries in a record meet a specific condition. + * + * @since 2.0.0 + */ +export declare const every: { + /** + * Check if all entries in a record meet a specific condition. + * + * @since 2.0.0 + */ + (refinement: (value: A, key: K) => value is B): (self: ReadonlyRecord) => self is ReadonlyRecord; + /** + * Check if all entries in a record meet a specific condition. + * + * @since 2.0.0 + */ + (predicate: (value: A, key: K) => boolean): (self: ReadonlyRecord) => boolean; + /** + * Check if all entries in a record meet a specific condition. + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, refinement: (value: A, key: K) => value is B): self is ReadonlyRecord; + /** + * Check if all entries in a record meet a specific condition. + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, predicate: (value: A, key: K) => boolean): boolean; +}; +/** + * Check if any entry in a record meets a specific condition. + * + * @since 2.0.0 + */ +export declare const some: { + /** + * Check if any entry in a record meets a specific condition. + * + * @since 2.0.0 + */ + (predicate: (value: A, key: K) => boolean): (self: ReadonlyRecord) => boolean; + /** + * Check if any entry in a record meets a specific condition. + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, predicate: (value: A, key: K) => boolean): boolean; +}; +/** + * Merge two records, preserving entries that exist in either of the records. + * + * @since 2.0.0 + */ +export declare const union: { + /** + * Merge two records, preserving entries that exist in either of the records. + * + * @since 2.0.0 + */ + (that: ReadonlyRecord, combine: (selfValue: A, thatValue: B) => C): (self: ReadonlyRecord) => Record; + /** + * Merge two records, preserving entries that exist in either of the records. + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, that: ReadonlyRecord, combine: (selfValue: A, thatValue: B) => C): Record; +}; +/** + * Merge two records, retaining only the entries that exist in both records. + * + * @since 2.0.0 + */ +export declare const intersection: { + /** + * Merge two records, retaining only the entries that exist in both records. + * + * @since 2.0.0 + */ + (that: ReadonlyRecord, combine: (selfValue: A, thatValue: B) => C): (self: ReadonlyRecord) => Record, C>; + /** + * Merge two records, retaining only the entries that exist in both records. + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, that: ReadonlyRecord, combine: (selfValue: A, thatValue: B) => C): Record, C>; +}; +/** + * Merge two records, preserving only the entries that are unique to each record. + * + * @since 2.0.0 + */ +export declare const difference: { + /** + * Merge two records, preserving only the entries that are unique to each record. + * + * @since 2.0.0 + */ + (that: ReadonlyRecord): (self: ReadonlyRecord) => Record; + /** + * Merge two records, preserving only the entries that are unique to each record. + * + * @since 2.0.0 + */ + (self: ReadonlyRecord, that: ReadonlyRecord): Record; +}; +/** + * Create an `Equivalence` for records using the provided `Equivalence` for values. + * + * @category instances + * @since 2.0.0 + */ +export declare const getEquivalence: (equivalence: Equivalence) => Equivalence>; +/** + * Create a non-empty record from a single element. + * + * @category constructors + * @since 2.0.0 + */ +export declare const singleton: (key: K, value: A) => Record; +/** + * 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 declare 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 + */ + (refinement: (value: NoInfer, key: NoInfer) => value is V2): (self: ReadonlyRecord) => 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 + */ + (predicate: (value: NoInfer, key: NoInfer) => boolean): (self: ReadonlyRecord) => 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 + */ + (self: ReadonlyRecord, refinement: (value: NoInfer, key: NoInfer) => 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 + */ + (self: ReadonlyRecord, predicate: (value: NoInfer, key: NoInfer) => boolean): Option.Option<[K, V]>; +}; +//# sourceMappingURL=Record.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Record.d.ts.map b/backend/node_modules/effect/dist/dts/Record.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..76f877afc64f1ae3540b2d4972ae08285928c1d2 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Record.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Record.d.ts","sourceRoot":"","sources":["../../src/Record.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RedBlackTree.d.ts b/backend/node_modules/effect/dist/dts/RedBlackTree.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f2305a36cb83511e834a298841be0931dbb9c0a6 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RedBlackTree.d.ts @@ -0,0 +1,676 @@ +/** + * @since 2.0.0 + */ +import type { Chunk } from "./Chunk.js"; +import type { Equal } from "./Equal.js"; +import type { Inspectable } from "./Inspectable.js"; +import type { Option } from "./Option.js"; +import type { Order } from "./Order.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Types from "./Types.js"; +declare const TypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @since 2.0.0 + * @category constants + */ +export declare const Direction: { + readonly Forward: RedBlackTree.Direction; + readonly Backward: RedBlackTree.Direction; +}; +/** + * A Red-Black Tree. + * + * @since 2.0.0 + * @category models + */ +export interface RedBlackTree extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable { + readonly [TypeId]: { + readonly _Key: Types.Invariant; + readonly _Value: Types.Covariant; + }; +} +/** + * @since 2.0.0 + */ +export declare namespace RedBlackTree { + /** + * @since 2.0.0 + */ + type Direction = number & { + readonly Direction: unique symbol; + }; +} +/** + * @since 2.0.0 + * @category refinements + */ +export declare const isRedBlackTree: { + /** + * @since 2.0.0 + * @category refinements + */ + (u: Iterable): u is RedBlackTree; + /** + * @since 2.0.0 + * @category refinements + */ + (u: unknown): u is RedBlackTree; +}; +/** + * Creates an empty `RedBlackTree`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const empty: (ord: Order) => RedBlackTree; +/** + * Creates a new `RedBlackTree` from an iterable collection of key/value pairs. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromIterable: { + /** + * Creates a new `RedBlackTree` from an iterable collection of key/value pairs. + * + * @since 2.0.0 + * @category constructors + */ + (ord: Order): (entries: Iterable) => RedBlackTree; + /** + * Creates a new `RedBlackTree` from an iterable collection of key/value pairs. + * + * @since 2.0.0 + * @category constructors + */ + (entries: Iterable, ord: Order): RedBlackTree; +}; +/** + * Constructs a new `RedBlackTree` from the specified entries. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (ord: Order) => >(...entries: Entries) => RedBlackTree; +/** + * Returns an iterator that points to the element at the specified index of the + * tree. + * + * **Note**: The iterator will run through elements in order. + * + * @since 2.0.0 + * @category traversing + */ +export declare const at: { + /** + * Returns an iterator that points to the element at the specified index of the + * tree. + * + * **Note**: The iterator will run through elements in order. + * + * @since 2.0.0 + * @category traversing + */ + (index: number): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that points to the element at the specified index of the + * tree. + * + * **Note**: The iterator will run through elements in order. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, index: number): Iterable<[K, V]>; +}; +/** + * Returns an iterator that points to the element at the specified index of the + * tree. + * + * **Note**: The iterator will run through elements in reverse order. + * + * @since 2.0.0 + * @category traversing + */ +export declare const atReversed: { + /** + * Returns an iterator that points to the element at the specified index of the + * tree. + * + * **Note**: The iterator will run through elements in reverse order. + * + * @since 2.0.0 + * @category traversing + */ + (index: number): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that points to the element at the specified index of the + * tree. + * + * **Note**: The iterator will run through elements in reverse order. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, index: number): Iterable<[K, V]>; +}; +/** + * Finds all values in the tree associated with the specified key. + * + * @since 2.0.0 + * @category elements + */ +export declare const findAll: { + /** + * Finds all values in the tree associated with the specified key. + * + * @since 2.0.0 + * @category elements + */ + (key: K): (self: RedBlackTree) => Chunk; + /** + * Finds all values in the tree associated with the specified key. + * + * @since 2.0.0 + * @category elements + */ + (self: RedBlackTree, key: K): Chunk; +}; +/** + * Finds the first value in the tree associated with the specified key, if it exists. + * + * @category elements + * @since 2.0.0 + */ +export declare const findFirst: { + /** + * Finds the first value in the tree associated with the specified key, if it exists. + * + * @category elements + * @since 2.0.0 + */ + (key: K): (self: RedBlackTree) => Option; + /** + * Finds the first value in the tree associated with the specified key, if it exists. + * + * @category elements + * @since 2.0.0 + */ + (self: RedBlackTree, key: K): Option; +}; +/** + * Returns the first entry in the tree, if it exists. + * + * @since 2.0.0 + * @category getters + */ +export declare const first: (self: RedBlackTree) => Option<[K, V]>; +/** + * Returns the element at the specified index within the tree or `None` if the + * specified index does not exist. + * + * @since 2.0.0 + * @category elements + */ +export declare const getAt: { + /** + * Returns the element at the specified index within the tree or `None` if the + * specified index does not exist. + * + * @since 2.0.0 + * @category elements + */ + (index: number): (self: RedBlackTree) => Option<[K, V]>; + /** + * Returns the element at the specified index within the tree or `None` if the + * specified index does not exist. + * + * @since 2.0.0 + * @category elements + */ + (self: RedBlackTree, index: number): Option<[K, V]>; +}; +/** + * Gets the `Order` that the `RedBlackTree` is using. + * + * @since 2.0.0 + * @category getters + */ +export declare const getOrder: (self: RedBlackTree) => Order; +/** + * Returns an iterator that traverse entries in order with keys greater than the + * specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const greaterThan: { + /** + * Returns an iterator that traverse entries in order with keys greater than the + * specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in order with keys greater than the + * specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Returns an iterator that traverse entries in reverse order with keys greater + * than the specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const greaterThanReversed: { + /** + * Returns an iterator that traverse entries in reverse order with keys greater + * than the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in reverse order with keys greater + * than the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Returns an iterator that traverse entries in order with keys greater than or + * equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const greaterThanEqual: { + /** + * Returns an iterator that traverse entries in order with keys greater than or + * equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in order with keys greater than or + * equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Returns an iterator that traverse entries in reverse order with keys greater + * than or equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const greaterThanEqualReversed: { + /** + * Returns an iterator that traverse entries in reverse order with keys greater + * than or equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in reverse order with keys greater + * than or equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Finds the item with key, if it exists. + * + * @since 2.0.0 + * @category elements + */ +export declare const has: { + /** + * Finds the item with key, if it exists. + * + * @since 2.0.0 + * @category elements + */ + (key: K): (self: RedBlackTree) => boolean; + /** + * Finds the item with key, if it exists. + * + * @since 2.0.0 + * @category elements + */ + (self: RedBlackTree, key: K): boolean; +}; +/** + * Insert a new item into the tree. + * + * @since 2.0.0 + */ +export declare const insert: { + /** + * Insert a new item into the tree. + * + * @since 2.0.0 + */ + (key: K, value: V): (self: RedBlackTree) => RedBlackTree; + /** + * Insert a new item into the tree. + * + * @since 2.0.0 + */ + (self: RedBlackTree, key: K, value: V): RedBlackTree; +}; +/** + * Get all the keys present in the tree in order. + * + * @since 2.0.0 + * @category getters + */ +export declare const keys: (self: RedBlackTree) => IterableIterator; +/** + * Get all the keys present in the tree in reverse order. + * + * @since 2.0.0 + * @category getters + */ +export declare const keysReversed: (self: RedBlackTree) => IterableIterator; +/** + * Returns the last entry in the tree, if it exists. + * + * @since 2.0.0 + * @category getters + */ +export declare const last: (self: RedBlackTree) => Option<[K, V]>; +/** + * Returns an iterator that traverse entries in order with keys less than the + * specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const lessThan: { + /** + * Returns an iterator that traverse entries in order with keys less than the + * specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in order with keys less than the + * specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Returns an iterator that traverse entries in reverse order with keys less + * than the specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const lessThanReversed: { + /** + * Returns an iterator that traverse entries in reverse order with keys less + * than the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in reverse order with keys less + * than the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Returns an iterator that traverse entries in order with keys less than or + * equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const lessThanEqual: { + /** + * Returns an iterator that traverse entries in order with keys less than or + * equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in order with keys less than or + * equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Returns an iterator that traverse entries in reverse order with keys less + * than or equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ +export declare const lessThanEqualReversed: { + /** + * Returns an iterator that traverse entries in reverse order with keys less + * than or equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (key: K): (self: RedBlackTree) => Iterable<[K, V]>; + /** + * Returns an iterator that traverse entries in reverse order with keys less + * than or equal to the specified key. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, key: K): Iterable<[K, V]>; +}; +/** + * Execute the specified function for each node of the tree, in order. + * + * @since 2.0.0 + * @category traversing + */ +export declare const forEach: { + /** + * Execute the specified function for each node of the tree, in order. + * + * @since 2.0.0 + * @category traversing + */ + (f: (key: K, value: V) => void): (self: RedBlackTree) => void; + /** + * Execute the specified function for each node of the tree, in order. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, f: (key: K, value: V) => void): void; +}; +/** + * Visit each node of the tree in order with key greater then or equal to max. + * + * @since 2.0.0 + * @category traversing + */ +export declare const forEachGreaterThanEqual: { + /** + * Visit each node of the tree in order with key greater then or equal to max. + * + * @since 2.0.0 + * @category traversing + */ + (min: K, f: (key: K, value: V) => void): (self: RedBlackTree) => void; + /** + * Visit each node of the tree in order with key greater then or equal to max. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, min: K, f: (key: K, value: V) => void): void; +}; +/** + * Visit each node of the tree in order with key lower then max. + * + * @since 2.0.0 + * @category traversing + */ +export declare const forEachLessThan: { + /** + * Visit each node of the tree in order with key lower then max. + * + * @since 2.0.0 + * @category traversing + */ + (max: K, f: (key: K, value: V) => void): (self: RedBlackTree) => void; + /** + * Visit each node of the tree in order with key lower then max. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, max: K, f: (key: K, value: V) => void): void; +}; +/** + * Visit each node of the tree in order with key lower than max and greater + * than or equal to min. + * + * @since 2.0.0 + * @category traversing + */ +export declare const forEachBetween: { + /** + * Visit each node of the tree in order with key lower than max and greater + * than or equal to min. + * + * @since 2.0.0 + * @category traversing + */ + (options: { + readonly min: K; + readonly max: K; + readonly body: (key: K, value: V) => void; + }): (self: RedBlackTree) => void; + /** + * Visit each node of the tree in order with key lower than max and greater + * than or equal to min. + * + * @since 2.0.0 + * @category traversing + */ + (self: RedBlackTree, options: { + readonly min: K; + readonly max: K; + readonly body: (key: K, value: V) => void; + }): void; +}; +/** + * Reduce a state over the entries of the tree. + * + * @since 2.0.0 + * @category folding + */ +export declare const reduce: { + /** + * Reduce a state over the entries of the tree. + * + * @since 2.0.0 + * @category folding + */ + (zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree) => Z; + /** + * Reduce a state over the entries of the tree. + * + * @since 2.0.0 + * @category folding + */ + (self: RedBlackTree, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z; +}; +/** + * Removes the entry with the specified key, if it exists. + * + * @since 2.0.0 + */ +export declare const removeFirst: { + /** + * Removes the entry with the specified key, if it exists. + * + * @since 2.0.0 + */ + (key: K): (self: RedBlackTree) => RedBlackTree; + /** + * Removes the entry with the specified key, if it exists. + * + * @since 2.0.0 + */ + (self: RedBlackTree, key: K): RedBlackTree; +}; +/** + * Traverse the tree in reverse order. + * + * @since 2.0.0 + * @category traversing + */ +export declare const reversed: (self: RedBlackTree) => Iterable<[K, V]>; +/** + * Returns the size of the tree. + * + * @since 2.0.0 + * @category getters + */ +export declare const size: (self: RedBlackTree) => number; +/** + * Get all values present in the tree in order. + * + * @since 2.0.0 + * @category getters + */ +export declare const values: (self: RedBlackTree) => IterableIterator; +/** + * Get all values present in the tree in reverse order. + * + * @since 2.0.0 + * @category getters + */ +export declare const valuesReversed: (self: RedBlackTree) => IterableIterator; +export {}; +//# sourceMappingURL=RedBlackTree.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RedBlackTree.d.ts.map b/backend/node_modules/effect/dist/dts/RedBlackTree.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..b6f2c9559f2498ad9d284ad4db7778f22ce584ff --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RedBlackTree.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"RedBlackTree.d.ts","sourceRoot":"","sources":["../../src/RedBlackTree.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Redacted.d.ts.map b/backend/node_modules/effect/dist/dts/Redacted.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..399232db812081a24e278fc6e00f3134067ec3b3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Redacted.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Redacted.d.ts","sourceRoot":"","sources":["../../src/Redacted.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAAiC,CAAA;AAErE;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD;;;GAGG;AACH,MAAM,WAAW,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAE,SAAQ,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,QAAQ;CAC5F;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,QAAQ,CAAC;IAChC;;;OAGG;IACH,UAAiB,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC7B,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE;YACzB,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;SAC1B,CAAA;KACF;IAED;;;OAGG;IACH,KAAY,KAAK,CAAC,CAAC,SAAS,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,CAAA;CAC3F;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAwB,CAAA;AAEtF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAkB,CAAA;AAEhE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAmB,CAAA;AAEjE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,OAA8B,CAAA;AAEjF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,cAAc,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAClD,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Ref.d.ts.map b/backend/node_modules/effect/dist/dts/Ref.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..fc68d1cc38d9da8e136e65b3ec4f5bc5f16b6189 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Ref.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Ref.d.ts","sourceRoot":"","sources":["../../src/Ref.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAE1C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,OAAO,MAA2B,CAAA;AAE1D;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA;AAExC;;;GAGG;AACH,MAAM,WAAW,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAE,SAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC5F,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACzD,QAAQ,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,EAAE,OAAO,CAAA;IACrC,QAAQ,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC7C,QAAQ,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc,CAAA;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS;IAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,EAAE,GAAG,CAAA;CAAE,CAAE,SAAQ,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;IAC7F,GAAG,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;CACnD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,MAAM,CAAC,iBAAiB;IAC9D,MAAM,CAAC,EAAE,IAAI,CAAA;CACd;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,WAAW,GAAG,CAAC;IAC3B;;OAEG;IACH,UAAiB,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAChC,QAAQ,CAAC,CAAC,SAAS,CAAC,EAAE;YACpB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;SAChC,CAAA;KACF;CACF;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAiB,CAAA;AAEzE;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAgB,CAAA;AAEtE;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;OAGG;IACH,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACjD;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACzB,CAAA;AAEtB;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE;IACzB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACvD;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CAC5B,CAAA;AAEzB;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAC7B;;;OAGG;IACH,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACvE;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACxC,CAAA;AAE7B;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACxE;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACnD,CAAA;AAEnB;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACrG;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CAC5E,CAAA;AAEvB;;;GAGG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;OAGG;IACH,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACpD;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAClC,CAAA;AAEhB;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;OAGG;IACH,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACjD;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACzB,CAAA;AAEtB;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC1D;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CACrC,CAAA;AAEnB;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE;IACzB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACvD;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CAC5B,CAAA;AAEzB;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB;;;OAGG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACzE;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAChD,CAAA;AAEvB;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAC7B;;;OAGG;IACH,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACvE;;;OAGG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACxC,CAAA;AAE7B;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,CAAuB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RegExp.d.ts b/backend/node_modules/effect/dist/dts/RegExp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9c9b972891eabb48271bc3fb53b054cdc81e6c93 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RegExp.d.ts @@ -0,0 +1,31 @@ +/** + * Tests if a value is a `RegExp`. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { RegExp } from "effect" + * + * assert.deepStrictEqual(RegExp.isRegExp(/a/), true) + * assert.deepStrictEqual(RegExp.isRegExp("a"), false) + * ``` + * + * @category guards + * @since 3.9.0 + */ +export declare const isRegExp: (input: unknown) => input is RegExp; +/** + * Escapes special characters in a regular expression pattern. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { RegExp } from "effect" + * + * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b") + * ``` + * + * @since 2.0.0 + */ +export declare const escape: (string: string) => string; +//# sourceMappingURL=RegExp.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RegExp.d.ts.map b/backend/node_modules/effect/dist/dts/RegExp.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..9cfb75061780550037a8e388f761dcf1f434932b --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RegExp.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"RegExp.d.ts","sourceRoot":"","sources":["../../src/RegExp.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,MAA2B,CAAA;AAE/E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM,KAAG,MAAwD,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Reloadable.d.ts b/backend/node_modules/effect/dist/dts/Reloadable.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bedd34fe1e3dcf3cf73614dd9ffbd71bb60a463a --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Reloadable.d.ts @@ -0,0 +1,102 @@ +/** + * @since 2.0.0 + */ +import type * as Context from "./Context.js"; +import type * as Effect from "./Effect.js"; +import type * as Layer from "./Layer.js"; +import type * as Schedule from "./Schedule.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const ReloadableTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ReloadableTypeId = typeof ReloadableTypeId; +/** + * A `Reloadable` is an implementation of some service that can be dynamically + * reloaded, or swapped out for another implementation on-the-fly. + * + * @since 2.0.0 + * @category models + */ +export interface Reloadable extends Reloadable.Variance { +} +/** + * @since 2.0.0 + */ +export declare namespace Reloadable { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [ReloadableTypeId]: { + readonly _A: Types.Invariant; + }; + } +} +/** + * Makes a new reloadable service from a layer that describes the construction + * of a static service. The service is automatically reloaded according to the + * provided schedule. + * + * @since 2.0.0 + * @category constructors + */ +export declare const auto: (tag: Context.Tag, options: { + readonly layer: Layer.Layer; + readonly schedule: Schedule.Schedule; +}) => Layer.Layer, E, R | In>; +/** + * Makes a new reloadable service from a layer that describes the construction + * of a static service. The service is automatically reloaded according to a + * schedule, which is extracted from the input to the layer. + * + * @since 2.0.0 + * @category constructors + */ +export declare const autoFromConfig: (tag: Context.Tag, options: { + readonly layer: Layer.Layer; + readonly scheduleFromConfig: (context: Context.Context) => Schedule.Schedule; +}) => Layer.Layer, E, R | In>; +/** + * Retrieves the current version of the reloadable service. + * + * @since 2.0.0 + * @category getters + */ +export declare const get: (tag: Context.Tag) => Effect.Effect>; +/** + * Makes a new reloadable service from a layer that describes the construction + * of a static service. + * + * @since 2.0.0 + * @category constructors + */ +export declare const manual: (tag: Context.Tag, options: { + readonly layer: Layer.Layer; +}) => Layer.Layer, E, In>; +/** + * Reloads the specified service. + * + * @since 2.0.0 + * @category constructors + */ +export declare const reload: (tag: Context.Tag) => Effect.Effect>; +/** + * @since 2.0.0 + * @category context + */ +export declare const tag: (tag: Context.Tag) => Context.Tag, Reloadable>; +/** + * Forks the reload of the service in the background, ignoring any errors. + * + * @since 2.0.0 + * @category constructors + */ +export declare const reloadFork: (tag: Context.Tag) => Effect.Effect>; +//# sourceMappingURL=Reloadable.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Reloadable.d.ts.map b/backend/node_modules/effect/dist/dts/Reloadable.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..b18b33a3fffbda84ef64eecbb8a8c41bbe64bc90 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Reloadable.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Reloadable.d.ts","sourceRoot":"","sources":["../../src/Reloadable.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Request.d.ts.map b/backend/node_modules/effect/dist/dts/Request.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..ee989023bfd1e3f8de6bdc7c097d5f917525f225 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Request.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Request.d.ts","sourceRoot":"","sources":["../../src/Request.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RequestBlock.d.ts b/backend/node_modules/effect/dist/dts/RequestBlock.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..87dad32144e2f4d34db926f817c2cffdd9efeebb --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RequestBlock.d.ts @@ -0,0 +1,94 @@ +import type * as Request from "./Request.js"; +import type * as RequestResolver from "./RequestResolver.js"; +/** + * `RequestBlock` captures a collection of blocked requests as a data + * structure. By doing this the library is able to preserve information about + * which requests must be performed sequentially and which can be performed in + * parallel, allowing for maximum possible batching and pipelining while + * preserving ordering guarantees. + * + * @since 2.0.0 + * @category models + */ +export type RequestBlock = Empty | Par | Seq | Single; +/** + * @since 2.0.0 + * @category models + */ +export declare namespace RequestBlock { + /** + * @since 2.0.0 + * @category models + */ + interface Reducer { + emptyCase(): Z; + parCase(left: Z, right: Z): Z; + singleCase(dataSource: RequestResolver.RequestResolver, blockedRequest: Request.Entry): Z; + seqCase(left: Z, right: Z): Z; + } +} +/** + * @since 2.0.0 + * @category models + */ +export interface Empty { + readonly _tag: "Empty"; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Par { + readonly _tag: "Par"; + readonly left: RequestBlock; + readonly right: RequestBlock; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Seq { + readonly _tag: "Seq"; + readonly left: RequestBlock; + readonly right: RequestBlock; +} +/** + * @since 2.0.0 + * @category models + */ +export interface Single { + readonly _tag: "Single"; + readonly dataSource: RequestResolver.RequestResolver; + readonly blockedRequest: Request.Entry; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const single: (dataSource: RequestResolver.RequestResolver, blockedRequest: Request.Entry) => RequestBlock; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const empty: RequestBlock; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const mapRequestResolvers: (self: RequestBlock, f: (dataSource: RequestResolver.RequestResolver) => RequestResolver.RequestResolver) => RequestBlock; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const parallel: (self: RequestBlock, that: RequestBlock) => RequestBlock; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const reduce: (self: RequestBlock, reducer: RequestBlock.Reducer) => Z; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const sequential: (self: RequestBlock, that: RequestBlock) => RequestBlock; +//# sourceMappingURL=RequestBlock.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RequestBlock.d.ts.map b/backend/node_modules/effect/dist/dts/RequestBlock.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..5cd20ad4eecfbd1c31080015bb9931788e85fb7d --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RequestBlock.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"RequestBlock.d.ts","sourceRoot":"","sources":["../../src/RequestBlock.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAE5D;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAA;AAErD;;;GAGG;AACH,MAAM,CAAC,OAAO,WAAW,YAAY,CAAC;IACpC;;;OAGG;IACH,UAAiB,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAC/B,SAAS,IAAI,CAAC,CAAA;QACd,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAA;QAC7B,UAAU,CACR,UAAU,EAAE,eAAe,CAAC,eAAe,CAAC,OAAO,CAAC,EACpD,cAAc,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,GACrC,CAAC,CAAA;QACJ,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAA;KAC9B;CACF;AAED;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC,eAAe,CAAC,OAAO,CAAC,CAAA;IAC7D,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;CAChD;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EACrB,UAAU,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,EAC9C,cAAc,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,KAC7B,YAAmC,CAAA;AAExC;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,YAAkC,CAAA;AAEtD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAClC,IAAI,EAAE,YAAY,EAClB,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,KACtF,YAAgD,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,KAAK,YAAgC,CAAA;AAEnG;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAwB,CAAA;AAE1G;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,KAAK,YAAgC,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RequestResolver.d.ts b/backend/node_modules/effect/dist/dts/RequestResolver.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..14f216fee4097d712e4b33d3d4649f3194e73f02 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RequestResolver.d.ts @@ -0,0 +1,413 @@ +/** + * @since 2.0.0 + */ +import type { NonEmptyArray } from "./Array.js"; +import * as Context from "./Context.js"; +import * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type * as Equal from "./Equal.js"; +import type { FiberRef } from "./FiberRef.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as Request from "./Request.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const RequestResolverTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type RequestResolverTypeId = typeof RequestResolverTypeId; +/** + * The `RequestResolver` interface requires an environment `R` and handles + * the execution of requests of type `A`. + * + * Implementations must provide a `runAll` method, which processes a collection + * of requests and produces an effect that fulfills these requests. Requests are + * organized into a `Array>`, where the outer `Array` groups requests + * into batches that are executed sequentially, and each inner `Array` contains + * requests that can be executed in parallel. This structure allows + * implementations to analyze all incoming requests collectively and optimize + * query execution accordingly. + * + * Implementations are typically specialized for a subtype of `Request`. + * However, they are not strictly limited to these subtypes as long as they can + * map any given request type to `Request`. Implementations should inspect + * the collection of requests to identify the needed information and execute the + * corresponding queries. It is imperative that implementations resolve all the + * requests they receive. Failing to do so will lead to a `QueryFailure` error + * during query execution. + * + * @since 2.0.0 + * @category models + */ +export interface RequestResolver extends RequestResolver.Variance, Equal.Equal, Pipeable { + /** + * Execute a collection of requests. The outer `Array` represents batches + * of requests that must be performed sequentially. The inner `Array` + * represents a batch of requests that can be performed in parallel. + */ + runAll(requests: Array>>): Effect.Effect; + /** + * Identify the data source using the specific identifier + */ + identified(...identifiers: Array): RequestResolver; +} +/** + * @since 2.0.0 + */ +export declare namespace RequestResolver { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [RequestResolverTypeId]: { + readonly _A: Types.Contravariant; + readonly _R: Types.Covariant; + }; + } +} +/** + * @since 2.0.0 + * @category utils + */ +export declare const contextFromEffect: >(self: RequestResolver) => Effect.Effect, never, R>; +/** + * @since 2.0.0 + * @category utils + */ +export declare const contextFromServices: >>(...services: Services) => >(self: RequestResolver) => Effect.Effect; }[number]>>, never, { [k in keyof Services]: Effect.Effect.Context; }[number]>; +/** + * Returns `true` if the specified value is a `RequestResolver`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isRequestResolver: (u: unknown) => u is RequestResolver; +/** + * Constructs a data source with the specified identifier and method to run + * requests. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (runAll: (requests: Array>) => Effect.Effect) => RequestResolver; +/** + * Constructs a data source with the specified identifier and method to run + * requests. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeWithEntry: (runAll: (requests: Array>>) => Effect.Effect) => RequestResolver; +/** + * Constructs a data source from a function taking a collection of requests. + * + * @since 2.0.0 + * @category constructors + */ +export declare const makeBatched: , R>(run: (requests: NonEmptyArray) => Effect.Effect) => RequestResolver; +/** + * A data source aspect that executes requests between two effects, `before` + * and `after`, where the result of `before` can be used by `after`. + * + * @since 2.0.0 + * @category combinators + */ +export declare const around: { + /** + * A data source aspect that executes requests between two effects, `before` + * and `after`, where the result of `before` can be used by `after`. + * + * @since 2.0.0 + * @category combinators + */ + (before: Effect.Effect, after: (a: A2) => Effect.Effect): (self: RequestResolver) => RequestResolver; + /** + * A data source aspect that executes requests between two effects, `before` + * and `after`, where the result of `before` can be used by `after`. + * + * @since 2.0.0 + * @category combinators + */ + (self: RequestResolver, before: Effect.Effect, after: (a: A2) => Effect.Effect): RequestResolver; +}; +/** + * A data source aspect that executes requests between two effects, `before` + * and `after`, where the result of `before` can be used by `after`. + * + * The `before` and `after` effects are provided with the requests being executed. + * + * @since 2.0.0 + * @category combinators + * @example + * ```ts + * import { Effect, Request, RequestResolver } from "effect" + * + * interface GetUserById extends Request.Request { + * readonly id: number + * } + * + * const resolver = RequestResolver.fromFunction( + * (request: GetUserById) => ({ id: request.id, name: "John" }) + * ) + * + * RequestResolver.aroundRequests( + * resolver, + * (requests) => Effect.log(`got ${requests.length} requests`), + * (requests, _) => Effect.log(`finised running ${requests.length} requests`) + * ) + * ``` + */ +export declare const aroundRequests: { + /** + * A data source aspect that executes requests between two effects, `before` + * and `after`, where the result of `before` can be used by `after`. + * + * The `before` and `after` effects are provided with the requests being executed. + * + * @since 2.0.0 + * @category combinators + * @example + * ```ts + * import { Effect, Request, RequestResolver } from "effect" + * + * interface GetUserById extends Request.Request { + * readonly id: number + * } + * + * const resolver = RequestResolver.fromFunction( + * (request: GetUserById) => ({ id: request.id, name: "John" }) + * ) + * + * RequestResolver.aroundRequests( + * resolver, + * (requests) => Effect.log(`got ${requests.length} requests`), + * (requests, _) => Effect.log(`finised running ${requests.length} requests`) + * ) + * ``` + */ + (before: (requests: ReadonlyArray>) => Effect.Effect, after: (requests: ReadonlyArray>, _: A2) => Effect.Effect): (self: RequestResolver) => RequestResolver; + /** + * A data source aspect that executes requests between two effects, `before` + * and `after`, where the result of `before` can be used by `after`. + * + * The `before` and `after` effects are provided with the requests being executed. + * + * @since 2.0.0 + * @category combinators + * @example + * ```ts + * import { Effect, Request, RequestResolver } from "effect" + * + * interface GetUserById extends Request.Request { + * readonly id: number + * } + * + * const resolver = RequestResolver.fromFunction( + * (request: GetUserById) => ({ id: request.id, name: "John" }) + * ) + * + * RequestResolver.aroundRequests( + * resolver, + * (requests) => Effect.log(`got ${requests.length} requests`), + * (requests, _) => Effect.log(`finised running ${requests.length} requests`) + * ) + * ``` + */ + (self: RequestResolver, before: (requests: ReadonlyArray>) => Effect.Effect, after: (requests: ReadonlyArray>, _: A2) => Effect.Effect): RequestResolver; +}; +/** + * Returns a data source that executes at most `n` requests in parallel. + * + * @since 2.0.0 + * @category combinators + */ +export declare const batchN: { + /** + * Returns a data source that executes at most `n` requests in parallel. + * + * @since 2.0.0 + * @category combinators + */ + (n: number): (self: RequestResolver) => RequestResolver; + /** + * Returns a data source that executes at most `n` requests in parallel. + * + * @since 2.0.0 + * @category combinators + */ + (self: RequestResolver, n: number): RequestResolver; +}; +/** + * Provides this data source with part of its required context. + * + * @since 2.0.0 + * @category context + */ +export declare const mapInputContext: { + /** + * Provides this data source with part of its required context. + * + * @since 2.0.0 + * @category context + */ + (f: (context: Context.Context) => Context.Context): >(self: RequestResolver) => RequestResolver; + /** + * Provides this data source with part of its required context. + * + * @since 2.0.0 + * @category context + */ + , R0>(self: RequestResolver, f: (context: Context.Context) => Context.Context): RequestResolver; +}; +/** + * Returns a new data source that executes requests of type `C` using the + * specified function to transform `C` requests into requests that either this + * data source or that data source can execute. + * + * @since 2.0.0 + * @category combinators + */ +export declare const eitherWith: { + /** + * Returns a new data source that executes requests of type `C` using the + * specified function to transform `C` requests into requests that either this + * data source or that data source can execute. + * + * @since 2.0.0 + * @category combinators + */ + , R2, B extends Request.Request, C extends Request.Request>(that: RequestResolver, f: (_: Request.Entry) => Either.Either, Request.Entry>): (self: RequestResolver) => RequestResolver; + /** + * Returns a new data source that executes requests of type `C` using the + * specified function to transform `C` requests into requests that either this + * data source or that data source can execute. + * + * @since 2.0.0 + * @category combinators + */ + , R2, B extends Request.Request, C extends Request.Request>(self: RequestResolver, that: RequestResolver, f: (_: Request.Entry) => Either.Either, Request.Entry>): RequestResolver; +}; +/** + * Constructs a data source from a pure function. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromFunction: >(f: (request: A) => Request.Request.Success) => RequestResolver; +/** + * Constructs a data source from a pure function that takes a list of requests + * and returns a list of results of the same size. Each item in the result + * list must correspond to the item at the same index in the request list. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromFunctionBatched: >(f: (chunk: NonEmptyArray) => Iterable>) => RequestResolver; +/** + * Constructs a data source from an effectual function. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromEffect: >(f: (a: A) => Effect.Effect, Request.Request.Error, R>) => RequestResolver; +/** + * Constructs a data source from a list of tags paired to functions, that takes + * a list of requests and returns a list of results of the same size. Each item + * in the result list must correspond to the item at the same index in the + * request list. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromEffectTagged: & { + readonly _tag: string; +}>() => ] extends [infer Req] ? Req extends Request.Request ? (requests: Array) => Effect.Effect, ReqE, any> : never : never; +}>(fns: Fns) => RequestResolver extends Effect.Effect ? R : never>; +/** + * A data source that never executes requests. + * + * @since 2.0.0 + * @category constructors + */ +export declare const never: RequestResolver; +/** + * Provides this data source with its required context. + * + * @since 2.0.0 + * @category context + */ +export declare const provideContext: { + /** + * Provides this data source with its required context. + * + * @since 2.0.0 + * @category context + */ + (context: Context.Context): >(self: RequestResolver) => RequestResolver; + /** + * Provides this data source with its required context. + * + * @since 2.0.0 + * @category context + */ + >(self: RequestResolver, context: Context.Context): RequestResolver; +}; +/** + * Returns a new data source that executes requests by sending them to this + * data source and that data source, returning the results from the first data + * source to complete and safely interrupting the loser. + * + * @since 2.0.0 + * @category combinators + */ +export declare const race: { + /** + * Returns a new data source that executes requests by sending them to this + * data source and that data source, returning the results from the first data + * source to complete and safely interrupting the loser. + * + * @since 2.0.0 + * @category combinators + */ + , R2>(that: RequestResolver): , R>(self: RequestResolver) => RequestResolver; + /** + * Returns a new data source that executes requests by sending them to this + * data source and that data source, returning the results from the first data + * source to complete and safely interrupting the loser. + * + * @since 2.0.0 + * @category combinators + */ + , R, A2 extends Request.Request, R2>(self: RequestResolver, that: RequestResolver): RequestResolver; +}; +/** + * Returns a new data source with a localized FiberRef + * + * @since 2.0.0 + * @category combinators + */ +export declare const locally: { + /** + * Returns a new data source with a localized FiberRef + * + * @since 2.0.0 + * @category combinators + */ + (self: FiberRef, value: A): >(use: RequestResolver) => RequestResolver; + /** + * Returns a new data source with a localized FiberRef + * + * @since 2.0.0 + * @category combinators + */ + , A>(use: RequestResolver, self: FiberRef, value: A): RequestResolver; +}; +//# sourceMappingURL=RequestResolver.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Resource.d.ts b/backend/node_modules/effect/dist/dts/Resource.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1b26ba3d0254646a6559e387f99a1a52e8ddc9d8 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Resource.d.ts @@ -0,0 +1,99 @@ +/** + * @since 2.0.0 + */ +import type * as Effect from "./Effect.js"; +import type * as Schedule from "./Schedule.js"; +import type * as Scope from "./Scope.js"; +import type * as Types from "./Types.js"; +import type * as Unify from "./Unify.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const ResourceTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type ResourceTypeId = typeof ResourceTypeId; +/** + * A `Resource` is a possibly resourceful value that is loaded into memory, and + * which can be refreshed either manually or automatically. + * + * @since 2.0.0 + * @category models + */ +export interface Resource extends Effect.Effect, Resource.Variance { + readonly [Unify.typeSymbol]?: unknown; + readonly [Unify.unifySymbol]?: ResourceUnify; + readonly [Unify.ignoreSymbol]?: ResourceUnifyIgnore; +} +/** + * @category models + * @since 3.9.0 + */ +export interface ResourceUnify extends Effect.EffectUnify { + Resource?: () => Extract>; +} +/** + * @category models + * @since 3.9.0 + */ +export interface ResourceUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * @since 2.0.0 + */ +export declare namespace Resource { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [ResourceTypeId]: { + _A: Types.Invariant; + _E: Types.Invariant; + }; + } +} +/** + * Creates a new `Resource` value that is automatically refreshed according to + * the specified policy. Note that error retrying is not performed + * automatically, so if you want to retry on errors, you should first apply + * retry policies to the acquisition effect before passing it to this + * constructor. + * + * @since 2.0.0 + * @category constructors + */ +export declare const auto: (acquire: Effect.Effect, policy: Schedule.Schedule) => Effect.Effect, never, R | R2 | Scope.Scope>; +/** + * Retrieves the current value stored in the cache. + * + * @since 2.0.0 + * @category getters + */ +export declare const get: (self: Resource) => Effect.Effect; +/** + * Creates a new `Resource` value that must be manually refreshed by calling + * the refresh method. Note that error retrying is not performed + * automatically, so if you want to retry on errors, you should first apply + * retry policies to the acquisition effect before passing it to this + * constructor. + * + * @since 2.0.0 + * @category constructors + */ +export declare const manual: (acquire: Effect.Effect) => Effect.Effect, never, Scope.Scope | R>; +/** + * Refreshes the cache. This method will not return until either the refresh + * is successful, or the refresh operation fails. + * + * @since 2.0.0 + * @category utils + */ +export declare const refresh: (self: Resource) => Effect.Effect; +//# sourceMappingURL=Resource.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Runtime.d.ts.map b/backend/node_modules/effect/dist/dts/Runtime.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..31dd0f0d76dae2f4b8dc37a4ef3a472f0261179c --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Runtime.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../src/Runtime.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RuntimeFlags.d.ts b/backend/node_modules/effect/dist/dts/RuntimeFlags.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..99620d07621b05a2d4022db57aa8447cccdf85cc --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RuntimeFlags.d.ts @@ -0,0 +1,397 @@ +/** + * @since 2.0.0 + */ +import type * as Differ from "./Differ.js"; +import type * as Layer from "./Layer.js"; +import type * as RuntimeFlagsPatch from "./RuntimeFlagsPatch.js"; +/** + * Represents a set of `RuntimeFlag`s. `RuntimeFlag`s affect the operation of + * the Effect runtime system. They are exposed to application-level code because + * they affect the behavior and performance of application code. + * + * @since 2.0.0 + * @category models + */ +export type RuntimeFlags = number & { + readonly RuntimeFlags: unique symbol; +}; +/** + * Represents a flag that can be set to enable or disable a particular feature + * of the Effect runtime. + * + * @since 2.0.0 + * @category models + */ +export type RuntimeFlag = number & { + readonly RuntimeFlag: unique symbol; +}; +/** + * No runtime flags. + * + * @since 2.0.0 + * @category constructors + */ +export declare const None: RuntimeFlag; +/** + * The interruption flag determines whether or not the Effect runtime system will + * interrupt a fiber. + * + * @since 2.0.0 + * @category constructors + */ +export declare const Interruption: RuntimeFlag; +/** + * The op supervision flag determines whether or not the Effect runtime system + * will supervise all operations of the Effect runtime. Use of this flag will + * negatively impact performance, but is required for some operations, such as + * profiling. + * + * @since 2.0.0 + * @category constructors + */ +export declare const OpSupervision: RuntimeFlag; +/** + * The runtime metrics flag determines whether or not the Effect runtime system + * will collect metrics about the Effect runtime. Use of this flag will have a + * very small negative impact on performance, but generates very helpful + * operational insight into running Effect applications that can be exported to + * Prometheus or other tools via Effect Metrics. + * + * @since 2.0.0 + * @category constructors + */ +export declare const RuntimeMetrics: RuntimeFlag; +/** + * The wind down flag determines whether the Effect runtime system will execute + * effects in wind-down mode. In wind-down mode, even if interruption is + * enabled and a fiber has been interrupted, the fiber will continue its + * execution uninterrupted. + * + * @since 2.0.0 + * @category constructors + */ +export declare const WindDown: RuntimeFlag; +/** + * The cooperative yielding flag determines whether the Effect runtime will + * yield to another fiber. + * + * @since 2.0.0 + * @category constructors + */ +export declare const CooperativeYielding: RuntimeFlag; +/** + * Returns `true` if the `CooperativeYielding` `RuntimeFlag` is enabled, `false` + * otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const cooperativeYielding: (self: RuntimeFlags) => boolean; +/** + * Creates a `RuntimeFlagsPatch` which describes the difference between `self` + * and `that`. + * + * @since 2.0.0 + * @category diffing + */ +export declare const diff: { + /** + * Creates a `RuntimeFlagsPatch` which describes the difference between `self` + * and `that`. + * + * @since 2.0.0 + * @category diffing + */ + (that: RuntimeFlags): (self: RuntimeFlags) => RuntimeFlagsPatch.RuntimeFlagsPatch; + /** + * Creates a `RuntimeFlagsPatch` which describes the difference between `self` + * and `that`. + * + * @since 2.0.0 + * @category diffing + */ + (self: RuntimeFlags, that: RuntimeFlags): RuntimeFlagsPatch.RuntimeFlagsPatch; +}; +/** + * Constructs a differ that knows how to diff `RuntimeFlags` values. + * + * @since 2.0.0 + * @category utils + */ +export declare const differ: Differ.Differ; +/** + * Disables the specified `RuntimeFlag`. + * + * @since 2.0.0 + * @category utils + */ +export declare const disable: { + /** + * Disables the specified `RuntimeFlag`. + * + * @since 2.0.0 + * @category utils + */ + (flag: RuntimeFlag): (self: RuntimeFlags) => RuntimeFlags; + /** + * Disables the specified `RuntimeFlag`. + * + * @since 2.0.0 + * @category utils + */ + (self: RuntimeFlags, flag: RuntimeFlag): RuntimeFlags; +}; +/** + * Disables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`. + * + * @since 2.0.0 + * @category utils + */ +export declare const disableAll: { + /** + * Disables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`. + * + * @since 2.0.0 + * @category utils + */ + (flags: RuntimeFlags): (self: RuntimeFlags) => RuntimeFlags; + /** + * Disables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`. + * + * @since 2.0.0 + * @category utils + */ + (self: RuntimeFlags, flags: RuntimeFlags): RuntimeFlags; +}; +/** + * @since 2.0.0 + * @category context + */ +export declare const disableCooperativeYielding: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const disableInterruption: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const disableOpSupervision: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const disableRuntimeMetrics: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const disableWindDown: Layer.Layer; +/** + * Enables the specified `RuntimeFlag`. + * + * @since 2.0.0 + * @category utils + */ +export declare const enable: { + /** + * Enables the specified `RuntimeFlag`. + * + * @since 2.0.0 + * @category utils + */ + (flag: RuntimeFlag): (self: RuntimeFlags) => RuntimeFlags; + /** + * Enables the specified `RuntimeFlag`. + * + * @since 2.0.0 + * @category utils + */ + (self: RuntimeFlags, flag: RuntimeFlag): RuntimeFlags; +}; +/** + * Enables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`. + * + * @since 2.0.0 + * @category utils + */ +export declare const enableAll: { + /** + * Enables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`. + * + * @since 2.0.0 + * @category utils + */ + (flags: RuntimeFlags): (self: RuntimeFlags) => RuntimeFlags; + /** + * Enables all of the `RuntimeFlag`s in the specified set of `RuntimeFlags`. + * + * @since 2.0.0 + * @category utils + */ + (self: RuntimeFlags, flags: RuntimeFlags): RuntimeFlags; +}; +/** + * @since 2.0.0 + * @category context + */ +export declare const enableCooperativeYielding: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const enableInterruption: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const enableOpSupervision: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const enableRuntimeMetrics: Layer.Layer; +/** + * @since 2.0.0 + * @category context + */ +export declare const enableWindDown: Layer.Layer; +/** + * Returns true only if the `Interruption` flag is **enabled** and the + * `WindDown` flag is **disabled**. + * + * A fiber is said to be interruptible if interruption is enabled and the fiber + * is not in its wind-down phase, in which it takes care of cleanup activities + * related to fiber shutdown. + * + * @since 2.0.0 + * @category getters + */ +export declare const interruptible: (self: RuntimeFlags) => boolean; +/** + * Returns `true` if the `Interruption` `RuntimeFlag` is enabled, `false` + * otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const interruption: (self: RuntimeFlags) => boolean; +/** + * Returns `true` if the specified `RuntimeFlag` is enabled, `false` otherwise. + * + * @since 2.0.0 + * @category elements + */ +export declare const isEnabled: { + /** + * Returns `true` if the specified `RuntimeFlag` is enabled, `false` otherwise. + * + * @since 2.0.0 + * @category elements + */ + (flag: RuntimeFlag): (self: RuntimeFlags) => boolean; + /** + * Returns `true` if the specified `RuntimeFlag` is enabled, `false` otherwise. + * + * @since 2.0.0 + * @category elements + */ + (self: RuntimeFlags, flag: RuntimeFlag): boolean; +}; +/** + * Returns `true` if the specified `RuntimeFlag` is disabled, `false` otherwise. + * + * @since 2.0.0 + * @category elements + */ +export declare const isDisabled: { + /** + * Returns `true` if the specified `RuntimeFlag` is disabled, `false` otherwise. + * + * @since 2.0.0 + * @category elements + */ + (flag: RuntimeFlag): (self: RuntimeFlags) => boolean; + /** + * Returns `true` if the specified `RuntimeFlag` is disabled, `false` otherwise. + * + * @since 2.0.0 + * @category elements + */ + (self: RuntimeFlags, flag: RuntimeFlag): boolean; +}; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (...flags: ReadonlyArray) => RuntimeFlags; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const none: RuntimeFlags; +/** + * Returns `true` if the `OpSupervision` `RuntimeFlag` is enabled, `false` + * otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const opSupervision: (self: RuntimeFlags) => boolean; +/** + * Patches a set of `RuntimeFlag`s with a `RuntimeFlagsPatch`, returning the + * patched set of `RuntimeFlag`s. + * + * @since 2.0.0 + * @category utils + */ +export declare const patch: { + /** + * Patches a set of `RuntimeFlag`s with a `RuntimeFlagsPatch`, returning the + * patched set of `RuntimeFlag`s. + * + * @since 2.0.0 + * @category utils + */ + (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): (self: RuntimeFlags) => RuntimeFlags; + /** + * Patches a set of `RuntimeFlag`s with a `RuntimeFlagsPatch`, returning the + * patched set of `RuntimeFlag`s. + * + * @since 2.0.0 + * @category utils + */ + (self: RuntimeFlags, patch: RuntimeFlagsPatch.RuntimeFlagsPatch): RuntimeFlags; +}; +/** + * Converts the provided `RuntimeFlags` into a `string`. + * + * @category conversions + * @since 2.0.0 + */ +export declare const render: (self: RuntimeFlags) => string; +/** + * Returns `true` if the `RuntimeMetrics` `RuntimeFlag` is enabled, `false` + * otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const runtimeMetrics: (self: RuntimeFlags) => boolean; +/** + * Converts the provided `RuntimeFlags` into a `ReadonlySet`. + * + * @category conversions + * @since 2.0.0 + */ +export declare const toSet: (self: RuntimeFlags) => ReadonlySet; +/** + * Returns `true` if the `WindDown` `RuntimeFlag` is enabled, `false` + * otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const windDown: (self: RuntimeFlags) => boolean; +//# sourceMappingURL=RuntimeFlags.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/RuntimeFlags.d.ts.map b/backend/node_modules/effect/dist/dts/RuntimeFlags.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..ef74b7f1777b1000ba45bf231ee24a17b398399a --- /dev/null +++ b/backend/node_modules/effect/dist/dts/RuntimeFlags.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"RuntimeFlags.d.ts","sourceRoot":"","sources":["../../src/RuntimeFlags.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/STM.d.ts b/backend/node_modules/effect/dist/dts/STM.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f7970dd045315de3d552f4820a765c92e6185d60 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/STM.d.ts @@ -0,0 +1,2645 @@ +/** + * @since 2.0.0 + */ +import * as Cause from "./Cause.js"; +import type * as Context from "./Context.js"; +import type * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type * as FiberId from "./FiberId.js"; +import type { LazyArg } from "./Function.js"; +import type { TypeLambda } from "./HKT.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate, Refinement } from "./Predicate.js"; +import type { Covariant, MergeRecord, NoExcessProperties, NoInfer } from "./Types.js"; +import type * as Unify from "./Unify.js"; +import type { YieldWrap } from "./Utils.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const STMTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type STMTypeId = typeof STMTypeId; +/** + * `STM` represents an effect that can be performed transactionally, + * resulting in a failure `E` or a value `A` that may require an environment + * `R` to execute. + * + * Software Transactional Memory is a technique which allows composition of + * arbitrary atomic operations. It is the software analog of transactions in + * database systems. + * + * The API is lifted directly from the Haskell package Control.Concurrent.STM + * although the implementation does not resemble the Haskell one at all. + * + * See http://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM.html + * + * STM in Haskell was introduced in: + * + * Composable memory transactions, by Tim Harris, Simon Marlow, Simon Peyton + * Jones, and Maurice Herlihy, in ACM Conference on Principles and Practice of + * Parallel Programming 2005. + * + * See https://www.microsoft.com/en-us/research/publication/composable-memory-transactions/ + * + * See also: + * Lock Free Data Structures using STMs in Haskell, by Anthony Discolo, Tim + * Harris, Simon Marlow, Simon Peyton Jones, Satnam Singh) FLOPS 2006: Eighth + * International Symposium on Functional and Logic Programming, Fuji Susono, + * JAPAN, April 2006 + * + * https://www.microsoft.com/en-us/research/publication/lock-free-data-structures-using-stms-in-haskell/ + * + * The implemtation is based on the ZIO STM module, while JS environments have + * no race conditions from multiple threads STM provides greater benefits for + * synchronization of Fibers and transactional data-types can be quite useful. + * + * @since 2.0.0 + * @category models + */ +export interface STM extends Effect.Effect, STM.Variance, Pipeable { + [Unify.typeSymbol]?: unknown; + [Unify.unifySymbol]?: STMUnify; + [Unify.ignoreSymbol]?: STMUnifyIgnore; + [Symbol.iterator](): Effect.EffectGenerator>; +} +/** + * @since 2.0.0 + * @category models + */ +export interface STMUnify extends Effect.EffectUnify { + STM?: () => A[Unify.typeSymbol] extends STM | infer _ ? STM : never; +} +/** + * @category models + * @since 2.0.0 + */ +export interface STMUnifyIgnore extends Effect.EffectUnifyIgnore { + Effect?: true; +} +/** + * @category type lambdas + * @since 2.0.0 + */ +export interface STMTypeLambda extends TypeLambda { + readonly type: STM; +} +/** + * @since 2.0.0 + * @category models + */ +declare module "./Context.js" { + interface Tag extends STM { + } + interface Reference extends STM { + } +} +/** + * @since 2.0.0 + * @category models + */ +declare module "./Either.js" { + interface Left extends STM { + readonly _tag: "Left"; + } + interface Right extends STM { + readonly _tag: "Right"; + } +} +/** + * @since 2.0.0 + * @category models + */ +declare module "./Option.js" { + interface None extends STM { + readonly _tag: "None"; + } + interface Some extends STM { + readonly _tag: "Some"; + } +} +/** + * @since 2.0.0 + */ +export declare namespace STM { + /** + * @since 2.0.0 + * @category models + */ + interface Variance { + readonly [STMTypeId]: { + readonly _A: Covariant; + readonly _E: Covariant; + readonly _R: Covariant; + }; + } +} +/** + * Returns `true` if the provided value is an `STM`, `false` otherwise. + * + * @since 2.0.0 + * @category refinements + */ +export declare const isSTM: (u: unknown) => u is STM; +/** + * Treats the specified `acquire` transaction as the acquisition of a + * resource. The `acquire` transaction will be executed interruptibly. If it + * is a success and is committed the specified `release` workflow will be + * executed uninterruptibly as soon as the `use` workflow completes execution. + * + * @since 2.0.0 + * @category constructors + */ +export declare const acquireUseRelease: { + /** + * Treats the specified `acquire` transaction as the acquisition of a + * resource. The `acquire` transaction will be executed interruptibly. If it + * is a success and is committed the specified `release` workflow will be + * executed uninterruptibly as soon as the `use` workflow completes execution. + * + * @since 2.0.0 + * @category constructors + */ + (use: (resource: A) => STM, release: (resource: A) => STM): (acquire: STM) => Effect.Effect; + /** + * Treats the specified `acquire` transaction as the acquisition of a + * resource. The `acquire` transaction will be executed interruptibly. If it + * is a success and is committed the specified `release` workflow will be + * executed uninterruptibly as soon as the `use` workflow completes execution. + * + * @since 2.0.0 + * @category constructors + */ + (acquire: STM, use: (resource: A) => STM, release: (resource: A) => STM): Effect.Effect; +}; +/** + * @since 2.0.0 + * @category utils + */ +export declare namespace All { + type STMAny = STM; + type ReturnTuple>, Discard extends boolean> = STM] ? A : never; + }, T[number] extends never ? never : [T[number]] extends [{ + [STMTypeId]: { + _E: (_: never) => infer E; + }; + }] ? E : never, T[number] extends never ? never : [T[number]] extends [{ + [STMTypeId]: { + _R: (_: never) => infer R; + }; + }] ? R : never> extends infer X ? X : never; + type ReturnIterable, Discard extends boolean> = [T] extends [ + Iterable> + ] ? STM, E, R> : never; + type ReturnObject, Discard extends boolean> = STM] ? A : never; + }, keyof T extends never ? never : [T[keyof T]] extends [{ + [STMTypeId]: { + _E: (_: never) => infer E; + }; + }] ? E : never, keyof T extends never ? never : [T[keyof T]] extends [{ + [STMTypeId]: { + _R: (_: never) => infer R; + }; + }] ? R : never>; + /** + * @since 2.0.0 + * @category utils + */ + type Options = { + readonly discard?: boolean | undefined; + }; + type IsDiscard = [Extract] extends [never] ? false : true; + type Narrow = (A extends [] ? [] : never) | A; + /** + * @since 2.0.0 + * @category utils + */ + interface Signature { + | Iterable | Record, O extends NoExcessProperties>(arg: Narrow, options?: O): [Arg] extends [ReadonlyArray] ? ReturnTuple> : [Arg] extends [Iterable] ? ReturnIterable> : [Arg] extends [Record] ? ReturnObject> : never; + } +} +/** + * Runs all the provided transactional effects in sequence respecting the + * structure provided in input. + * + * Supports multiple arguments, a single argument tuple / array or record / + * struct. + * + * @since 2.0.0 + * @category constructors + */ +export declare const all: All.Signature; +/** + * Maps the success value of this effect to the specified constant value. + * + * @since 2.0.0 + * @category mapping + */ +export declare const as: { + /** + * Maps the success value of this effect to the specified constant value. + * + * @since 2.0.0 + * @category mapping + */ + (value: A2): (self: STM) => STM; + /** + * Maps the success value of this effect to the specified constant value. + * + * @since 2.0.0 + * @category mapping + */ + (self: STM, value: A2): STM; +}; +/** + * Maps the success value of this effect to an optional value. + * + * @since 2.0.0 + * @category mapping + */ +export declare const asSome: (self: STM) => STM, E, R>; +/** + * Maps the error value of this effect to an optional value. + * + * @since 2.0.0 + * @category mapping + */ +export declare const asSomeError: (self: STM) => STM, R>; +/** + * This function maps the success value of an `STM` to `void`. If the original + * `STM` succeeds, the returned `STM` will also succeed. If the original `STM` + * fails, the returned `STM` will fail with the same error. + * + * @since 2.0.0 + * @category mapping + */ +export declare const asVoid: (self: STM) => STM; +/** + * Creates an `STM` value from a partial (but pure) function. + * + * @since 2.0.0 + * @category constructors + */ +export declare const attempt: (evaluate: LazyArg) => STM; +/** + * Recovers from all errors. + * + * @since 2.0.0 + * @category error handling + */ +export declare const catchAll: { + /** + * Recovers from all errors. + * + * @since 2.0.0 + * @category error handling + */ + (f: (e: E) => STM): (self: STM) => STM; + /** + * Recovers from all errors. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, f: (e: E) => STM): STM; +}; +/** + * Recovers from some or all of the error cases. + * + * @since 2.0.0 + * @category error handling + */ +export declare const catchSome: { + /** + * Recovers from some or all of the error cases. + * + * @since 2.0.0 + * @category error handling + */ + (pf: (error: E) => Option.Option>): (self: STM) => STM; + /** + * Recovers from some or all of the error cases. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, pf: (error: E) => Option.Option>): STM; +}; +/** + * Recovers from the specified tagged error. + * + * @since 2.0.0 + * @category error handling + */ +export declare const catchTag: { + /** + * Recovers from the specified tagged error. + * + * @since 2.0.0 + * @category error handling + */ + (k: K, f: (e: Extract) => STM): (self: STM) => STM, R1 | R>; + /** + * Recovers from the specified tagged error. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, k: K, f: (e: Extract) => STM): STM, R | R1>; +}; +/** + * Recovers from multiple tagged errors. + * + * @since 2.0.0 + * @category error handling + */ +export declare const catchTags: { + /** + * Recovers from multiple tagged errors. + * + * @since 2.0.0 + * @category error handling + */ + ) => STM); + }>(cases: Cases): (self: STM) => STM) => STM ? A : never; + }[keyof Cases], Exclude | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => STM ? E : never; + }[keyof Cases], R | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => STM ? R : never; + }[keyof Cases]>; + /** + * Recovers from multiple tagged errors. + * + * @since 2.0.0 + * @category error handling + */ + ) => STM); + }>(self: STM, cases: Cases): STM) => STM ? A : never; + }[keyof Cases], Exclude | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => STM ? E : never; + }[keyof Cases], R | { + [K in keyof Cases]: Cases[K] extends (...args: Array) => STM ? R : never; + }[keyof Cases]>; +}; +/** + * Checks the condition, and if it's true, returns unit, otherwise, retries. + * + * @since 2.0.0 + * @category constructors + */ +export declare const check: (predicate: LazyArg) => STM; +/** + * Simultaneously filters and maps the value produced by this effect. + * + * @since 2.0.0 + * @category mutations + */ +export declare const collect: { + /** + * Simultaneously filters and maps the value produced by this effect. + * + * @since 2.0.0 + * @category mutations + */ + (pf: (a: A) => Option.Option): (self: STM) => STM; + /** + * Simultaneously filters and maps the value produced by this effect. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, pf: (a: A) => Option.Option): STM; +}; +/** + * Simultaneously filters and maps the value produced by this effect. + * + * @since 2.0.0 + * @category mutations + */ +export declare const collectSTM: { + /** + * Simultaneously filters and maps the value produced by this effect. + * + * @since 2.0.0 + * @category mutations + */ + (pf: (a: A) => Option.Option>): (self: STM) => STM; + /** + * Simultaneously filters and maps the value produced by this effect. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, pf: (a: A) => Option.Option>): STM; +}; +/** + * Commits this transaction atomically. + * + * @since 2.0.0 + * @category destructors + */ +export declare const commit: (self: STM) => Effect.Effect; +/** + * Commits this transaction atomically, regardless of whether the transaction + * is a success or a failure. + * + * @since 2.0.0 + * @category destructors + */ +export declare const commitEither: (self: STM) => Effect.Effect; +/** + * Similar to Either.cond, evaluate the predicate, return the given A as + * success if predicate returns true, and the given E as error otherwise + * + * @since 2.0.0 + * @category constructors + */ +export declare const cond: (predicate: LazyArg, error: LazyArg, result: LazyArg) => STM; +/** + * Retrieves the environment inside an stm. + * + * @since 2.0.0 + * @category constructors + */ +export declare const context: () => STM, never, R>; +/** + * Accesses the environment of the transaction to perform a transaction. + * + * @since 2.0.0 + * @category constructors + */ +export declare const contextWith: (f: (environment: Context.Context) => R) => STM; +/** + * Accesses the environment of the transaction to perform a transaction. + * + * @since 2.0.0 + * @category constructors + */ +export declare const contextWithSTM: (f: (environment: Context.Context) => STM) => STM; +/** + * Transforms the environment being provided to this effect with the specified + * function. + * + * @since 2.0.0 + * @category context + */ +export declare const mapInputContext: { + /** + * Transforms the environment being provided to this effect with the specified + * function. + * + * @since 2.0.0 + * @category context + */ + (f: (context: Context.Context) => Context.Context): (self: STM) => STM; + /** + * Transforms the environment being provided to this effect with the specified + * function. + * + * @since 2.0.0 + * @category context + */ + (self: STM, f: (context: Context.Context) => Context.Context): STM; +}; +/** + * Fails the transactional effect with the specified defect. + * + * @since 2.0.0 + * @category constructors + */ +export declare const die: (defect: unknown) => STM; +/** + * Kills the fiber running the effect with a `Cause.RuntimeException` that + * contains the specified message. + * + * @since 2.0.0 + * @category constructors + */ +export declare const dieMessage: (message: string) => STM; +/** + * Fails the transactional effect with the specified lazily evaluated defect. + * + * @since 2.0.0 + * @category constructors + */ +export declare const dieSync: (evaluate: LazyArg) => STM; +/** + * Converts the failure channel into an `Either`. + * + * @since 2.0.0 + * @category mutations + */ +export declare const either: (self: STM) => STM, never, R>; +/** + * Executes the specified finalization transaction whether or not this effect + * succeeds. Note that as with all STM transactions, if the full transaction + * fails, everything will be rolled back. + * + * @since 2.0.0 + * @category finalization + */ +export declare const ensuring: { + /** + * Executes the specified finalization transaction whether or not this effect + * succeeds. Note that as with all STM transactions, if the full transaction + * fails, everything will be rolled back. + * + * @since 2.0.0 + * @category finalization + */ + (finalizer: STM): (self: STM) => STM; + /** + * Executes the specified finalization transaction whether or not this effect + * succeeds. Note that as with all STM transactions, if the full transaction + * fails, everything will be rolled back. + * + * @since 2.0.0 + * @category finalization + */ + (self: STM, finalizer: STM): STM; +}; +/** + * Returns an effect that ignores errors and runs repeatedly until it + * eventually succeeds. + * + * @since 2.0.0 + * @category mutations + */ +export declare const eventually: (self: STM) => STM; +/** + * Determines whether all elements of the `Iterable` satisfy the effectual + * predicate. + * + * @since 2.0.0 + * @category constructors + */ +export declare const every: { + /** + * Determines whether all elements of the `Iterable` satisfy the effectual + * predicate. + * + * @since 2.0.0 + * @category constructors + */ + (predicate: (a: NoInfer) => STM): (iterable: Iterable) => STM; + /** + * Determines whether all elements of the `Iterable` satisfy the effectual + * predicate. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable, predicate: (a: A) => STM): STM; +}; +/** + * Determines whether any element of the `Iterable[A]` satisfies the effectual + * predicate `f`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const exists: { + /** + * Determines whether any element of the `Iterable[A]` satisfies the effectual + * predicate `f`. + * + * @since 2.0.0 + * @category constructors + */ + (predicate: (a: NoInfer) => STM): (iterable: Iterable) => STM; + /** + * Determines whether any element of the `Iterable[A]` satisfies the effectual + * predicate `f`. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable, predicate: (a: A) => STM): STM; +}; +/** + * Fails the transactional effect with the specified error. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fail: (error: E) => STM; +/** + * Fails the transactional effect with the specified lazily evaluated error. + * + * @since 2.0.0 + * @category constructors + */ +export declare const failSync: (evaluate: LazyArg) => STM; +/** + * Returns the fiber id of the fiber committing the transaction. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fiberId: STM; +/** + * Filters the collection using the specified effectual predicate. + * + * @since 2.0.0 + * @category constructors + */ +export declare const filter: { + /** + * Filters the collection using the specified effectual predicate. + * + * @since 2.0.0 + * @category constructors + */ + (predicate: (a: NoInfer) => STM): (iterable: Iterable) => STM, E, R>; + /** + * Filters the collection using the specified effectual predicate. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable, predicate: (a: A) => STM): STM, E, R>; +}; +/** + * Filters the collection using the specified effectual predicate, removing + * all elements that satisfy the predicate. + * + * @since 2.0.0 + * @category constructors + */ +export declare const filterNot: { + /** + * Filters the collection using the specified effectual predicate, removing + * all elements that satisfy the predicate. + * + * @since 2.0.0 + * @category constructors + */ + (predicate: (a: NoInfer) => STM): (iterable: Iterable) => STM, E, R>; + /** + * Filters the collection using the specified effectual predicate, removing + * all elements that satisfy the predicate. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable, predicate: (a: A) => STM): STM, E, R>; +}; +/** + * Dies with specified defect if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterOrDie: { + /** + * Dies with specified defect if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (refinement: Refinement, B>, defect: LazyArg): (self: STM) => STM; + /** + * Dies with specified defect if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (predicate: Predicate>, defect: LazyArg): (self: STM) => STM; + /** + * Dies with specified defect if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, refinement: Refinement, defect: LazyArg): STM; + /** + * Dies with specified defect if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, predicate: Predicate, defect: LazyArg): STM; +}; +/** + * Dies with a `Cause.RuntimeException` having the specified message if the + * predicate fails. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterOrDieMessage: { + /** + * Dies with a `Cause.RuntimeException` having the specified message if the + * predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (refinement: Refinement, B>, message: string): (self: STM) => STM; + /** + * Dies with a `Cause.RuntimeException` having the specified message if the + * predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (predicate: Predicate>, message: string): (self: STM) => STM; + /** + * Dies with a `Cause.RuntimeException` having the specified message if the + * predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, refinement: Refinement, message: string): STM; + /** + * Dies with a `Cause.RuntimeException` having the specified message if the + * predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, predicate: Predicate, message: string): STM; +}; +/** + * Supplies `orElse` if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterOrElse: { + /** + * Supplies `orElse` if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (refinement: Refinement, B>, orElse: (a: NoInfer) => STM): (self: STM) => STM; + /** + * Supplies `orElse` if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (predicate: Predicate>, orElse: (a: NoInfer) => STM): (self: STM) => STM; + /** + * Supplies `orElse` if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, refinement: Refinement, orElse: (a: A) => STM): STM; + /** + * Supplies `orElse` if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, predicate: Predicate, orElse: (a: A) => STM): STM; +}; +/** + * Fails with the specified error if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ +export declare const filterOrFail: { + /** + * Fails with the specified error if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (refinement: Refinement, B>, orFailWith: (a: NoInfer) => E2): (self: STM) => STM; + /** + * Fails with the specified error if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (predicate: Predicate>, orFailWith: (a: NoInfer) => E2): (self: STM) => STM; + /** + * Fails with the specified error if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, refinement: Refinement, orFailWith: (a: A) => E2): STM; + /** + * Fails with the specified error if the predicate fails. + * + * @since 2.0.0 + * @category filtering + */ + (self: STM, predicate: Predicate, orFailWith: (a: A) => E2): STM; +}; +/** + * Feeds the value produced by this effect to the specified function, and then + * runs the returned effect as well to produce its results. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatMap: { + /** + * Feeds the value produced by this effect to the specified function, and then + * runs the returned effect as well to produce its results. + * + * @since 2.0.0 + * @category sequencing + */ + (f: (a: A) => STM): (self: STM) => STM; + /** + * Feeds the value produced by this effect to the specified function, and then + * runs the returned effect as well to produce its results. + * + * @since 2.0.0 + * @category sequencing + */ + (self: STM, f: (a: A) => STM): STM; +}; +/** + * Flattens out a nested `STM` effect. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const flatten: (self: STM, E, R>) => STM; +/** + * Flips the success and failure channels of this transactional effect. This + * allows you to use all methods on the error channel, possibly before + * flipping back. + * + * @since 2.0.0 + * @category mutations + */ +export declare const flip: (self: STM) => STM; +/** + * Swaps the error/value parameters, applies the function `f` and flips the + * parameters back + * + * @since 2.0.0 + * @category mutations + */ +export declare const flipWith: { + /** + * Swaps the error/value parameters, applies the function `f` and flips the + * parameters back + * + * @since 2.0.0 + * @category mutations + */ + (f: (stm: STM) => STM): (self: STM) => STM; + /** + * Swaps the error/value parameters, applies the function `f` and flips the + * parameters back + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, f: (stm: STM) => STM): STM; +}; +/** + * Folds over the `STM` effect, handling both failure and success, but not + * retry. + * + * @since 2.0.0 + * @category folding + */ +export declare const match: { + /** + * Folds over the `STM` effect, handling both failure and success, but not + * retry. + * + * @since 2.0.0 + * @category folding + */ + (options: { + readonly onFailure: (error: E) => A2; + readonly onSuccess: (value: A) => A3; + }): (self: STM) => STM; + /** + * Folds over the `STM` effect, handling both failure and success, but not + * retry. + * + * @since 2.0.0 + * @category folding + */ + (self: STM, options: { + readonly onFailure: (error: E) => A2; + readonly onSuccess: (value: A) => A3; + }): STM; +}; +/** + * Effectfully folds over the `STM` effect, handling both failure and success. + * + * @since 2.0.0 + * @category folding + */ +export declare const matchSTM: { + /** + * Effectfully folds over the `STM` effect, handling both failure and success. + * + * @since 2.0.0 + * @category folding + */ + (options: { + readonly onFailure: (e: E) => STM; + readonly onSuccess: (a: A) => STM; + }): (self: STM) => STM; + /** + * Effectfully folds over the `STM` effect, handling both failure and success. + * + * @since 2.0.0 + * @category folding + */ + (self: STM, options: { + readonly onFailure: (e: E) => STM; + readonly onSuccess: (a: A) => STM; + }): STM; +}; +/** + * Applies the function `f` to each element of the `Iterable` and returns + * a transactional effect that produces a new `Chunk`. + * + * @since 2.0.0 + * @category traversing + */ +export declare const forEach: { + /** + * Applies the function `f` to each element of the `Iterable` and returns + * a transactional effect that produces a new `Chunk`. + * + * @since 2.0.0 + * @category traversing + */ + (f: (a: A) => STM, options?: { + readonly discard?: false | undefined; + } | undefined): (elements: Iterable) => STM, E, R>; + /** + * Applies the function `f` to each element of the `Iterable` and returns + * a transactional effect that produces a new `Chunk`. + * + * @since 2.0.0 + * @category traversing + */ + (f: (a: A) => STM, options: { + readonly discard: true; + }): (elements: Iterable) => STM; + /** + * Applies the function `f` to each element of the `Iterable` and returns + * a transactional effect that produces a new `Chunk`. + * + * @since 2.0.0 + * @category traversing + */ + (elements: Iterable, f: (a: A) => STM, options?: { + readonly discard?: false | undefined; + } | undefined): STM, E, R>; + /** + * Applies the function `f` to each element of the `Iterable` and returns + * a transactional effect that produces a new `Chunk`. + * + * @since 2.0.0 + * @category traversing + */ + (elements: Iterable, f: (a: A) => STM, options: { + readonly discard: true; + }): STM; +}; +/** + * Lifts an `Either` into a `STM`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromEither: (either: Either.Either) => STM; +/** + * Lifts an `Option` into a `STM`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromOption: (option: Option.Option) => STM>; +/** + * @since 2.0.0 + * @category models + */ +export interface Adapter { + (self: STM): STM; + (a: A, ab: (a: A) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: F) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (g: H) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => STM<_A, _E, _R>): STM<_A, _E, _R>; + (a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (s: T) => STM<_A, _E, _R>): STM<_A, _E, _R>; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const gen: >, AEff>(...args: [ + self: Self, + body: (this: Self, resume: Adapter) => Generator +] | [body: (resume: Adapter) => Generator]) => STM>] ? E : never, [ + Eff +] extends [never] ? never : [Eff] extends [YieldWrap>] ? R : never>; +/** + * Returns a successful effect with the head of the list if the list is + * non-empty or fails with the error `None` if the list is empty. + * + * @since 2.0.0 + * @category getters + */ +export declare const head: (self: STM, E, R>) => STM, R>; +declare const if_: { + (options: { + readonly onTrue: STM; + readonly onFalse: STM; /** + * Flattens out a nested `STM` effect. + * + * @since 2.0.0 + * @category sequencing + */ + }): (self: boolean | STM) => STM; + (self: boolean, options: { + readonly onTrue: STM; + readonly onFalse: STM; + }): STM; + (self: STM, options: { + readonly onTrue: STM; + readonly onFalse: STM; + }): STM; +}; +export { +/** + * Runs `onTrue` if the result of `b` is `true` and `onFalse` otherwise. + * + * @since 2.0.0 + * @category mutations + */ +if_ as if }; +/** + * Returns a new effect that ignores the success or failure of this effect. + * + * @since 2.0.0 + * @category mutations + */ +export declare const ignore: (self: STM) => STM; +/** + * Interrupts the fiber running the effect. + * + * @since 2.0.0 + * @category constructors + */ +export declare const interrupt: STM; +/** + * Interrupts the fiber running the effect with the specified `FiberId`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const interruptAs: (fiberId: FiberId.FiberId) => STM; +/** + * Returns whether this transactional effect is a failure. + * + * @since 2.0.0 + * @category getters + */ +export declare const isFailure: (self: STM) => STM; +/** + * Returns whether this transactional effect is a success. + * + * @since 2.0.0 + * @category getters + */ +export declare const isSuccess: (self: STM) => STM; +/** + * Iterates with the specified transactional function. The moral equivalent + * of: + * + * ```ts skip-type-checking + * const s = initial + * + * while (cont(s)) { + * s = body(s) + * } + * + * return s + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const iterate: (initial: Z, options: { + readonly while: Predicate; + readonly body: (z: Z) => STM; +}) => STM; +/** + * Loops with the specified transactional function, collecting the results + * into a list. The moral equivalent of: + * + * ```ts skip-type-checking + * const as = [] + * let s = initial + * + * while (cont(s)) { + * as.push(body(s)) + * s = inc(s) + * } + * + * return as + * ``` + * + * @since 2.0.0 + * @category constructors + */ +export declare const loop: { + /** + * Loops with the specified transactional function, collecting the results + * into a list. The moral equivalent of: + * + * ```ts skip-type-checking + * const as = [] + * let s = initial + * + * while (cont(s)) { + * as.push(body(s)) + * s = inc(s) + * } + * + * return as + * ``` + * + * @since 2.0.0 + * @category constructors + */ + (initial: Z, options: { + readonly while: (z: Z) => boolean; + readonly step: (z: Z) => Z; + readonly body: (z: Z) => STM; + readonly discard?: false | undefined; + }): STM, E, R>; + /** + * Loops with the specified transactional function, collecting the results + * into a list. The moral equivalent of: + * + * ```ts skip-type-checking + * const as = [] + * let s = initial + * + * while (cont(s)) { + * as.push(body(s)) + * s = inc(s) + * } + * + * return as + * ``` + * + * @since 2.0.0 + * @category constructors + */ + (initial: Z, options: { + readonly while: (z: Z) => boolean; + readonly step: (z: Z) => Z; + readonly body: (z: Z) => STM; + readonly discard: true; + }): STM; +}; +/** + * Maps the value produced by the effect. + * + * @since 2.0.0 + * @category mapping + */ +export declare const map: { + /** + * Maps the value produced by the effect. + * + * @since 2.0.0 + * @category mapping + */ + (f: (a: A) => B): (self: STM) => STM; + /** + * Maps the value produced by the effect. + * + * @since 2.0.0 + * @category mapping + */ + (self: STM, f: (a: A) => B): STM; +}; +/** + * Maps the value produced by the effect with the specified function that may + * throw exceptions but is otherwise pure, translating any thrown exceptions + * into typed failed effects. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapAttempt: { + /** + * Maps the value produced by the effect with the specified function that may + * throw exceptions but is otherwise pure, translating any thrown exceptions + * into typed failed effects. + * + * @since 2.0.0 + * @category mapping + */ + (f: (a: A) => B): (self: STM) => STM; + /** + * Maps the value produced by the effect with the specified function that may + * throw exceptions but is otherwise pure, translating any thrown exceptions + * into typed failed effects. + * + * @since 2.0.0 + * @category mapping + */ + (self: STM, f: (a: A) => B): STM; +}; +/** + * Returns an `STM` effect whose failure and success channels have been mapped + * by the specified pair of functions, `f` and `g`. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapBoth: { + /** + * Returns an `STM` effect whose failure and success channels have been mapped + * by the specified pair of functions, `f` and `g`. + * + * @since 2.0.0 + * @category mapping + */ + (options: { + readonly onFailure: (error: E) => E2; + readonly onSuccess: (value: A) => A2; + }): (self: STM) => STM; + /** + * Returns an `STM` effect whose failure and success channels have been mapped + * by the specified pair of functions, `f` and `g`. + * + * @since 2.0.0 + * @category mapping + */ + (self: STM, options: { + readonly onFailure: (error: E) => E2; + readonly onSuccess: (value: A) => A2; + }): STM; +}; +/** + * Maps from one error type to another. + * + * @since 2.0.0 + * @category mapping + */ +export declare const mapError: { + /** + * Maps from one error type to another. + * + * @since 2.0.0 + * @category mapping + */ + (f: (error: E) => E2): (self: STM) => STM; + /** + * Maps from one error type to another. + * + * @since 2.0.0 + * @category mapping + */ + (self: STM, f: (error: E) => E2): STM; +}; +/** + * Returns a new effect where the error channel has been merged into the + * success channel to their common combined type. + * + * @since 2.0.0 + * @category mutations + */ +export declare const merge: (self: STM) => STM; +/** + * Merges an `Iterable` to a single `STM`, working sequentially. + * + * @since 2.0.0 + * @category constructors + */ +export declare const mergeAll: { + /** + * Merges an `Iterable` to a single `STM`, working sequentially. + * + * @since 2.0.0 + * @category constructors + */ + (zero: A2, f: (a2: A2, a: A) => A2): (iterable: Iterable>) => STM; + /** + * Merges an `Iterable` to a single `STM`, working sequentially. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable>, zero: A2, f: (a2: A2, a: A) => A2): STM; +}; +/** + * Returns a new effect where boolean value of this effect is negated. + * + * @since 2.0.0 + * @category mutations + */ +export declare const negate: (self: STM) => STM; +/** + * Requires the option produced by this value to be `None`. + * + * @since 2.0.0 + * @category mutations + */ +export declare const none: (self: STM, E, R>) => STM, R>; +/** + * Converts the failure channel into an `Option`. + * + * @since 2.0.0 + * @category mutations + */ +export declare const option: (self: STM) => STM, never, R>; +/** + * Translates `STM` effect failure into death of the fiber, making all + * failures unchecked and not a part of the type of the effect. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orDie: (self: STM) => STM; +/** + * Keeps none of the errors, and terminates the fiber running the `STM` effect + * with them, using the specified function to convert the `E` into a defect. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orDieWith: { + /** + * Keeps none of the errors, and terminates the fiber running the `STM` effect + * with them, using the specified function to convert the `E` into a defect. + * + * @since 2.0.0 + * @category error handling + */ + (f: (error: E) => unknown): (self: STM) => STM; + /** + * Keeps none of the errors, and terminates the fiber running the `STM` effect + * with them, using the specified function to convert the `E` into a defect. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, f: (error: E) => unknown): STM; +}; +/** + * Tries this effect first, and if it fails or retries, tries the other + * effect. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orElse: { + /** + * Tries this effect first, and if it fails or retries, tries the other + * effect. + * + * @since 2.0.0 + * @category error handling + */ + (that: LazyArg>): (self: STM) => STM; + /** + * Tries this effect first, and if it fails or retries, tries the other + * effect. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, that: LazyArg>): STM; +}; +/** + * Returns a transactional effect that will produce the value of this effect + * in left side, unless it fails or retries, in which case, it will produce + * the value of the specified effect in right side. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orElseEither: { + /** + * Returns a transactional effect that will produce the value of this effect + * in left side, unless it fails or retries, in which case, it will produce + * the value of the specified effect in right side. + * + * @since 2.0.0 + * @category error handling + */ + (that: LazyArg>): (self: STM) => STM, E2, R2 | R>; + /** + * Returns a transactional effect that will produce the value of this effect + * in left side, unless it fails or retries, in which case, it will produce + * the value of the specified effect in right side. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, that: LazyArg>): STM, E2, R | R2>; +}; +/** + * Tries this effect first, and if it fails or retries, fails with the + * specified error. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orElseFail: { + /** + * Tries this effect first, and if it fails or retries, fails with the + * specified error. + * + * @since 2.0.0 + * @category error handling + */ + (error: LazyArg): (self: STM) => STM; + /** + * Tries this effect first, and if it fails or retries, fails with the + * specified error. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, error: LazyArg): STM; +}; +/** + * Returns an effect that will produce the value of this effect, unless it + * fails with the `None` value, in which case it will produce the value of the + * specified effect. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orElseOptional: { + /** + * Returns an effect that will produce the value of this effect, unless it + * fails with the `None` value, in which case it will produce the value of the + * specified effect. + * + * @since 2.0.0 + * @category error handling + */ + (that: LazyArg, R2>>): (self: STM, R>) => STM, R2 | R>; + /** + * Returns an effect that will produce the value of this effect, unless it + * fails with the `None` value, in which case it will produce the value of the + * specified effect. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, R>, that: LazyArg, R2>>): STM, R | R2>; +}; +/** + * Tries this effect first, and if it fails or retries, succeeds with the + * specified value. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orElseSucceed: { + /** + * Tries this effect first, and if it fails or retries, succeeds with the + * specified value. + * + * @since 2.0.0 + * @category error handling + */ + (value: LazyArg): (self: STM) => STM; + /** + * Tries this effect first, and if it fails or retries, succeeds with the + * specified value. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, value: LazyArg): STM; +}; +/** + * Tries this effect first, and if it enters retry, then it tries the other + * effect. This is an equivalent of Haskell's orElse. + * + * @since 2.0.0 + * @category error handling + */ +export declare const orTry: { + /** + * Tries this effect first, and if it enters retry, then it tries the other + * effect. This is an equivalent of Haskell's orElse. + * + * @since 2.0.0 + * @category error handling + */ + (that: LazyArg>): (self: STM) => STM; + /** + * Tries this effect first, and if it enters retry, then it tries the other + * effect. This is an equivalent of Haskell's orElse. + * + * @since 2.0.0 + * @category error handling + */ + (self: STM, that: LazyArg>): STM; +}; +/** + * Feeds elements of type `A` to a function `f` that returns an effect. + * Collects all successes and failures in a tupled fashion. + * + * @since 2.0.0 + * @category traversing + */ +export declare const partition: { + /** + * Feeds elements of type `A` to a function `f` that returns an effect. + * Collects all successes and failures in a tupled fashion. + * + * @since 2.0.0 + * @category traversing + */ + (f: (a: A) => STM): (elements: Iterable) => STM<[excluded: Array, satisfying: Array], never, R>; + /** + * Feeds elements of type `A` to a function `f` that returns an effect. + * Collects all successes and failures in a tupled fashion. + * + * @since 2.0.0 + * @category traversing + */ + (elements: Iterable, f: (a: A) => STM): STM<[excluded: Array, satisfying: Array], never, R>; +}; +/** + * Provides the transaction its required environment, which eliminates its + * dependency on `R`. + * + * @since 2.0.0 + * @category context + */ +export declare const provideContext: { + /** + * Provides the transaction its required environment, which eliminates its + * dependency on `R`. + * + * @since 2.0.0 + * @category context + */ + (env: Context.Context): (self: STM) => STM; + /** + * Provides the transaction its required environment, which eliminates its + * dependency on `R`. + * + * @since 2.0.0 + * @category context + */ + (self: STM, env: Context.Context): STM; +}; +/** + * Splits the context into two parts, providing one part using the + * specified layer and leaving the remainder `R0`. + * + * @since 2.0.0 + * @category context + */ +export declare const provideSomeContext: { + /** + * Splits the context into two parts, providing one part using the + * specified layer and leaving the remainder `R0`. + * + * @since 2.0.0 + * @category context + */ + (context: Context.Context): (self: STM) => STM>; + /** + * Splits the context into two parts, providing one part using the + * specified layer and leaving the remainder `R0`. + * + * @since 2.0.0 + * @category context + */ + (self: STM, context: Context.Context): STM>; +}; +/** + * Provides the effect with the single service it requires. If the transactional + * effect requires more than one service use `provideEnvironment` instead. + * + * @since 2.0.0 + * @category context + */ +export declare const provideService: { + /** + * Provides the effect with the single service it requires. If the transactional + * effect requires more than one service use `provideEnvironment` instead. + * + * @since 2.0.0 + * @category context + */ + (tag: Context.Tag, resource: NoInfer): (self: STM) => STM>; + /** + * Provides the effect with the single service it requires. If the transactional + * effect requires more than one service use `provideEnvironment` instead. + * + * @since 2.0.0 + * @category context + */ + (self: STM, tag: Context.Tag, resource: NoInfer): STM>; +}; +/** + * Provides the effect with the single service it requires. If the transactional + * effect requires more than one service use `provideEnvironment` instead. + * + * @since 2.0.0 + * @category context + */ +export declare const provideServiceSTM: { + /** + * Provides the effect with the single service it requires. If the transactional + * effect requires more than one service use `provideEnvironment` instead. + * + * @since 2.0.0 + * @category context + */ + (tag: Context.Tag, stm: STM, E1, R1>): (self: STM) => STM>; + /** + * Provides the effect with the single service it requires. If the transactional + * effect requires more than one service use `provideEnvironment` instead. + * + * @since 2.0.0 + * @category context + */ + (self: STM, tag: Context.Tag, stm: STM, E1, R1>): STM>; +}; +/** + * Folds an `Iterable` using an effectual function f, working sequentially + * from left to right. + * + * @since 2.0.0 + * @category constructors + */ +export declare const reduce: { + /** + * Folds an `Iterable` using an effectual function f, working sequentially + * from left to right. + * + * @since 2.0.0 + * @category constructors + */ + (zero: S, f: (s: S, a: A) => STM): (iterable: Iterable) => STM; + /** + * Folds an `Iterable` using an effectual function f, working sequentially + * from left to right. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable, zero: S, f: (s: S, a: A) => STM): STM; +}; +/** + * Reduces an `Iterable` to a single `STM`, working sequentially. + * + * @since 2.0.0 + * @category constructors + */ +export declare const reduceAll: { + /** + * Reduces an `Iterable` to a single `STM`, working sequentially. + * + * @since 2.0.0 + * @category constructors + */ + (initial: STM, f: (x: A, y: A) => A): (iterable: Iterable>) => STM; + /** + * Reduces an `Iterable` to a single `STM`, working sequentially. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable>, initial: STM, f: (x: A, y: A) => A): STM; +}; +/** + * Folds an `Iterable` using an effectual function f, working sequentially + * from right to left. + * + * @since 2.0.0 + * @category constructors + */ +export declare const reduceRight: { + /** + * Folds an `Iterable` using an effectual function f, working sequentially + * from right to left. + * + * @since 2.0.0 + * @category constructors + */ + (zero: S, f: (s: S, a: A) => STM): (iterable: Iterable) => STM; + /** + * Folds an `Iterable` using an effectual function f, working sequentially + * from right to left. + * + * @since 2.0.0 + * @category constructors + */ + (iterable: Iterable, zero: S, f: (s: S, a: A) => STM): STM; +}; +/** + * Keeps some of the errors, and terminates the fiber with the rest. + * + * @since 2.0.0 + * @category mutations + */ +export declare const refineOrDie: { + /** + * Keeps some of the errors, and terminates the fiber with the rest. + * + * @since 2.0.0 + * @category mutations + */ + (pf: (error: E) => Option.Option): (self: STM) => STM; + /** + * Keeps some of the errors, and terminates the fiber with the rest. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, pf: (error: E) => Option.Option): STM; +}; +/** + * Keeps some of the errors, and terminates the fiber with the rest, using the + * specified function to convert the `E` into a `Throwable`. + * + * @since 2.0.0 + * @category mutations + */ +export declare const refineOrDieWith: { + /** + * Keeps some of the errors, and terminates the fiber with the rest, using the + * specified function to convert the `E` into a `Throwable`. + * + * @since 2.0.0 + * @category mutations + */ + (pf: (error: E) => Option.Option, f: (error: E) => unknown): (self: STM) => STM; + /** + * Keeps some of the errors, and terminates the fiber with the rest, using the + * specified function to convert the `E` into a `Throwable`. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, pf: (error: E) => Option.Option, f: (error: E) => unknown): STM; +}; +/** + * Fail with the returned value if the `PartialFunction` matches, otherwise + * continue with our held value. + * + * @since 2.0.0 + * @category mutations + */ +export declare const reject: { + /** + * Fail with the returned value if the `PartialFunction` matches, otherwise + * continue with our held value. + * + * @since 2.0.0 + * @category mutations + */ + (pf: (a: A) => Option.Option): (self: STM) => STM; + /** + * Fail with the returned value if the `PartialFunction` matches, otherwise + * continue with our held value. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, pf: (a: A) => Option.Option): STM; +}; +/** + * Continue with the returned computation if the specified partial function + * matches, translating the successful match into a failure, otherwise continue + * with our held value. + * + * @since 2.0.0 + * @category mutations + */ +export declare const rejectSTM: { + /** + * Continue with the returned computation if the specified partial function + * matches, translating the successful match into a failure, otherwise continue + * with our held value. + * + * @since 2.0.0 + * @category mutations + */ + (pf: (a: A) => Option.Option>): (self: STM) => STM; + /** + * Continue with the returned computation if the specified partial function + * matches, translating the successful match into a failure, otherwise continue + * with our held value. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, pf: (a: A) => Option.Option>): STM; +}; +/** + * Repeats this `STM` effect until its result satisfies the specified + * predicate. + * + * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will + * consume a thread until it completes (it cannot yield). This is because STM + * describes a single atomic transaction which must either complete, retry or + * fail a transaction before yielding back to the Effect runtime. + * - Use `retryUntil` instead if you don't need to maintain transaction + * state for repeats. + * - Ensure repeating the STM effect will eventually satisfy the predicate. + * + * @since 2.0.0 + * @category mutations + */ +export declare const repeatUntil: { + /** + * Repeats this `STM` effect until its result satisfies the specified + * predicate. + * + * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will + * consume a thread until it completes (it cannot yield). This is because STM + * describes a single atomic transaction which must either complete, retry or + * fail a transaction before yielding back to the Effect runtime. + * - Use `retryUntil` instead if you don't need to maintain transaction + * state for repeats. + * - Ensure repeating the STM effect will eventually satisfy the predicate. + * + * @since 2.0.0 + * @category mutations + */ + (predicate: Predicate): (self: STM) => STM; + /** + * Repeats this `STM` effect until its result satisfies the specified + * predicate. + * + * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will + * consume a thread until it completes (it cannot yield). This is because STM + * describes a single atomic transaction which must either complete, retry or + * fail a transaction before yielding back to the Effect runtime. + * - Use `retryUntil` instead if you don't need to maintain transaction + * state for repeats. + * - Ensure repeating the STM effect will eventually satisfy the predicate. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: Predicate): STM; +}; +/** + * Repeats this `STM` effect while its result satisfies the specified + * predicate. + * + * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will + * consume a thread until it completes (it cannot yield). This is because STM + * describes a single atomic transaction which must either complete, retry or + * fail a transaction before yielding back to the Effect runtime. + * - Use `retryWhile` instead if you don't need to maintain transaction + * state for repeats. + * - Ensure repeating the STM effect will eventually not satisfy the + * predicate. + * + * @since 2.0.0 + * @category mutations + */ +export declare const repeatWhile: { + /** + * Repeats this `STM` effect while its result satisfies the specified + * predicate. + * + * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will + * consume a thread until it completes (it cannot yield). This is because STM + * describes a single atomic transaction which must either complete, retry or + * fail a transaction before yielding back to the Effect runtime. + * - Use `retryWhile` instead if you don't need to maintain transaction + * state for repeats. + * - Ensure repeating the STM effect will eventually not satisfy the + * predicate. + * + * @since 2.0.0 + * @category mutations + */ + (predicate: Predicate): (self: STM) => STM; + /** + * Repeats this `STM` effect while its result satisfies the specified + * predicate. + * + * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will + * consume a thread until it completes (it cannot yield). This is because STM + * describes a single atomic transaction which must either complete, retry or + * fail a transaction before yielding back to the Effect runtime. + * - Use `retryWhile` instead if you don't need to maintain transaction + * state for repeats. + * - Ensure repeating the STM effect will eventually not satisfy the + * predicate. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: Predicate): STM; +}; +/** + * Replicates the given effect n times. If 0 or negative numbers are given, an + * empty `Chunk` will be returned. + * + * @since 2.0.0 + * @category constructors + */ +export declare const replicate: { + /** + * Replicates the given effect n times. If 0 or negative numbers are given, an + * empty `Chunk` will be returned. + * + * @since 2.0.0 + * @category constructors + */ + (n: number): (self: STM) => Array>; + /** + * Replicates the given effect n times. If 0 or negative numbers are given, an + * empty `Chunk` will be returned. + * + * @since 2.0.0 + * @category constructors + */ + (self: STM, n: number): Array>; +}; +/** + * Performs this transaction the specified number of times and collects the + * results. + * + * @since 2.0.0 + * @category constructors + */ +export declare const replicateSTM: { + /** + * Performs this transaction the specified number of times and collects the + * results. + * + * @since 2.0.0 + * @category constructors + */ + (n: number): (self: STM) => STM, E, R>; + /** + * Performs this transaction the specified number of times and collects the + * results. + * + * @since 2.0.0 + * @category constructors + */ + (self: STM, n: number): STM, E, R>; +}; +/** + * Performs this transaction the specified number of times, discarding the + * results. + * + * @since 2.0.0 + * @category constructors + */ +export declare const replicateSTMDiscard: { + /** + * Performs this transaction the specified number of times, discarding the + * results. + * + * @since 2.0.0 + * @category constructors + */ + (n: number): (self: STM) => STM; + /** + * Performs this transaction the specified number of times, discarding the + * results. + * + * @since 2.0.0 + * @category constructors + */ + (self: STM, n: number): STM; +}; +/** + * Abort and retry the whole transaction when any of the underlying + * transactional variables have changed. + * + * @since 2.0.0 + * @category error handling + */ +export declare const retry: STM; +/** + * Filters the value produced by this effect, retrying the transaction until + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ +export declare const retryUntil: { + /** + * Filters the value produced by this effect, retrying the transaction until + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ + (refinement: Refinement, B>): (self: STM) => STM; + /** + * Filters the value produced by this effect, retrying the transaction until + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ + (predicate: Predicate): (self: STM) => STM; + /** + * Filters the value produced by this effect, retrying the transaction until + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, refinement: Refinement): STM; + /** + * Filters the value produced by this effect, retrying the transaction until + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: Predicate): STM; +}; +/** + * Filters the value produced by this effect, retrying the transaction while + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ +export declare const retryWhile: { + /** + * Filters the value produced by this effect, retrying the transaction while + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ + (predicate: Predicate): (self: STM) => STM; + /** + * Filters the value produced by this effect, retrying the transaction while + * the predicate returns `true` for the value. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: Predicate): STM; +}; +/** + * Converts an option on values into an option on errors. + * + * @since 2.0.0 + * @category getters + */ +export declare const some: (self: STM, E, R>) => STM, R>; +/** + * Returns an `STM` effect that succeeds with the specified value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const succeed: (value: A) => STM; +/** + * Returns an effect with the empty value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const succeedNone: STM>; +/** + * Returns an effect with the optional value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const succeedSome: (value: A) => STM>; +/** + * Summarizes a `STM` effect by computing a provided value before and after + * execution, and then combining the values to produce a summary, together + * with the result of execution. + * + * @since 2.0.0 + * @category mutations + */ +export declare const summarized: { + /** + * Summarizes a `STM` effect by computing a provided value before and after + * execution, and then combining the values to produce a summary, together + * with the result of execution. + * + * @since 2.0.0 + * @category mutations + */ + (summary: STM, f: (before: A2, after: A2) => A3): (self: STM) => STM<[A3, A], E2 | E, R2 | R>; + /** + * Summarizes a `STM` effect by computing a provided value before and after + * execution, and then combining the values to produce a summary, together + * with the result of execution. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, summary: STM, f: (before: A2, after: A2) => A3): STM<[A3, A], E | E2, R | R2>; +}; +/** + * Suspends creation of the specified transaction lazily. + * + * @since 2.0.0 + * @category constructors + */ +export declare const suspend: (evaluate: LazyArg>) => STM; +/** + * Returns an `STM` effect that succeeds with the specified lazily evaluated + * value. + * + * @since 2.0.0 + * @category constructors + */ +export declare const sync: (evaluate: () => A) => STM; +/** + * "Peeks" at the success of transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const tap: { + /** + * "Peeks" at the success of transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ + (f: (a: A) => STM): (self: STM) => STM; + /** + * "Peeks" at the success of transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ + (self: STM, f: (a: A) => STM): STM; +}; +/** + * "Peeks" at both sides of an transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const tapBoth: { + /** + * "Peeks" at both sides of an transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ + (options: { + readonly onFailure: (error: XE) => STM; + readonly onSuccess: (value: XA) => STM; + }): (self: STM) => STM; + /** + * "Peeks" at both sides of an transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ + (self: STM, options: { + readonly onFailure: (error: XE) => STM; + readonly onSuccess: (value: XA) => STM; + }): STM; +}; +/** + * "Peeks" at the error of the transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ +export declare const tapError: { + /** + * "Peeks" at the error of the transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ + (f: (error: NoInfer) => STM): (self: STM) => STM; + /** + * "Peeks" at the error of the transactional effect. + * + * @since 2.0.0 + * @category sequencing + */ + (self: STM, f: (error: E) => STM): STM; +}; +declare const try_: { + (options: { + readonly try: LazyArg; + readonly catch: (u: unknown) => E; + }): STM; + (try_: LazyArg): STM; +}; +export { +/** + * Imports a synchronous side-effect into a pure value, translating any thrown + * exceptions into typed failed effects. + * + * @since 2.0.0 + * @category constructors + */ +try_ as try }; +/** + * The moral equivalent of `if (!p) exp` + * + * @since 2.0.0 + * @category mutations + */ +export declare const unless: { + /** + * The moral equivalent of `if (!p) exp` + * + * @since 2.0.0 + * @category mutations + */ + (predicate: LazyArg): (self: STM) => STM, E, R>; + /** + * The moral equivalent of `if (!p) exp` + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: LazyArg): STM, E, R>; +}; +/** + * The moral equivalent of `if (!p) exp` when `p` has side-effects + * + * @since 2.0.0 + * @category mutations + */ +export declare const unlessSTM: { + /** + * The moral equivalent of `if (!p) exp` when `p` has side-effects + * + * @since 2.0.0 + * @category mutations + */ + (predicate: STM): (self: STM) => STM, E2 | E, R2 | R>; + /** + * The moral equivalent of `if (!p) exp` when `p` has side-effects + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: STM): STM, E | E2, R | R2>; +}; +/** + * Converts an option on errors into an option on values. + * + * @since 2.0.0 + * @category getters + */ +export declare const unsome: (self: STM, R>) => STM, E, R>; +declare const void_: STM; +export { +/** + * Returns an `STM` effect that succeeds with `void`. + * + * @since 2.0.0 + * @category constructors + */ +void_ as void }; +/** + * Feeds elements of type `A` to `f` and accumulates all errors in error + * channel or successes in success channel. + * + * This combinator is lossy meaning that if there are errors all successes + * will be lost. To retain all information please use `STM.partition`. + * + * @since 2.0.0 + * @category mutations + */ +export declare const validateAll: { + /** + * Feeds elements of type `A` to `f` and accumulates all errors in error + * channel or successes in success channel. + * + * This combinator is lossy meaning that if there are errors all successes + * will be lost. To retain all information please use `STM.partition`. + * + * @since 2.0.0 + * @category mutations + */ + (f: (a: A) => STM): (elements: Iterable) => STM, [E, ...Array], R>; + /** + * Feeds elements of type `A` to `f` and accumulates all errors in error + * channel or successes in success channel. + * + * This combinator is lossy meaning that if there are errors all successes + * will be lost. To retain all information please use `STM.partition`. + * + * @since 2.0.0 + * @category mutations + */ + (elements: Iterable, f: (a: A) => STM): STM, [E, ...Array], R>; +}; +/** + * Feeds elements of type `A` to `f` until it succeeds. Returns first success + * or the accumulation of all errors. + * + * @since 2.0.0 + * @category mutations + */ +export declare const validateFirst: { + /** + * Feeds elements of type `A` to `f` until it succeeds. Returns first success + * or the accumulation of all errors. + * + * @since 2.0.0 + * @category mutations + */ + (f: (a: A) => STM): (elements: Iterable) => STM, R>; + /** + * Feeds elements of type `A` to `f` until it succeeds. Returns first success + * or the accumulation of all errors. + * + * @since 2.0.0 + * @category mutations + */ + (elements: Iterable, f: (a: A) => STM): STM, R>; +}; +/** + * The moral equivalent of `if (p) exp`. + * + * @since 2.0.0 + * @category mutations + */ +export declare const when: { + /** + * The moral equivalent of `if (p) exp`. + * + * @since 2.0.0 + * @category mutations + */ + (predicate: LazyArg): (self: STM) => STM, E, R>; + /** + * The moral equivalent of `if (p) exp`. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: LazyArg): STM, E, R>; +}; +/** + * The moral equivalent of `if (p) exp` when `p` has side-effects. + * + * @since 2.0.0 + * @category mutations + */ +export declare const whenSTM: { + /** + * The moral equivalent of `if (p) exp` when `p` has side-effects. + * + * @since 2.0.0 + * @category mutations + */ + (predicate: STM): (self: STM) => STM, E2 | E, R2 | R>; + /** + * The moral equivalent of `if (p) exp` when `p` has side-effects. + * + * @since 2.0.0 + * @category mutations + */ + (self: STM, predicate: STM): STM, E | E2, R | R2>; +}; +/** + * Sequentially zips this value with the specified one. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zip: { + /** + * Sequentially zips this value with the specified one. + * + * @since 2.0.0 + * @category zipping + */ + (that: STM): (self: STM) => STM<[A, A1], E1 | E, R1 | R>; + /** + * Sequentially zips this value with the specified one. + * + * @since 2.0.0 + * @category zipping + */ + (self: STM, that: STM): STM<[A, A1], E | E1, R | R1>; +}; +/** + * Sequentially zips this value with the specified one, discarding the second + * element of the tuple. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipLeft: { + /** + * Sequentially zips this value with the specified one, discarding the second + * element of the tuple. + * + * @since 2.0.0 + * @category zipping + */ + (that: STM): (self: STM) => STM; + /** + * Sequentially zips this value with the specified one, discarding the second + * element of the tuple. + * + * @since 2.0.0 + * @category zipping + */ + (self: STM, that: STM): STM; +}; +/** + * Sequentially zips this value with the specified one, discarding the first + * element of the tuple. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipRight: { + /** + * Sequentially zips this value with the specified one, discarding the first + * element of the tuple. + * + * @since 2.0.0 + * @category zipping + */ + (that: STM): (self: STM) => STM; + /** + * Sequentially zips this value with the specified one, discarding the first + * element of the tuple. + * + * @since 2.0.0 + * @category zipping + */ + (self: STM, that: STM): STM; +}; +/** + * Sequentially zips this value with the specified one, combining the values + * using the specified combiner function. + * + * @since 2.0.0 + * @category zipping + */ +export declare const zipWith: { + /** + * Sequentially zips this value with the specified one, combining the values + * using the specified combiner function. + * + * @since 2.0.0 + * @category zipping + */ + (that: STM, f: (a: A, b: A1) => A2): (self: STM) => STM; + /** + * Sequentially zips this value with the specified one, combining the values + * using the specified combiner function. + * + * @since 2.0.0 + * @category zipping + */ + (self: STM, that: STM, f: (a: A, b: A1) => A2): STM; +}; +/** + * This function takes an iterable of `STM` values and returns a new + * `STM` value that represents the first `STM` value in the iterable + * that succeeds. If all of the `Effect` values in the iterable fail, then + * the resulting `STM` value will fail as well. + * + * This function is sequential, meaning that the `STM` values in the + * iterable will be executed in sequence, and the first one that succeeds + * will determine the outcome of the resulting `STM` value. + * + * Returns a new `STM` value that represents the first successful + * `STM` value in the iterable, or a failed `STM` value if all of the + * `STM` values in the iterable fail. + * + * @since 2.0.0 + * @category elements + */ +export declare const firstSuccessOf: (effects: Iterable>) => STM; +/** + * @category do notation + * @since 2.0.0 + */ +export declare const Do: STM<{}>; +/** + * @category do notation + * @since 2.0.0 + */ +export declare const bind: { + /** + * @category do notation + * @since 2.0.0 + */ + (tag: Exclude, f: (_: NoInfer) => STM): (self: STM) => STM, E2 | E, R2 | R>; + /** + * @category do notation + * @since 2.0.0 + */ + (self: STM, tag: Exclude, f: (_: NoInfer) => STM): STM, E | E2, R | R2>; +}; +declare const let_: { + (tag: Exclude, f: (_: NoInfer) => A): (self: STM) => STM, E, R>; + (self: STM, tag: Exclude, f: (_: NoInfer) => A): STM, E, R>; +}; +export { +/** + * @category do notation + * @since 2.0.0 + */ +let_ as let }; +/** + * @category do notation + * @since 2.0.0 + */ +export declare const bindTo: { + /** + * @category do notation + * @since 2.0.0 + */ + (tag: N): (self: STM) => STM, E, R>; + /** + * @category do notation + * @since 2.0.0 + */ + (self: STM, tag: N): STM, E, R>; +}; +//# sourceMappingURL=STM.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/STM.d.ts.map b/backend/node_modules/effect/dist/dts/STM.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..258ee808409c7254a5a5364e56b2402d78926c83 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/STM.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"STM.d.ts","sourceRoot":"","sources":["../../src/STM.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Schedule.d.ts b/backend/node_modules/effect/dist/dts/Schedule.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..94ca6936e59095809eb8c647d9f7fc30ed8ca622 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Schedule.d.ts @@ -0,0 +1,3509 @@ +/** + * @since 2.0.0 + */ +import type * as Cause from "./Cause.js"; +import type * as Chunk from "./Chunk.js"; +import type * as Context from "./Context.js"; +import type * as Cron from "./Cron.js"; +import type * as DateTime from "./DateTime.js"; +import type * as Duration from "./Duration.js"; +import type * as Effect from "./Effect.js"; +import type * as Either from "./Either.js"; +import type { LazyArg } from "./Function.js"; +import type * as Option from "./Option.js"; +import type { Pipeable } from "./Pipeable.js"; +import type { Predicate } from "./Predicate.js"; +import type * as Ref from "./Ref.js"; +import type * as ScheduleDecision from "./ScheduleDecision.js"; +import type * as Intervals from "./ScheduleIntervals.js"; +import type * as Types from "./Types.js"; +/** + * @since 2.0.0 + * @category Symbols + */ +export declare const ScheduleTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type ScheduleTypeId = typeof ScheduleTypeId; +/** + * @since 2.0.0 + * @category Symbols + */ +export declare const ScheduleDriverTypeId: unique symbol; +/** + * @since 2.0.0 + * @category Symbols + */ +export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId; +/** + * A `Schedule` defines a recurring schedule, which consumes values + * of type `In`, and which returns values of type `Out`. + * + * The `Schedule` type is structured as follows: + * + * ```ts skip-type-checking + * // ┌─── The type of output produced by the schedule + * // │ ┌─── The type of input consumed by the schedule + * // │ │ ┌─── Additional requirements for the schedule + * // ▼ ▼ ▼ + * Schedule + * ``` + * + * A schedule operates by consuming values of type `In` (such as errors in the + * case of `Effect.retry`, or values in the case of `Effect.repeat`) and + * producing values of type `Out`. It determines when to halt or continue the + * execution based on input values and its internal state. + * + * The inclusion of a `Requirements` parameter allows the schedule to leverage + * additional services or resources as needed. + * + * Schedules are defined as a possibly infinite set of intervals spread out over + * time. Each interval defines a window in which recurrence is possible. + * + * When schedules are used to repeat or retry effects, the starting boundary of + * each interval produced by a schedule is used as the moment when the effect + * will be executed again. + * + * Schedules can be composed in different ways: + * + * - Union: Combines two schedules and recurs if either schedule wants to + * continue, using the shorter delay. + * - Intersection: Combines two schedules and recurs only if both schedules want + * to continue, using the longer delay. + * - Sequencing: Combines two schedules by running the first one fully, then + * switching to the second. + * + * In addition, schedule inputs and outputs can be transformed, filtered (to + * terminate a schedule early in response to some input or output), and so + * forth. + * + * A variety of other operators exist for transforming and combining schedules, + * and the companion object for `Schedule` contains all common types of + * schedules, both for performing retrying, as well as performing repetition. + * + * @category Model + * @since 2.0.0 + */ +export interface Schedule extends Schedule.Variance, Pipeable { + /** + * Initial State + */ + readonly initial: any; + /** + * Schedule Step + */ + step(now: number, input: In, state: any): Effect.Effect; +} +/** + * @since 2.0.0 + */ +export declare namespace Schedule { + /** + * @since 2.0.0 + * @category Models + */ + interface Variance { + readonly [ScheduleTypeId]: { + readonly _Out: Types.Covariant; + readonly _In: Types.Contravariant; + readonly _R: Types.Covariant; + }; + } + /** + * @since 2.0.0 + */ + interface DriverVariance { + readonly [ScheduleDriverTypeId]: { + readonly _Out: Types.Covariant; + readonly _In: Types.Contravariant; + readonly _R: Types.Covariant; + }; + } +} +/** + * @since 2.0.0 + * @category Models + */ +export interface ScheduleDriver extends Schedule.DriverVariance { + readonly state: Effect.Effect; + readonly iterationMeta: Ref.Ref; + readonly last: Effect.Effect; + readonly reset: Effect.Effect; + next(input: In): Effect.Effect, R>; +} +/** + * Creates a new schedule with a custom state and step function. + * + * **Details** + * + * This function constructs a `Schedule` by defining its initial state and a + * step function, which determines how the schedule progresses over time. The + * step function is called on each iteration with the current time, an input + * value, and the schedule's current state. It returns the next state, an output + * value, and a decision on whether the schedule should continue or stop. + * + * This function is useful for creating custom scheduling logic that goes beyond + * predefined schedules like fixed intervals or exponential backoff. It allows + * full control over how the schedule behaves at each step. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const makeWithState: (initial: S, step: (now: number, input: In, state: S) => Effect.Effect) => Schedule; +/** + * Checks whether a given value is a `Schedule`. + * + * @since 2.0.0 + * @category Guards + */ +export declare const isSchedule: (u: unknown) => u is Schedule; +/** + * Adds a delay to every interval in a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying an additional delay to + * every interval it defines. The delay is determined by the provided function, + * which takes the schedule's output and returns a delay duration. + * + * @see {@link addDelayEffect} If you need to compute the delay using an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const addDelay: { + /** + * Adds a delay to every interval in a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying an additional delay to + * every interval it defines. The delay is determined by the provided function, + * which takes the schedule's output and returns a delay duration. + * + * @see {@link addDelayEffect} If you need to compute the delay using an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (f: (out: Out) => Duration.DurationInput): (self: Schedule) => Schedule; + /** + * Adds a delay to every interval in a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying an additional delay to + * every interval it defines. The delay is determined by the provided function, + * which takes the schedule's output and returns a delay duration. + * + * @see {@link addDelayEffect} If you need to compute the delay using an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (self: Schedule, f: (out: Out) => Duration.DurationInput): Schedule; +}; +/** + * Adds an effectfully computed delay to every interval in a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying an additional delay to + * each interval, where the delay is determined by an effectful function. The + * function takes the schedule’s output and returns an effect that produces a + * delay duration. + * + * @see {@link addDelay} If you need to compute the delay using a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const addDelayEffect: { + /** + * Adds an effectfully computed delay to every interval in a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying an additional delay to + * each interval, where the delay is determined by an effectful function. The + * function takes the schedule’s output and returns an effect that produces a + * delay duration. + * + * @see {@link addDelay} If you need to compute the delay using a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (f: (out: Out) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Adds an effectfully computed delay to every interval in a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying an additional delay to + * each interval, where the delay is determined by an effectful function. The + * function takes the schedule’s output and returns an effect that produces a + * delay duration. + * + * @see {@link addDelay} If you need to compute the delay using a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (self: Schedule, f: (out: Out) => Effect.Effect): Schedule; +}; +/** + * Runs two schedules sequentially, merging their outputs. + * + * **Details** + * + * This function executes two schedules one after the other. The first schedule + * runs to completion, and then the second schedule begins execution. Unlike + * {@link andThenEither}, this function merges the outputs instead of wrapping + * them in `Either`, allowing both schedules to contribute their results + * directly. + * + * This is useful when a workflow consists of two phases where the second phase + * should start only after the first one has fully completed. + * + * @see {@link andThenEither} If you need to keep track of which schedule + * produced each result. + * + * @since 2.0.0 + * @category Sequential Composition + */ +export declare const andThen: { + /** + * Runs two schedules sequentially, merging their outputs. + * + * **Details** + * + * This function executes two schedules one after the other. The first schedule + * runs to completion, and then the second schedule begins execution. Unlike + * {@link andThenEither}, this function merges the outputs instead of wrapping + * them in `Either`, allowing both schedules to contribute their results + * directly. + * + * This is useful when a workflow consists of two phases where the second phase + * should start only after the first one has fully completed. + * + * @see {@link andThenEither} If you need to keep track of which schedule + * produced each result. + * + * @since 2.0.0 + * @category Sequential Composition + */ + (that: Schedule): (self: Schedule) => Schedule; + /** + * Runs two schedules sequentially, merging their outputs. + * + * **Details** + * + * This function executes two schedules one after the other. The first schedule + * runs to completion, and then the second schedule begins execution. Unlike + * {@link andThenEither}, this function merges the outputs instead of wrapping + * them in `Either`, allowing both schedules to contribute their results + * directly. + * + * This is useful when a workflow consists of two phases where the second phase + * should start only after the first one has fully completed. + * + * @see {@link andThenEither} If you need to keep track of which schedule + * produced each result. + * + * @since 2.0.0 + * @category Sequential Composition + */ + (self: Schedule, that: Schedule): Schedule; +}; +/** + * Runs two schedules sequentially, collecting results in an `Either`. + * + * **Details** + * + * This function combines two schedules in sequence. The first schedule runs to + * completion, and then the second schedule starts and runs to completion as + * well. The outputs of both schedules are collected into an `Either` structure: + * - `Either.Left` contains the output of the second schedule. + * - `Either.Right` contains the output of the first schedule. + * + * This is useful when you need to switch from one schedule to another after the + * first one finishes, while still keeping track of which schedule produced each + * result. + * + * @see {@link andThen} If you need to merge the outputs of both schedules. + * + * @since 2.0.0 + * @category Sequential Composition + */ +export declare const andThenEither: { + /** + * Runs two schedules sequentially, collecting results in an `Either`. + * + * **Details** + * + * This function combines two schedules in sequence. The first schedule runs to + * completion, and then the second schedule starts and runs to completion as + * well. The outputs of both schedules are collected into an `Either` structure: + * - `Either.Left` contains the output of the second schedule. + * - `Either.Right` contains the output of the first schedule. + * + * This is useful when you need to switch from one schedule to another after the + * first one finishes, while still keeping track of which schedule produced each + * result. + * + * @see {@link andThen} If you need to merge the outputs of both schedules. + * + * @since 2.0.0 + * @category Sequential Composition + */ + (that: Schedule): (self: Schedule) => Schedule, In & In2, R2 | R>; + /** + * Runs two schedules sequentially, collecting results in an `Either`. + * + * **Details** + * + * This function combines two schedules in sequence. The first schedule runs to + * completion, and then the second schedule starts and runs to completion as + * well. The outputs of both schedules are collected into an `Either` structure: + * - `Either.Left` contains the output of the second schedule. + * - `Either.Right` contains the output of the first schedule. + * + * This is useful when you need to switch from one schedule to another after the + * first one finishes, while still keeping track of which schedule produced each + * result. + * + * @see {@link andThen} If you need to merge the outputs of both schedules. + * + * @since 2.0.0 + * @category Sequential Composition + */ + (self: Schedule, that: Schedule): Schedule, In & In2, R | R2>; +}; +/** + * Transforms a schedule to always produce a constant output. + * + * **Details** + * + * This function modifies a given schedule so that instead of returning its + * computed outputs, it always returns a constant value. + * + * This is useful when you need a schedule for timing but don’t care about its + * actual output, or when you want to standardize results across different + * scheduling strategies. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const as: { + /** + * Transforms a schedule to always produce a constant output. + * + * **Details** + * + * This function modifies a given schedule so that instead of returning its + * computed outputs, it always returns a constant value. + * + * This is useful when you need a schedule for timing but don’t care about its + * actual output, or when you want to standardize results across different + * scheduling strategies. + * + * @since 2.0.0 + * @category Mapping + */ + (out: Out2): (self: Schedule) => Schedule; + /** + * Transforms a schedule to always produce a constant output. + * + * **Details** + * + * This function modifies a given schedule so that instead of returning its + * computed outputs, it always returns a constant value. + * + * This is useful when you need a schedule for timing but don’t care about its + * actual output, or when you want to standardize results across different + * scheduling strategies. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, out: Out2): Schedule; +}; +/** + * Transforms a schedule to always return `void` instead of its output. + * + * **Details** + * + * This function modifies a given schedule so that it no longer returns + * meaningful output—each execution produces `void`. This is useful when the + * schedule is used only for timing purposes and the actual output of the + * schedule is irrelevant. + * + * The schedule still determines when executions should occur, but the results + * are discarded. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const asVoid: (self: Schedule) => Schedule; +/** + * Combines two schedules, preserving both their inputs and outputs. + * + * **Details** + * + * This function merges two schedules so that both their input types and output + * types are retained. When executed, the resulting schedule will take inputs + * from both original schedules and produce a tuple containing both outputs. + * + * It recurs if either schedule wants to continue, using the shorter delay. + * + * This is useful when you want to track multiple schedules simultaneously, + * ensuring that both receive the same inputs and produce combined results. + * + * @since 2.0.0 + * @category Zipping + */ +export declare const bothInOut: { + /** + * Combines two schedules, preserving both their inputs and outputs. + * + * **Details** + * + * This function merges two schedules so that both their input types and output + * types are retained. When executed, the resulting schedule will take inputs + * from both original schedules and produce a tuple containing both outputs. + * + * It recurs if either schedule wants to continue, using the shorter delay. + * + * This is useful when you want to track multiple schedules simultaneously, + * ensuring that both receive the same inputs and produce combined results. + * + * @since 2.0.0 + * @category Zipping + */ + (that: Schedule): (self: Schedule) => Schedule<[Out, Out2], readonly [In, In2], R2 | R>; + /** + * Combines two schedules, preserving both their inputs and outputs. + * + * **Details** + * + * This function merges two schedules so that both their input types and output + * types are retained. When executed, the resulting schedule will take inputs + * from both original schedules and produce a tuple containing both outputs. + * + * It recurs if either schedule wants to continue, using the shorter delay. + * + * This is useful when you want to track multiple schedules simultaneously, + * ensuring that both receive the same inputs and produce combined results. + * + * @since 2.0.0 + * @category Zipping + */ + (self: Schedule, that: Schedule): Schedule<[Out, Out2], readonly [In, In2], R | R2>; +}; +/** + * Filters schedule executions based on a custom condition. + * + * **Details** + * + * This function modifies a schedule by applying a custom test function to each + * input-output pair. The test function determines whether the schedule should + * continue or stop. If the function returns `true`, the schedule proceeds as + * usual; if it returns `false`, the schedule terminates. + * + * This is useful for conditional retries, custom stop conditions, or + * dynamically controlling execution based on observed inputs and outputs. + * + * @see {@link checkEffect} If you need to use an effectful test function. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const check: { + /** + * Filters schedule executions based on a custom condition. + * + * **Details** + * + * This function modifies a schedule by applying a custom test function to each + * input-output pair. The test function determines whether the schedule should + * continue or stop. If the function returns `true`, the schedule proceeds as + * usual; if it returns `false`, the schedule terminates. + * + * This is useful for conditional retries, custom stop conditions, or + * dynamically controlling execution based on observed inputs and outputs. + * + * @see {@link checkEffect} If you need to use an effectful test function. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (test: (input: In, output: Out) => boolean): (self: Schedule) => Schedule; + /** + * Filters schedule executions based on a custom condition. + * + * **Details** + * + * This function modifies a schedule by applying a custom test function to each + * input-output pair. The test function determines whether the schedule should + * continue or stop. If the function returns `true`, the schedule proceeds as + * usual; if it returns `false`, the schedule terminates. + * + * This is useful for conditional retries, custom stop conditions, or + * dynamically controlling execution based on observed inputs and outputs. + * + * @see {@link checkEffect} If you need to use an effectful test function. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, test: (input: In, output: Out) => boolean): Schedule; +}; +/** + * Conditionally filters schedule executions using an effectful function. + * + * **Details** + * + * This function modifies a schedule by applying a custom effectful test + * function to each input-output pair. The test function determines whether the + * schedule should continue (`true`) or stop (`false`). + * + * This is useful when the decision to continue depends on external factors such + * as database lookups, API calls, or other asynchronous computations. + * + * @see {@link check} If you need to use a pure test function. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const checkEffect: { + /** + * Conditionally filters schedule executions using an effectful function. + * + * **Details** + * + * This function modifies a schedule by applying a custom effectful test + * function to each input-output pair. The test function determines whether the + * schedule should continue (`true`) or stop (`false`). + * + * This is useful when the decision to continue depends on external factors such + * as database lookups, API calls, or other asynchronous computations. + * + * @see {@link check} If you need to use a pure test function. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (test: (input: In, output: Out) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Conditionally filters schedule executions using an effectful function. + * + * **Details** + * + * This function modifies a schedule by applying a custom effectful test + * function to each input-output pair. The test function determines whether the + * schedule should continue (`true`) or stop (`false`). + * + * This is useful when the decision to continue depends on external factors such + * as database lookups, API calls, or other asynchronous computations. + * + * @see {@link check} If you need to use a pure test function. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, test: (input: In, output: Out) => Effect.Effect): Schedule; +}; +/** + * A schedule that collects all inputs into a `Chunk`. + * + * **Details** + * + * This function creates a schedule that never terminates and continuously + * collects every input it receives into a `Chunk`. Each time the schedule runs, + * it appends the new input to the collected list. + * + * This is useful when you need to track all received inputs over time, such as + * logging user actions, recording retry attempts, or accumulating data for + * later processing. + * + * @see {@link collectAllOutputs} If you need to collect outputs instead of + * inputs. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const collectAllInputs: () => Schedule, A>; +/** + * Collects all outputs of a schedule into a `Chunk`. + * + * **Details** + * + * This function modifies a given schedule so that instead of returning + * individual outputs, it accumulates them into a `Chunk`. The schedule + * continues to run, appending each output to the collected list. + * + * This is useful when you need to track all results over time, such as logging + * outputs, aggregating data, or keeping a history of previous values. + * + * @see {@link collectAllInputs} If you need to collect inputs instead of + * outputs. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const collectAllOutputs: (self: Schedule) => Schedule, In, R>; +/** + * Collects all inputs into a `Chunk` until a condition fails. + * + * **Details** + * + * This function creates a schedule that continuously collects inputs into a + * `Chunk` until the given predicate function `f` evaluates to `false`. Once the + * condition fails, the schedule stops. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const collectUntil: (f: Predicate) => Schedule, A>; +/** + * Collects all inputs into a `Chunk` until an effectful condition fails. + * + * **Details** + * + * This function creates a schedule that continuously collects inputs into a + * `Chunk` until the given effectful predicate `f` returns `false`. The + * predicate runs as an effect, meaning it can involve asynchronous computations + * like API calls, database lookups, or randomness. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const collectUntilEffect: (f: (a: A) => Effect.Effect) => Schedule, A, R>; +/** + * Collects all inputs into a `Chunk` while a condition holds. + * + * **Details** + * + * This function creates a schedule that continuously collects inputs into a + * `Chunk` while the given predicate function `f` evaluates to `true`. As soon + * as the condition fails, the schedule stops. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const collectWhile: (f: Predicate) => Schedule, A>; +/** + * Collects all inputs into a `Chunk` while an effectful condition holds. + * + * **Details** + * + * This function creates a schedule that continuously collects inputs into a + * `Chunk` while the given effectful predicate `f` returns `true`. The predicate + * returns an effect, meaning it can depend on external state, such as database + * queries, API responses, or real-time user conditions. + * + * As soon as the effectful condition returns `false`, the schedule stops. This + * is useful for dynamically controlled data collection, where stopping depends + * on an external or asynchronous factor. + * + * @since 2.0.0 + * @category Collecting + */ +export declare const collectWhileEffect: (f: (a: A) => Effect.Effect) => Schedule, A, R>; +/** + * Chains two schedules, passing the output of the first as the input to the + * second, while selecting the shorter delay between them. + * + * **Details** + * + * This function composes two schedules so that the output of the first schedule + * becomes the input of the second schedule. The first schedule executes first, + * and once it produces a result, the second schedule receives that result and + * continues execution based on it. + * + * This is useful for building complex scheduling workflows where one schedule's + * behavior determines how the next schedule behaves. + * + * @since 2.0.0 + * @category Composition + */ +export declare const compose: { + /** + * Chains two schedules, passing the output of the first as the input to the + * second, while selecting the shorter delay between them. + * + * **Details** + * + * This function composes two schedules so that the output of the first schedule + * becomes the input of the second schedule. The first schedule executes first, + * and once it produces a result, the second schedule receives that result and + * continues execution based on it. + * + * This is useful for building complex scheduling workflows where one schedule's + * behavior determines how the next schedule behaves. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule): (self: Schedule) => Schedule; + /** + * Chains two schedules, passing the output of the first as the input to the + * second, while selecting the shorter delay between them. + * + * **Details** + * + * This function composes two schedules so that the output of the first schedule + * becomes the input of the second schedule. The first schedule executes first, + * and once it produces a result, the second schedule receives that result and + * continues execution based on it. + * + * This is useful for building complex scheduling workflows where one schedule's + * behavior determines how the next schedule behaves. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule): Schedule; +}; +/** + * Transforms the input type of a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying a transformation function + * to its inputs. Instead of directly receiving values of type `In`, the + * schedule will now accept values of type `In2`, which are converted to `In` + * using the provided mapping function `f`. + * + * This is useful when you have a schedule that expects a specific input type + * but you need to adapt it to work with a different type. + * + * @see {@link mapInputEffect} If you need to use an effectful transformation function. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapInput: { + /** + * Transforms the input type of a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying a transformation function + * to its inputs. Instead of directly receiving values of type `In`, the + * schedule will now accept values of type `In2`, which are converted to `In` + * using the provided mapping function `f`. + * + * This is useful when you have a schedule that expects a specific input type + * but you need to adapt it to work with a different type. + * + * @see {@link mapInputEffect} If you need to use an effectful transformation function. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (in2: In2) => In): (self: Schedule) => Schedule; + /** + * Transforms the input type of a schedule. + * + * **Details** + * + * This function modifies a given schedule by applying a transformation function + * to its inputs. Instead of directly receiving values of type `In`, the + * schedule will now accept values of type `In2`, which are converted to `In` + * using the provided mapping function `f`. + * + * This is useful when you have a schedule that expects a specific input type + * but you need to adapt it to work with a different type. + * + * @see {@link mapInputEffect} If you need to use an effectful transformation function. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, f: (in2: In2) => In): Schedule; +}; +/** + * Transforms the input type of a schedule using an effectful function. + * + * **Details** + * + * This function modifies a schedule by applying an effectful transformation to + * its inputs. Instead of directly receiving values of type `In`, the schedule + * will now accept values of type `In2`, which are converted to `In` via an + * effectful function `f`. + * + * This is useful when the input transformation involves external dependencies, + * such as API calls, database lookups, or other asynchronous computations. + * + * @see {@link mapInput} If you need to use a pure transformation function. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapInputEffect: { + /** + * Transforms the input type of a schedule using an effectful function. + * + * **Details** + * + * This function modifies a schedule by applying an effectful transformation to + * its inputs. Instead of directly receiving values of type `In`, the schedule + * will now accept values of type `In2`, which are converted to `In` via an + * effectful function `f`. + * + * This is useful when the input transformation involves external dependencies, + * such as API calls, database lookups, or other asynchronous computations. + * + * @see {@link mapInput} If you need to use a pure transformation function. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (in2: In2) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Transforms the input type of a schedule using an effectful function. + * + * **Details** + * + * This function modifies a schedule by applying an effectful transformation to + * its inputs. Instead of directly receiving values of type `In`, the schedule + * will now accept values of type `In2`, which are converted to `In` via an + * effectful function `f`. + * + * This is useful when the input transformation involves external dependencies, + * such as API calls, database lookups, or other asynchronous computations. + * + * @see {@link mapInput} If you need to use a pure transformation function. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, f: (in2: In2) => Effect.Effect): Schedule; +}; +/** + * Transforms the required context of a schedule. + * + * **Details** + * + * This function modifies a schedule by mapping its required context (`R`) into + * a new context (`R0`) using the provided function `f`. + * + * This is useful when you need to adapt a schedule to work with a different + * dependency environment without changing its core logic. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapInputContext: { + /** + * Transforms the required context of a schedule. + * + * **Details** + * + * This function modifies a schedule by mapping its required context (`R`) into + * a new context (`R0`) using the provided function `f`. + * + * This is useful when you need to adapt a schedule to work with a different + * dependency environment without changing its core logic. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (env0: Context.Context) => Context.Context): (self: Schedule) => Schedule; + /** + * Transforms the required context of a schedule. + * + * **Details** + * + * This function modifies a schedule by mapping its required context (`R`) into + * a new context (`R0`) using the provided function `f`. + * + * This is useful when you need to adapt a schedule to work with a different + * dependency environment without changing its core logic. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, f: (env0: Context.Context) => Context.Context): Schedule; +}; +/** + * A schedule that recurs indefinitely, counting the number of recurrences. + * + * **Details** + * + * This schedule never stops and simply counts how many times it has executed. + * Each recurrence increases the count, starting from `0`. + * + * This is useful when tracking the number of attempts in retry policies, + * measuring execution loops, or implementing infinite polling scenarios. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const count: Schedule; +/** + * Creates a schedule that recurs based on a cron expression. + * + * **Details** + * + * This schedule automatically executes at intervals defined by a cron + * expression. It triggers at the beginning of each matched interval and + * produces timestamps representing the start and end of the cron window. + * + * The cron `expression` is validated lazily, meaning errors may only be + * detected when the schedule is executed. + * + * @since 2.0.0 + * @category Cron + */ +export declare const cron: { + /** + * Creates a schedule that recurs based on a cron expression. + * + * **Details** + * + * This schedule automatically executes at intervals defined by a cron + * expression. It triggers at the beginning of each matched interval and + * produces timestamps representing the start and end of the cron window. + * + * The cron `expression` is validated lazily, meaning errors may only be + * detected when the schedule is executed. + * + * @since 2.0.0 + * @category Cron + */ + (cron: Cron.Cron): Schedule<[number, number]>; + /** + * Creates a schedule that recurs based on a cron expression. + * + * **Details** + * + * This schedule automatically executes at intervals defined by a cron + * expression. It triggers at the beginning of each matched interval and + * produces timestamps representing the start and end of the cron window. + * + * The cron `expression` is validated lazily, meaning errors may only be + * detected when the schedule is executed. + * + * @since 2.0.0 + * @category Cron + */ + (expression: string, tz?: DateTime.TimeZone | string): Schedule<[number, number]>; +}; +/** + * Cron-like schedule that recurs at a specific second of each minute. + * + * **Details** + * + * This schedule triggers at the specified `second` of each minute, + * starting at zero nanoseconds. It produces a count of executions + * (0, 1, 2, ...). The `second` parameter is validated lazily, meaning + * invalid values will only be caught at runtime. + * + * @since 2.0.0 + * @category Cron + */ +export declare const secondOfMinute: (second: number) => Schedule; +/** + * Creates a schedule that recurs every specified minute of each hour. + * + * **Details** + * + * This schedule triggers once per hour at the specified `minute`, starting + * exactly at `minute:00` (zero seconds). The schedule produces a count of + * executions (`0, 1, 2, ...`), representing how many times it has run. + * + * The `minute` parameter must be between `0` and `59`. It is validated lazily, + * meaning an invalid value will cause errors only when the schedule is + * executed. + * + * @since 2.0.0 + * @category Cron + */ +export declare const minuteOfHour: (minute: number) => Schedule; +/** + * Creates a schedule that recurs at a specific hour of each day. + * + * **Details** + * + * This schedule triggers once per day at the specified `hour`, starting at zero + * minutes of that hour. The schedule produces a count of executions (`0, 1, 2, + * ...`), indicating how many times it has been triggered. + * + * The `hour` parameter must be between `0` (midnight) and `23` (11 PM). It is + * validated lazily, meaning an invalid value will cause errors only when the + * schedule is executed. + * + * This is useful for scheduling daily recurring tasks at a fixed time, such as + * running batch jobs or refreshing data. + * + * @since 2.0.0 + * @category Cron + */ +export declare const hourOfDay: (hour: number) => Schedule; +/** + * Creates a schedule that recurs on a specific day of the month. + * + * **Details** + * + * This schedule triggers at midnight on the specified day of each month. It + * will not execute in months that have fewer days than the given day. For + * example, if the schedule is set to run on the 31st, it will not execute in + * months with only 30 days. + * + * The schedule produces a count of executions, starting at 0 and incrementing + * with each recurrence. + * + * The `day` parameter is validated lazily, meaning errors may only be detected + * when the schedule is executed. + * + * @since 2.0.0 + * @category Cron + */ +export declare const dayOfMonth: (day: number) => Schedule; +/** + * Creates a schedule that recurs on a specific day of the week. + * + * **Details** + * + * This schedule triggers at midnight on the specified day of the week. The + * `day` parameter follows the standard convention where `Monday = 1` and + * `Sunday = 7`. The schedule produces a count of executions, starting at 0 and + * incrementing with each recurrence. + * + * The `day` parameter is validated lazily, meaning errors may only be detected + * when the schedule is executed. + * + * @since 2.0.0 + * @category Cron + */ +export declare const dayOfWeek: (day: number) => Schedule; +/** + * Modifies a schedule by adding a computed delay before each execution. + * + * **Details** + * + * This function adjusts an existing schedule by applying a transformation to + * its delays. Instead of using the default interval, each delay is modified + * using the provided function `f`, which takes the current delay and returns a + * new delay. + * + * This is useful for dynamically adjusting wait times between executions, such + * as introducing jitter, exponential backoff, or custom delay logic. + * + * @see {@link delayedEffect} If you need to compute the delay using an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const delayed: { + /** + * Modifies a schedule by adding a computed delay before each execution. + * + * **Details** + * + * This function adjusts an existing schedule by applying a transformation to + * its delays. Instead of using the default interval, each delay is modified + * using the provided function `f`, which takes the current delay and returns a + * new delay. + * + * This is useful for dynamically adjusting wait times between executions, such + * as introducing jitter, exponential backoff, or custom delay logic. + * + * @see {@link delayedEffect} If you need to compute the delay using an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (f: (duration: Duration.Duration) => Duration.DurationInput): (self: Schedule) => Schedule; + /** + * Modifies a schedule by adding a computed delay before each execution. + * + * **Details** + * + * This function adjusts an existing schedule by applying a transformation to + * its delays. Instead of using the default interval, each delay is modified + * using the provided function `f`, which takes the current delay and returns a + * new delay. + * + * This is useful for dynamically adjusting wait times between executions, such + * as introducing jitter, exponential backoff, or custom delay logic. + * + * @see {@link delayedEffect} If you need to compute the delay using an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (self: Schedule, f: (duration: Duration.Duration) => Duration.DurationInput): Schedule; +}; +/** + * Modifies a schedule by adding an effectfully computed delay before each + * execution. + * + * **Details** + * + * This function adjusts an existing schedule by introducing a delay that is + * computed via an effect. Instead of using a fixed delay, each interval is + * dynamically adjusted based on an effectful function `f`, which takes the + * current delay and returns a new delay wrapped in an `Effect`. + * + * This is useful for adaptive scheduling where delays depend on external + * factors, such as API calls, database queries, or dynamic system conditions. + * + * @see {@link delayed} If you need to compute the delay using a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const delayedEffect: { + /** + * Modifies a schedule by adding an effectfully computed delay before each + * execution. + * + * **Details** + * + * This function adjusts an existing schedule by introducing a delay that is + * computed via an effect. Instead of using a fixed delay, each interval is + * dynamically adjusted based on an effectful function `f`, which takes the + * current delay and returns a new delay wrapped in an `Effect`. + * + * This is useful for adaptive scheduling where delays depend on external + * factors, such as API calls, database queries, or dynamic system conditions. + * + * @see {@link delayed} If you need to compute the delay using a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (f: (duration: Duration.Duration) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Modifies a schedule by adding an effectfully computed delay before each + * execution. + * + * **Details** + * + * This function adjusts an existing schedule by introducing a delay that is + * computed via an effect. Instead of using a fixed delay, each interval is + * dynamically adjusted based on an effectful function `f`, which takes the + * current delay and returns a new delay wrapped in an `Effect`. + * + * This is useful for adaptive scheduling where delays depend on external + * factors, such as API calls, database queries, or dynamic system conditions. + * + * @see {@link delayed} If you need to compute the delay using a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (self: Schedule, f: (duration: Duration.Duration) => Effect.Effect): Schedule; +}; +/** + * Uses the delays produced by a schedule to further delay its intervals. + * + * **Details** + * + * This function modifies a schedule by using its own output delays to control + * its execution timing. Instead of executing immediately at each interval, the + * schedule will be delayed by the duration it produces. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const delayedSchedule: (schedule: Schedule) => Schedule; +/** + * Transforms a schedule to output the delay between each occurrence. + * + * **Details** + * + * This function modifies an existing schedule so that instead of producing its + * original output, it now returns the delay between each scheduled execution. + * + * @since 2.0.0 + * @category Monitoring + */ +export declare const delays: (self: Schedule) => Schedule; +/** + * Transforms both the input and output of a schedule. + * + * **Details** + * + * This function modifies an existing schedule by applying a transformation to + * both its input values and its output values. The provided transformation + * functions `onInput` and `onOutput` allow you to map the schedule to work with + * a different input type while modifying its outputs as well. + * + * @see {@link mapBothEffect} If you need to use effectful transformation functions. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapBoth: { + /** + * Transforms both the input and output of a schedule. + * + * **Details** + * + * This function modifies an existing schedule by applying a transformation to + * both its input values and its output values. The provided transformation + * functions `onInput` and `onOutput` allow you to map the schedule to work with + * a different input type while modifying its outputs as well. + * + * @see {@link mapBothEffect} If you need to use effectful transformation functions. + * + * @since 2.0.0 + * @category Mapping + */ + (options: { + readonly onInput: (in2: In2) => In; + readonly onOutput: (out: Out) => Out2; + }): (self: Schedule) => Schedule; + /** + * Transforms both the input and output of a schedule. + * + * **Details** + * + * This function modifies an existing schedule by applying a transformation to + * both its input values and its output values. The provided transformation + * functions `onInput` and `onOutput` allow you to map the schedule to work with + * a different input type while modifying its outputs as well. + * + * @see {@link mapBothEffect} If you need to use effectful transformation functions. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, options: { + readonly onInput: (in2: In2) => In; + readonly onOutput: (out: Out) => Out2; + }): Schedule; +}; +/** + * Transforms both the input and output of a schedule using effectful + * computations. + * + * **Details** + * + * This function modifies an existing schedule by applying effectful + * transformations to both its input values and its output values. The provided + * effectful functions `onInput` and `onOutput` allow you to transform inputs + * and outputs using computations that may involve additional logic, resource + * access, or side effects. + * + * @see {@link mapBoth} If you need to use pure transformation functions. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapBothEffect: { + /** + * Transforms both the input and output of a schedule using effectful + * computations. + * + * **Details** + * + * This function modifies an existing schedule by applying effectful + * transformations to both its input values and its output values. The provided + * effectful functions `onInput` and `onOutput` allow you to transform inputs + * and outputs using computations that may involve additional logic, resource + * access, or side effects. + * + * @see {@link mapBoth} If you need to use pure transformation functions. + * + * @since 2.0.0 + * @category Mapping + */ + (options: { + readonly onInput: (input: In2) => Effect.Effect; + readonly onOutput: (out: Out) => Effect.Effect; + }): (self: Schedule) => Schedule; + /** + * Transforms both the input and output of a schedule using effectful + * computations. + * + * **Details** + * + * This function modifies an existing schedule by applying effectful + * transformations to both its input values and its output values. The provided + * effectful functions `onInput` and `onOutput` allow you to transform inputs + * and outputs using computations that may involve additional logic, resource + * access, or side effects. + * + * @see {@link mapBoth} If you need to use pure transformation functions. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, options: { + readonly onInput: (input: In2) => Effect.Effect; + readonly onOutput: (out: Out) => Effect.Effect; + }): Schedule; +}; +/** + * Creates a driver to manually control the execution of a schedule. + * + * **Details** + * + * This function returns a `ScheduleDriver`, which allows stepping through a + * schedule manually while handling delays and sleeping appropriately. A driver + * is useful when you need fine-grained control over how a schedule progresses, + * rather than relying on automatic execution. + * + * The returned driver exposes methods for retrieving the current state, + * executing the next step, and resetting the schedule when needed. + * + * @since 2.0.0 + * @category getter + */ +export declare const driver: (self: Schedule) => Effect.Effect>; +/** + * Alias of {@link fromDelay}. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const duration: (duration: Duration.DurationInput) => Schedule; +/** + * Alias of {@link union}. + * + * @since 2.0.0 + * @category Alternatives + */ +export declare const either: { + /** + * Alias of {@link union}. + * + * @since 2.0.0 + * @category Alternatives + */ + (that: Schedule): (self: Schedule) => Schedule<[Out, Out2], In & In2, R2 | R>; + /** + * Alias of {@link union}. + * + * @since 2.0.0 + * @category Alternatives + */ + (self: Schedule, that: Schedule): Schedule<[Out, Out2], In & In2, R | R2>; +}; +/** + * Alias of {@link unionWith}. + * + * @since 2.0.0 + * @category Alternatives + */ +export declare const eitherWith: { + /** + * Alias of {@link unionWith}. + * + * @since 2.0.0 + * @category Alternatives + */ + (that: Schedule, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): (self: Schedule) => Schedule<[Out, Out2], In & In2, R2 | R>; + /** + * Alias of {@link unionWith}. + * + * @since 2.0.0 + * @category Alternatives + */ + (self: Schedule, that: Schedule, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<[Out, Out2], In & In2, R | R2>; +}; +/** + * Creates a schedule that tracks the total elapsed duration since it started. + * + * **Details** + * + * This schedule executes continuously and returns the total time that has + * passed since the first execution. The duration keeps increasing with each + * step, providing a way to measure elapsed time. + * + * This is useful for tracking execution time, monitoring delays, or + * implementing logic based on how long a process has been running. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const elapsed: Schedule; +/** + * Attaches a finalizer to a schedule that runs when the schedule completes. + * + * **Details** + * + * This function returns a new schedule that executes a given finalizer when the + * schedule reaches completion. Unlike `Effect.ensuring`, this method does not + * guarantee the finalizer will run in all cases. If the schedule never + * initializes or is not driven to completion, the finalizer may not execute. + * However, if the schedule decides not to continue, the finalizer will be + * invoked. + * + * This is useful for cleaning up resources, logging, or executing other side + * effects when a schedule completes. + * + * @since 2.0.0 + * @category Finalization + */ +export declare const ensuring: { + /** + * Attaches a finalizer to a schedule that runs when the schedule completes. + * + * **Details** + * + * This function returns a new schedule that executes a given finalizer when the + * schedule reaches completion. Unlike `Effect.ensuring`, this method does not + * guarantee the finalizer will run in all cases. If the schedule never + * initializes or is not driven to completion, the finalizer may not execute. + * However, if the schedule decides not to continue, the finalizer will be + * invoked. + * + * This is useful for cleaning up resources, logging, or executing other side + * effects when a schedule completes. + * + * @since 2.0.0 + * @category Finalization + */ + (finalizer: Effect.Effect): (self: Schedule) => Schedule; + /** + * Attaches a finalizer to a schedule that runs when the schedule completes. + * + * **Details** + * + * This function returns a new schedule that executes a given finalizer when the + * schedule reaches completion. Unlike `Effect.ensuring`, this method does not + * guarantee the finalizer will run in all cases. If the schedule never + * initializes or is not driven to completion, the finalizer may not execute. + * However, if the schedule decides not to continue, the finalizer will be + * invoked. + * + * This is useful for cleaning up resources, logging, or executing other side + * effects when a schedule completes. + * + * @since 2.0.0 + * @category Finalization + */ + (self: Schedule, finalizer: Effect.Effect): Schedule; +}; +/** + * Creates a schedule that recurs indefinitely with exponentially increasing + * delays. + * + * **Details** + * + * This schedule starts with an initial delay of `base` and increases the delay + * exponentially on each repetition using the formula `base * factor^n`, where + * `n` is the number of times the schedule has executed so far. If no `factor` + * is provided, it defaults to `2`, causing the delay to double after each + * execution. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const exponential: (base: Duration.DurationInput, factor?: number) => Schedule; +/** + * Creates a schedule that recurs indefinitely with Fibonacci-based increasing + * delays. + * + * **Details** + * + * This schedule starts with an initial delay of `one` and increases subsequent + * delays by summing the two previous delays, following the Fibonacci sequence. + * The delay pattern follows: `one, one, one + one, (one + one) + one, ...`, + * resulting in `1s, 1s, 2s, 3s, 5s, 8s, 13s, ...` if `one = 1s`. + * + * This is useful for progressive backoff strategies, where delays grow + * naturally over time without increasing as aggressively as an exponential + * schedule. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const fibonacci: (one: Duration.DurationInput) => Schedule; +/** + * Creates a schedule that recurs at a fixed interval. + * + * **Details** + * + * This schedule executes at regular, evenly spaced intervals, returning the + * number of times it has run so far. If the action being executed takes longer + * than the interval, the next execution will happen immediately to prevent + * "pile-ups," ensuring that the schedule remains consistent without overlapping + * executions. + * + * ```text + * |-----interval-----|-----interval-----|-----interval-----| + * |---------action--------||action|-----|action|-----------| + * ``` + * + * @see {@link spaced} If you need to run from the end of the last execution. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const fixed: (interval: Duration.DurationInput) => Schedule; +/** + * Creates a schedule that recurs indefinitely, producing a count of + * repetitions. + * + * **Details** + * + * This schedule runs indefinitely, returning an increasing count of executions + * (`0, 1, 2, 3, ...`). Each step increments the count by one, allowing tracking + * of how many times it has executed. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const forever: Schedule; +/** + * Creates a schedule that recurs once after a specified duration. + * + * **Details** + * + * This schedule executes a single time after waiting for the given duration. + * Once it has executed, it does not repeat. + * + * @see {@link fromDelays} If you need to create a schedule with multiple delays. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const fromDelay: (delay: Duration.DurationInput) => Schedule; +/** + * Creates a schedule that recurs once for each specified duration, applying the + * given delays sequentially. + * + * **Details** + * + * This schedule executes multiple times, each time waiting for the + * corresponding duration from the provided list of delays. The first execution + * waits for `delay`, the next for the second value in `delays`, and so on. Once + * all delays have been used, the schedule stops executing. + * + * This is useful for defining a custom delay sequence that does not follow a + * fixed pattern like exponential or Fibonacci backoff. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const fromDelays: (delay: Duration.DurationInput, ...delays: Array) => Schedule; +/** + * Creates a schedule that always recurs, transforming input values using the + * specified function. + * + * **Details** + * + * This schedule continuously executes and applies the given function `f` to + * each input value, producing a transformed output. The schedule itself does + * not control delays or stopping conditions; it simply transforms the input + * values as they are processed. + * + * This is useful when defining schedules that map inputs to outputs, allowing + * dynamic transformations of incoming data. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const fromFunction: (f: (a: A) => B) => Schedule; +/** + * Creates a schedule that always recurs, passing inputs directly as outputs. + * + * **Details** + * + * This schedule runs indefinitely, returning each input value as its output + * without modification. It effectively acts as a pass-through that simply + * echoes its input values at each step. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const identity: () => Schedule; +/** + * Transforms a schedule to pass through its inputs as outputs. + * + * **Details** + * + * This function modifies an existing schedule so that it returns its input + * values instead of its original output values. The schedule's timing remains + * unchanged, but its outputs are replaced with whatever inputs it receives. + * + * @since 2.0.0 + */ +export declare const passthrough: (self: Schedule) => Schedule; +/** + * Combines two schedules, continuing only if both schedules want to continue, + * using the longer delay. + * + * **Details** + * + * This function takes two schedules and creates a new schedule that only + * continues execution if both schedules allow it. The interval between + * recurrences is determined by the longer delay between the two schedules. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules. The input type is the intersection of both schedules' input + * types. + * + * This is useful when coordinating multiple scheduling conditions where + * execution should proceed only when both schedules permit it. + * + * @see {@link intersectWith} If you need to use a custom merge function. + * + * @since 2.0.0 + * @category Composition + */ +export declare const intersect: { + /** + * Combines two schedules, continuing only if both schedules want to continue, + * using the longer delay. + * + * **Details** + * + * This function takes two schedules and creates a new schedule that only + * continues execution if both schedules allow it. The interval between + * recurrences is determined by the longer delay between the two schedules. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules. The input type is the intersection of both schedules' input + * types. + * + * This is useful when coordinating multiple scheduling conditions where + * execution should proceed only when both schedules permit it. + * + * @see {@link intersectWith} If you need to use a custom merge function. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule): (self: Schedule) => Schedule<[Out, Out2], In & In2, R2 | R>; + /** + * Combines two schedules, continuing only if both schedules want to continue, + * using the longer delay. + * + * **Details** + * + * This function takes two schedules and creates a new schedule that only + * continues execution if both schedules allow it. The interval between + * recurrences is determined by the longer delay between the two schedules. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules. The input type is the intersection of both schedules' input + * types. + * + * This is useful when coordinating multiple scheduling conditions where + * execution should proceed only when both schedules permit it. + * + * @see {@link intersectWith} If you need to use a custom merge function. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule): Schedule<[Out, Out2], In & In2, R | R2>; +}; +/** + * Combines two schedules, continuing only if both want to continue, merging + * intervals using a custom function. + * + * **Details** + * + * This function takes two schedules and creates a new schedule that only + * continues execution if both schedules allow it. Instead of automatically + * using the longer delay (like {@link intersect}), this function applies a + * user-provided merge function `f` to determine the next interval between + * executions. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules, and the input type is the intersection of both schedules' + * input types. + * + * @since 2.0.0 + * @category Composition + */ +export declare const intersectWith: { + /** + * Combines two schedules, continuing only if both want to continue, merging + * intervals using a custom function. + * + * **Details** + * + * This function takes two schedules and creates a new schedule that only + * continues execution if both schedules allow it. Instead of automatically + * using the longer delay (like {@link intersect}), this function applies a + * user-provided merge function `f` to determine the next interval between + * executions. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules, and the input type is the intersection of both schedules' + * input types. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): (self: Schedule) => Schedule<[Out, Out2], In & In2, R2 | R>; + /** + * Combines two schedules, continuing only if both want to continue, merging + * intervals using a custom function. + * + * **Details** + * + * This function takes two schedules and creates a new schedule that only + * continues execution if both schedules allow it. Instead of automatically + * using the longer delay (like {@link intersect}), this function applies a + * user-provided merge function `f` to determine the next interval between + * executions. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules, and the input type is the intersection of both schedules' + * input types. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<[Out, Out2], In & In2, R | R2>; +}; +/** + * Returns a new schedule that randomly adjusts the interval size within a + * range. + * + * **Details** + * + * This function modifies a schedule so that its delay between executions is + * randomly varied within a range. By default, the delay is adjusted between + * `80%` (`0.8 * interval`) and `120%` (`1.2 * interval`) of the original + * interval size. + * + * This is useful for adding randomness to repeated executions, reducing + * contention in distributed systems, and avoiding synchronized execution + * patterns that can cause bottlenecks. + * + * @see {@link jitteredWith} If you need to specify custom min/max values. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const jittered: (self: Schedule) => Schedule; +/** + * Returns a new schedule that randomly adjusts the interval size within a + * user-defined range. + * + * **Details** + * + * This function modifies a schedule so that its delay between executions is + * randomly varied within a specified range. Instead of using the default `0.8 - + * 1.2` range like {@link jittered}, this function allows customizing the `min` + * and `max` multipliers. + * + * The delay for each step will be adjusted within `min * original_interval` and + * `max * original_interval`. If `min` and `max` are not provided, the defaults + * are `0.8` and `1.2`, respectively. + * + * This is useful for introducing randomness into scheduling behavior while + * having precise control over the jitter range. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const jitteredWith: { + /** + * Returns a new schedule that randomly adjusts the interval size within a + * user-defined range. + * + * **Details** + * + * This function modifies a schedule so that its delay between executions is + * randomly varied within a specified range. Instead of using the default `0.8 - + * 1.2` range like {@link jittered}, this function allows customizing the `min` + * and `max` multipliers. + * + * The delay for each step will be adjusted within `min * original_interval` and + * `max * original_interval`. If `min` and `max` are not provided, the defaults + * are `0.8` and `1.2`, respectively. + * + * This is useful for introducing randomness into scheduling behavior while + * having precise control over the jitter range. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (options: { + min?: number | undefined; + max?: number | undefined; + }): (self: Schedule) => Schedule; + /** + * Returns a new schedule that randomly adjusts the interval size within a + * user-defined range. + * + * **Details** + * + * This function modifies a schedule so that its delay between executions is + * randomly varied within a specified range. Instead of using the default `0.8 - + * 1.2` range like {@link jittered}, this function allows customizing the `min` + * and `max` multipliers. + * + * The delay for each step will be adjusted within `min * original_interval` and + * `max * original_interval`. If `min` and `max` are not provided, the defaults + * are `0.8` and `1.2`, respectively. + * + * This is useful for introducing randomness into scheduling behavior while + * having precise control over the jitter range. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (self: Schedule, options: { + min?: number | undefined; + max?: number | undefined; + }): Schedule; +}; +/** + * Creates a schedule that recurs indefinitely, increasing the delay linearly. + * + * **Details** + * + * This schedule starts with an initial delay of `base` and increases the delay + * on each recurrence in a linear fashion, following the formula: + * + * `delay = base * n` + * + * where `n` is the number of times the schedule has executed so far. This + * results in increasing intervals between executions. + * + * This is useful for implementing linear backoff strategies where the wait time + * between retries increases at a steady rate. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const linear: (base: Duration.DurationInput) => Schedule; +/** + * Returns a new schedule that transforms its output using the specified + * function. + * + * **Details** + * + * This function modifies an existing schedule so that its outputs are + * transformed by the provided function `f`. The timing and recurrence behavior + * of the schedule remain unchanged, but the values it produces are mapped to + * new values. + * + * This is useful when composing schedules where you need to adjust the output + * format or apply additional processing. + * + * @see {@link mapEffect} If you need to use an effectful transformation + * function. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const map: { + /** + * Returns a new schedule that transforms its output using the specified + * function. + * + * **Details** + * + * This function modifies an existing schedule so that its outputs are + * transformed by the provided function `f`. The timing and recurrence behavior + * of the schedule remain unchanged, but the values it produces are mapped to + * new values. + * + * This is useful when composing schedules where you need to adjust the output + * format or apply additional processing. + * + * @see {@link mapEffect} If you need to use an effectful transformation + * function. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (out: Out) => Out2): (self: Schedule) => Schedule; + /** + * Returns a new schedule that transforms its output using the specified + * function. + * + * **Details** + * + * This function modifies an existing schedule so that its outputs are + * transformed by the provided function `f`. The timing and recurrence behavior + * of the schedule remain unchanged, but the values it produces are mapped to + * new values. + * + * This is useful when composing schedules where you need to adjust the output + * format or apply additional processing. + * + * @see {@link mapEffect} If you need to use an effectful transformation + * function. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, f: (out: Out) => Out2): Schedule; +}; +/** + * Returns a new schedule that applies an effectful transformation to its + * output. + * + * **Details** + * + * This function modifies an existing schedule by applying an effectful function + * `f` to its output values. The timing and recurrence behavior of the schedule + * remain unchanged, but each output is mapped to a new value within an + * `Effect`. + * + * This is useful when you need to perform side effects or asynchronous + * transformations before passing the output forward. + * + * @see {@link map} If you need to use a pure transformation function. + * + * @since 2.0.0 + * @category Mapping + */ +export declare const mapEffect: { + /** + * Returns a new schedule that applies an effectful transformation to its + * output. + * + * **Details** + * + * This function modifies an existing schedule by applying an effectful function + * `f` to its output values. The timing and recurrence behavior of the schedule + * remain unchanged, but each output is mapped to a new value within an + * `Effect`. + * + * This is useful when you need to perform side effects or asynchronous + * transformations before passing the output forward. + * + * @see {@link map} If you need to use a pure transformation function. + * + * @since 2.0.0 + * @category Mapping + */ + (f: (out: Out) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that applies an effectful transformation to its + * output. + * + * **Details** + * + * This function modifies an existing schedule by applying an effectful function + * `f` to its output values. The timing and recurrence behavior of the schedule + * remain unchanged, but each output is mapped to a new value within an + * `Effect`. + * + * This is useful when you need to perform side effects or asynchronous + * transformations before passing the output forward. + * + * @see {@link map} If you need to use a pure transformation function. + * + * @since 2.0.0 + * @category Mapping + */ + (self: Schedule, f: (out: Out) => Effect.Effect): Schedule; +}; +/** + * Returns a new schedule that modifies the delay between executions using a + * custom function. + * + * **Details** + * + * This function transforms an existing schedule by applying `f` to modify the + * delay before each execution. The function receives both the schedule's output + * (`out`) and the originally computed delay (`duration`), and returns a new + * adjusted delay. + * + * @see {@link modifyDelayEffect} If you need to use an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const modifyDelay: { + /** + * Returns a new schedule that modifies the delay between executions using a + * custom function. + * + * **Details** + * + * This function transforms an existing schedule by applying `f` to modify the + * delay before each execution. The function receives both the schedule's output + * (`out`) and the originally computed delay (`duration`), and returns a new + * adjusted delay. + * + * @see {@link modifyDelayEffect} If you need to use an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (f: (out: Out, duration: Duration.Duration) => Duration.DurationInput): (self: Schedule) => Schedule; + /** + * Returns a new schedule that modifies the delay between executions using a + * custom function. + * + * **Details** + * + * This function transforms an existing schedule by applying `f` to modify the + * delay before each execution. The function receives both the schedule's output + * (`out`) and the originally computed delay (`duration`), and returns a new + * adjusted delay. + * + * @see {@link modifyDelayEffect} If you need to use an effectful function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (self: Schedule, f: (out: Out, duration: Duration.Duration) => Duration.DurationInput): Schedule; +}; +/** + * Returns a new schedule that modifies the delay before execution using an + * effectful function. + * + * **Details** + * + * This function takes an existing schedule and applies an effectful function + * `f` to dynamically adjust the delay before each execution. The function + * receives both the schedule's output (`out`) and the originally computed delay + * (`duration`), returning a new adjusted delay wrapped in an `Effect`. + * + * @see {@link modifyDelay} If you need to use a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ +export declare const modifyDelayEffect: { + /** + * Returns a new schedule that modifies the delay before execution using an + * effectful function. + * + * **Details** + * + * This function takes an existing schedule and applies an effectful function + * `f` to dynamically adjust the delay before each execution. The function + * receives both the schedule's output (`out`) and the originally computed delay + * (`duration`), returning a new adjusted delay wrapped in an `Effect`. + * + * @see {@link modifyDelay} If you need to use a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (f: (out: Out, duration: Duration.Duration) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that modifies the delay before execution using an + * effectful function. + * + * **Details** + * + * This function takes an existing schedule and applies an effectful function + * `f` to dynamically adjust the delay before each execution. The function + * receives both the schedule's output (`out`) and the originally computed delay + * (`duration`), returning a new adjusted delay wrapped in an `Effect`. + * + * @see {@link modifyDelay} If you need to use a pure function. + * + * @since 2.0.0 + * @category Timing & Delay + */ + (self: Schedule, f: (out: Out, duration: Duration.Duration) => Effect.Effect): Schedule; +}; +/** + * Returns a new schedule that executes an effect every time the schedule makes + * a decision. + * + * **Details** + * + * This function enhances an existing schedule by running an effectful function + * `f` whenever a scheduling decision is made. The function receives the current + * schedule output (`out`) and the decision (`ScheduleDecision`), allowing + * additional logic to be executed, such as logging, monitoring, or side + * effects. + * + * @since 2.0.0 + */ +export declare const onDecision: { + /** + * Returns a new schedule that executes an effect every time the schedule makes + * a decision. + * + * **Details** + * + * This function enhances an existing schedule by running an effectful function + * `f` whenever a scheduling decision is made. The function receives the current + * schedule output (`out`) and the decision (`ScheduleDecision`), allowing + * additional logic to be executed, such as logging, monitoring, or side + * effects. + * + * @since 2.0.0 + */ + (f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that executes an effect every time the schedule makes + * a decision. + * + * **Details** + * + * This function enhances an existing schedule by running an effectful function + * `f` whenever a scheduling decision is made. The function receives the current + * schedule output (`out`) and the decision (`ScheduleDecision`), allowing + * additional logic to be executed, such as logging, monitoring, or side + * effects. + * + * @since 2.0.0 + */ + (self: Schedule, f: (out: Out, decision: ScheduleDecision.ScheduleDecision) => Effect.Effect): Schedule; +}; +/** + * A schedule that executes only once and then stops. + * + * **Details** + * + * This schedule triggers a single execution and then terminates. It does not + * repeat or apply any additional logic. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const once: Schedule; +/** + * Returns a new schedule with a provided context, eliminating the need for + * external dependencies. + * + * **Details** + * + * This function supplies a required `context` to a schedule, allowing it to run + * without requiring external dependencies. After calling this function, the + * schedule can be used freely without needing to pass a context at execution + * time. + * + * This is useful when working with schedules that rely on contextual + * information, such as logging services, database connections, or configuration + * settings. + * + * @since 2.0.0 + * @category Context + */ +export declare const provideContext: { + /** + * Returns a new schedule with a provided context, eliminating the need for + * external dependencies. + * + * **Details** + * + * This function supplies a required `context` to a schedule, allowing it to run + * without requiring external dependencies. After calling this function, the + * schedule can be used freely without needing to pass a context at execution + * time. + * + * This is useful when working with schedules that rely on contextual + * information, such as logging services, database connections, or configuration + * settings. + * + * @since 2.0.0 + * @category Context + */ + (context: Context.Context): (self: Schedule) => Schedule; + /** + * Returns a new schedule with a provided context, eliminating the need for + * external dependencies. + * + * **Details** + * + * This function supplies a required `context` to a schedule, allowing it to run + * without requiring external dependencies. After calling this function, the + * schedule can be used freely without needing to pass a context at execution + * time. + * + * This is useful when working with schedules that rely on contextual + * information, such as logging services, database connections, or configuration + * settings. + * + * @since 2.0.0 + * @category Context + */ + (self: Schedule, context: Context.Context): Schedule; +}; +/** + * Returns a new schedule with a single required service provided, eliminating + * the need for external dependencies. + * + * **Details** + * + * This function supplies a single service dependency to a schedule, allowing it + * to run without requiring that service externally. If a schedule depends on + * multiple services, consider using `provideContext` instead. + * + * This is useful when working with schedules that require a specific service, + * such as logging, metrics, or configuration retrieval. + * + * @since 2.0.0 + * @category Context + */ +export declare const provideService: { + /** + * Returns a new schedule with a single required service provided, eliminating + * the need for external dependencies. + * + * **Details** + * + * This function supplies a single service dependency to a schedule, allowing it + * to run without requiring that service externally. If a schedule depends on + * multiple services, consider using `provideContext` instead. + * + * This is useful when working with schedules that require a specific service, + * such as logging, metrics, or configuration retrieval. + * + * @since 2.0.0 + * @category Context + */ + (tag: Context.Tag, service: Types.NoInfer): (self: Schedule) => Schedule>; + /** + * Returns a new schedule with a single required service provided, eliminating + * the need for external dependencies. + * + * **Details** + * + * This function supplies a single service dependency to a schedule, allowing it + * to run without requiring that service externally. If a schedule depends on + * multiple services, consider using `provideContext` instead. + * + * This is useful when working with schedules that require a specific service, + * such as logging, metrics, or configuration retrieval. + * + * @since 2.0.0 + * @category Context + */ + (self: Schedule, tag: Context.Tag, service: Types.NoInfer): Schedule>; +}; +/** + * A schedule that recurs until the given predicate evaluates to true. + * + * **Details** + * + * This schedule will continue executing as long as the provided predicate `f` + * returns `false` for the input value. Once `f` evaluates to `true`, the + * schedule stops recurring. + * + * This is useful for defining schedules that should stop when a certain + * condition is met, such as detecting a success state, reaching a threshold, or + * avoiding unnecessary retries. + * + * @see {@link recurUntilEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const recurUntil: (f: Predicate) => Schedule; +/** + * A schedule that recurs until the given effectful predicate evaluates to true. + * + * **Details** + * + * This schedule continues executing as long as the provided effectful predicate + * `f` returns `false`. Once `f` evaluates to `true`, the schedule stops + * recurring. Unlike {@link recurUntil}, this function allows the stopping + * condition to be computed asynchronously or based on external dependencies. + * + * This is useful when the stopping condition depends on an effectful + * computation, such as checking a database, making an API call, or retrieving + * system state dynamically. + * + * @see {@link recurUntil} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const recurUntilEffect: (f: (a: A) => Effect.Effect) => Schedule; +/** + * A schedule that recurs until the input value matches a partial function, then + * maps the value. + * + * **Details** + * + * This schedule continues executing until the provided partial function `pf` + * returns `Some(value)`. At that point, it stops and maps the resulting value + * to an `Option`. If `pf` returns `None`, the schedule continues. + * + * This is useful when defining schedules that should stop once a certain + * condition is met and transform the final value before completion. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const recurUntilOption: (pf: (a: A) => Option.Option) => Schedule, A>; +/** + * A schedule that recurs until the specified duration has elapsed. + * + * **Details** + * + * This schedule continues executing for the given `duration`, after which it + * stops. The schedule outputs the elapsed time on each recurrence. + * + * This is useful for limiting the duration of retries, enforcing time-based + * constraints, or ensuring that an operation does not run indefinitely. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const recurUpTo: (duration: Duration.DurationInput) => Schedule; +/** + * A schedule that recurs as long as the given predicate evaluates to true. + * + * **Details* + * + * This schedule continues executing as long as the provided predicate `f` + * returns `true` for the input value. Once `f` evaluates to `false`, the + * schedule stops recurring. + * + * @see {@link recurWhileEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const recurWhile: (f: Predicate) => Schedule; +/** + * A schedule that recurs as long as the given effectful predicate evaluates to + * true. + * + * **Details** + * + * This schedule continues executing as long as the provided effectful predicate + * `f` returns `true`. Once `f` evaluates to `false`, the schedule stops + * recurring. Unlike {@link recurWhile}, this function allows the condition to + * be computed dynamically using an effectful computation. + * + * @see {@link recurWhile} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const recurWhileEffect: (f: (a: A) => Effect.Effect) => Schedule; +/** + * A schedule that recurs a fixed number of times before terminating. + * + * **Details** + * + * This schedule will continue executing until it has been stepped `n` times, + * after which it will stop. The output of the schedule is the current count of + * recurrences. + * + * @category Constructors + * @since 2.0.0 + */ +export declare const recurs: (n: number) => Schedule; +/** + * Returns a new schedule that folds over the outputs of this one. + * + * **Details** + * + * This schedule transforms the output by accumulating values over time using a + * reducer function `f`. It starts with an initial value `zero` and updates it + * each time the schedule produces an output. + * + * This is useful for tracking statistics, aggregating results, or summarizing + * data across multiple executions. + * + * @see {@link reduceEffect} If you need to use an effectful reducer function. + * + * @since 2.0.0 + * @category Reducing + */ +export declare const reduce: { + /** + * Returns a new schedule that folds over the outputs of this one. + * + * **Details** + * + * This schedule transforms the output by accumulating values over time using a + * reducer function `f`. It starts with an initial value `zero` and updates it + * each time the schedule produces an output. + * + * This is useful for tracking statistics, aggregating results, or summarizing + * data across multiple executions. + * + * @see {@link reduceEffect} If you need to use an effectful reducer function. + * + * @since 2.0.0 + * @category Reducing + */ + (zero: Z, f: (z: Z, out: Out) => Z): (self: Schedule) => Schedule; + /** + * Returns a new schedule that folds over the outputs of this one. + * + * **Details** + * + * This schedule transforms the output by accumulating values over time using a + * reducer function `f`. It starts with an initial value `zero` and updates it + * each time the schedule produces an output. + * + * This is useful for tracking statistics, aggregating results, or summarizing + * data across multiple executions. + * + * @see {@link reduceEffect} If you need to use an effectful reducer function. + * + * @since 2.0.0 + * @category Reducing + */ + (self: Schedule, zero: Z, f: (z: Z, out: Out) => Z): Schedule; +}; +/** + * Returns a new schedule that effectfully folds over the outputs of this one. + * + * **Details** + * + * This schedule accumulates outputs over time using an effectful reducer + * function `f`. It starts with an initial value `zero` and updates it + * asynchronously or based on external dependencies. + * + * This is useful for asynchronous state tracking, logging, external metrics + * aggregation, or any scenario where accumulation needs to involve an effectful + * computation. + * + * @see {@link reduce} If you need to use a pure reducer function. + * + * @since 2.0.0 + * @category Reducing + */ +export declare const reduceEffect: { + /** + * Returns a new schedule that effectfully folds over the outputs of this one. + * + * **Details** + * + * This schedule accumulates outputs over time using an effectful reducer + * function `f`. It starts with an initial value `zero` and updates it + * asynchronously or based on external dependencies. + * + * This is useful for asynchronous state tracking, logging, external metrics + * aggregation, or any scenario where accumulation needs to involve an effectful + * computation. + * + * @see {@link reduce} If you need to use a pure reducer function. + * + * @since 2.0.0 + * @category Reducing + */ + (zero: Z, f: (z: Z, out: Out) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that effectfully folds over the outputs of this one. + * + * **Details** + * + * This schedule accumulates outputs over time using an effectful reducer + * function `f`. It starts with an initial value `zero` and updates it + * asynchronously or based on external dependencies. + * + * This is useful for asynchronous state tracking, logging, external metrics + * aggregation, or any scenario where accumulation needs to involve an effectful + * computation. + * + * @see {@link reduce} If you need to use a pure reducer function. + * + * @since 2.0.0 + * @category Reducing + */ + (self: Schedule, zero: Z, f: (z: Z, out: Out) => Effect.Effect): Schedule; +}; +/** + * Alias of {@link forever}. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const repeatForever: Schedule; +/** + * Returns a new schedule that outputs the number of repetitions of this one. + * + * **Details** + * + * This schedule tracks how many times the given schedule has executed and + * outputs the count instead of the original values. The first execution starts + * at `0`, and the count increases with each recurrence. + * + * @since 2.0.0 + * @category Monitoring + */ +export declare const repetitions: (self: Schedule) => Schedule; +/** + * Returns a new schedule that automatically resets to its initial state after a + * period of inactivity defined by `duration`. + * + * **Details** + * + * This function modifies a schedule so that if no inputs are received for the + * specified `duration`, the schedule resets as if it were new. + * + * @see {@link resetWhen} If you need to reset based on output values. + * + * @since 2.0.0 + * @category State Management + */ +export declare const resetAfter: { + /** + * Returns a new schedule that automatically resets to its initial state after a + * period of inactivity defined by `duration`. + * + * **Details** + * + * This function modifies a schedule so that if no inputs are received for the + * specified `duration`, the schedule resets as if it were new. + * + * @see {@link resetWhen} If you need to reset based on output values. + * + * @since 2.0.0 + * @category State Management + */ + (duration: Duration.DurationInput): (self: Schedule) => Schedule; + /** + * Returns a new schedule that automatically resets to its initial state after a + * period of inactivity defined by `duration`. + * + * **Details** + * + * This function modifies a schedule so that if no inputs are received for the + * specified `duration`, the schedule resets as if it were new. + * + * @see {@link resetWhen} If you need to reset based on output values. + * + * @since 2.0.0 + * @category State Management + */ + (self: Schedule, duration: Duration.DurationInput): Schedule; +}; +/** + * Resets the schedule when the specified predicate on the schedule output + * evaluates to `true`. + * + * **Details** + * + * This function modifies a schedule so that it resets to its initial state + * whenever the provided predicate `f` returns `true` for an output value. + * + * @see {@link resetAfter} If you need to reset based on inactivity. + * + * @since 2.0.0 + * @category State Management + */ +export declare const resetWhen: { + /** + * Resets the schedule when the specified predicate on the schedule output + * evaluates to `true`. + * + * **Details** + * + * This function modifies a schedule so that it resets to its initial state + * whenever the provided predicate `f` returns `true` for an output value. + * + * @see {@link resetAfter} If you need to reset based on inactivity. + * + * @since 2.0.0 + * @category State Management + */ + (f: Predicate): (self: Schedule) => Schedule; + /** + * Resets the schedule when the specified predicate on the schedule output + * evaluates to `true`. + * + * **Details** + * + * This function modifies a schedule so that it resets to its initial state + * whenever the provided predicate `f` returns `true` for an output value. + * + * @see {@link resetAfter} If you need to reset based on inactivity. + * + * @since 2.0.0 + * @category State Management + */ + (self: Schedule, f: Predicate): Schedule; +}; +/** + * Runs a schedule using the provided inputs and collects all outputs. + * + * **Details** + * + * This function executes a given schedule with a sequence of input values and + * accumulates all outputs into a `Chunk`. The schedule starts execution at the + * specified `now` timestamp and proceeds according to its defined behavior. + * + * This is useful for batch processing, simulating execution, or testing + * schedules with predefined input sequences. + * + * @since 2.0.0 + * @category Execution + */ +export declare const run: { + /** + * Runs a schedule using the provided inputs and collects all outputs. + * + * **Details** + * + * This function executes a given schedule with a sequence of input values and + * accumulates all outputs into a `Chunk`. The schedule starts execution at the + * specified `now` timestamp and proceeds according to its defined behavior. + * + * This is useful for batch processing, simulating execution, or testing + * schedules with predefined input sequences. + * + * @since 2.0.0 + * @category Execution + */ + (now: number, input: Iterable): (self: Schedule) => Effect.Effect, never, R>; + /** + * Runs a schedule using the provided inputs and collects all outputs. + * + * **Details** + * + * This function executes a given schedule with a sequence of input values and + * accumulates all outputs into a `Chunk`. The schedule starts execution at the + * specified `now` timestamp and proceeds according to its defined behavior. + * + * This is useful for batch processing, simulating execution, or testing + * schedules with predefined input sequences. + * + * @since 2.0.0 + * @category Execution + */ + (self: Schedule, now: number, input: Iterable): Effect.Effect, never, R>; +}; +/** + * Returns a schedule that recurs continuously, with each repetition + * spaced by the specified `duration` from the last run. + * + * **Details** + * + * This schedule ensures that executions occur at a fixed interval, + * maintaining a consistent delay between repetitions. The delay starts + * from the end of the last execution, not from the schedule start time. + * + * @see {@link fixed} If you need to run at a fixed interval from the start. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const spaced: (duration: Duration.DurationInput) => Schedule; +/** + * A schedule that does not recur and stops immediately. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const stop: Schedule; +/** + * Returns a schedule that recurs indefinitely, always producing the specified + * constant value. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const succeed: (value: A) => Schedule; +/** + * Returns a schedule that recurs indefinitely, evaluating the given function to + * produce a constant value. + * + * @category Constructors + * @since 2.0.0 + */ +export declare const sync: (evaluate: LazyArg) => Schedule; +/** + * Returns a new schedule that runs the given effectful function for each input + * before continuing execution. + * + * **Details** + * + * This function allows side effects to be performed on each input processed by + * the schedule. It does not modify the schedule’s behavior but ensures that the + * provided function `f` runs before each step. + * + * @since 2.0.0 + * @category Tapping + */ +export declare const tapInput: { + /** + * Returns a new schedule that runs the given effectful function for each input + * before continuing execution. + * + * **Details** + * + * This function allows side effects to be performed on each input processed by + * the schedule. It does not modify the schedule’s behavior but ensures that the + * provided function `f` runs before each step. + * + * @since 2.0.0 + * @category Tapping + */ + (f: (input: In2) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that runs the given effectful function for each input + * before continuing execution. + * + * **Details** + * + * This function allows side effects to be performed on each input processed by + * the schedule. It does not modify the schedule’s behavior but ensures that the + * provided function `f` runs before each step. + * + * @since 2.0.0 + * @category Tapping + */ + (self: Schedule, f: (input: In2) => Effect.Effect): Schedule; +}; +/** + * Returns a new schedule that runs the given effectful function for each output + * before continuing execution. + * + * **Details** + * + * This function allows side effects to be performed on each output produced by + * the schedule. It does not modify the schedule’s behavior but ensures that the + * provided function `f` runs after each step. + * + * @since 2.0.0 + * @category Tapping + */ +export declare const tapOutput: { + /** + * Returns a new schedule that runs the given effectful function for each output + * before continuing execution. + * + * **Details** + * + * This function allows side effects to be performed on each output produced by + * the schedule. It does not modify the schedule’s behavior but ensures that the + * provided function `f` runs after each step. + * + * @since 2.0.0 + * @category Tapping + */ + (f: (out: Types.NoInfer) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that runs the given effectful function for each output + * before continuing execution. + * + * **Details** + * + * This function allows side effects to be performed on each output produced by + * the schedule. It does not modify the schedule’s behavior but ensures that the + * provided function `f` runs after each step. + * + * @since 2.0.0 + * @category Tapping + */ + (self: Schedule, f: (out: Out) => Effect.Effect): Schedule; +}; +/** + * Creates a schedule that repeatedly applies a function to transform a state + * value, producing a sequence of values. + * + * **Details** + * + * This function starts with an `initial` value and applies `f` recursively to + * generate the next state at each step. The schedule continues indefinitely, + * producing a stream of values by unfolding the state over time. + * + * @since 2.0.0 + * @category Constructors + */ +export declare const unfold: (initial: A, f: (a: A) => A) => Schedule; +/** + * Combines two schedules, continuing execution as long as at least one of them + * allows it, using the shorter delay. + * + * **Details** + * + * This function combines two schedules into a single schedule that executes in + * parallel. If either schedule allows continuation, the merged schedule + * continues. When both schedules produce delays, the schedule selects the + * shorter delay to determine the next step. + * + * The output of the new schedule is a tuple containing the outputs of both + * schedules. The input type is the intersection of both schedules' input types. + * + * This is useful for scenarios where multiple scheduling conditions should be + * considered, ensuring execution proceeds if at least one schedule permits it. + * + * @see {@link unionWith} If you need to use a custom merge function. + * + * @since 2.0.0 + * @category Composition + */ +export declare const union: { + /** + * Combines two schedules, continuing execution as long as at least one of them + * allows it, using the shorter delay. + * + * **Details** + * + * This function combines two schedules into a single schedule that executes in + * parallel. If either schedule allows continuation, the merged schedule + * continues. When both schedules produce delays, the schedule selects the + * shorter delay to determine the next step. + * + * The output of the new schedule is a tuple containing the outputs of both + * schedules. The input type is the intersection of both schedules' input types. + * + * This is useful for scenarios where multiple scheduling conditions should be + * considered, ensuring execution proceeds if at least one schedule permits it. + * + * @see {@link unionWith} If you need to use a custom merge function. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule): (self: Schedule) => Schedule<[Out, Out2], In & In2, R2 | R>; + /** + * Combines two schedules, continuing execution as long as at least one of them + * allows it, using the shorter delay. + * + * **Details** + * + * This function combines two schedules into a single schedule that executes in + * parallel. If either schedule allows continuation, the merged schedule + * continues. When both schedules produce delays, the schedule selects the + * shorter delay to determine the next step. + * + * The output of the new schedule is a tuple containing the outputs of both + * schedules. The input type is the intersection of both schedules' input types. + * + * This is useful for scenarios where multiple scheduling conditions should be + * considered, ensuring execution proceeds if at least one schedule permits it. + * + * @see {@link unionWith} If you need to use a custom merge function. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule): Schedule<[Out, Out2], In & In2, R | R2>; +}; +/** + * Combines two schedules, continuing execution as long as at least one of them + * wants to continue, merging their intervals using a custom merge function. + * + * **Details** + * + * This function allows you to combine two schedules while defining how their + * intervals should be merged. Unlike {@link union}, which simply selects the + * shorter delay, this function lets you specify a custom merging strategy for + * the schedules’ intervals. + * + * The merged schedule continues execution as long as at least one of the input + * schedules allows it. The next interval is determined by applying the provided + * merge function to the intervals of both schedules. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules. The input type is the intersection of both schedules' input + * types. + * + * @see {@link union} If you need to use the shorter delay. + * + * @since 2.0.0 + * @category Composition + */ +export declare const unionWith: { + /** + * Combines two schedules, continuing execution as long as at least one of them + * wants to continue, merging their intervals using a custom merge function. + * + * **Details** + * + * This function allows you to combine two schedules while defining how their + * intervals should be merged. Unlike {@link union}, which simply selects the + * shorter delay, this function lets you specify a custom merging strategy for + * the schedules’ intervals. + * + * The merged schedule continues execution as long as at least one of the input + * schedules allows it. The next interval is determined by applying the provided + * merge function to the intervals of both schedules. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules. The input type is the intersection of both schedules' input + * types. + * + * @see {@link union} If you need to use the shorter delay. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): (self: Schedule) => Schedule<[Out, Out2], In & In2, R2 | R>; + /** + * Combines two schedules, continuing execution as long as at least one of them + * wants to continue, merging their intervals using a custom merge function. + * + * **Details** + * + * This function allows you to combine two schedules while defining how their + * intervals should be merged. Unlike {@link union}, which simply selects the + * shorter delay, this function lets you specify a custom merging strategy for + * the schedules’ intervals. + * + * The merged schedule continues execution as long as at least one of the input + * schedules allows it. The next interval is determined by applying the provided + * merge function to the intervals of both schedules. + * + * The output of the resulting schedule is a tuple containing the outputs of + * both schedules. The input type is the intersection of both schedules' input + * types. + * + * @see {@link union} If you need to use the shorter delay. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule, f: (x: Intervals.Intervals, y: Intervals.Intervals) => Intervals.Intervals): Schedule<[Out, Out2], In & In2, R | R2>; +}; +/** + * Returns a new schedule that stops execution when the given predicate on the + * input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it continues executing + * only while the provided predicate returns `false` for incoming inputs. Once + * an input satisfies the condition, the schedule terminates immediately. + * + * @see {@link untilInputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const untilInput: { + /** + * Returns a new schedule that stops execution when the given predicate on the + * input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it continues executing + * only while the provided predicate returns `false` for incoming inputs. Once + * an input satisfies the condition, the schedule terminates immediately. + * + * @see {@link untilInputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: Predicate): (self: Schedule) => Schedule; + /** + * Returns a new schedule that stops execution when the given predicate on the + * input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it continues executing + * only while the provided predicate returns `false` for incoming inputs. Once + * an input satisfies the condition, the schedule terminates immediately. + * + * @see {@link untilInputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: Predicate): Schedule; +}; +/** + * Returns a new schedule that stops execution when the given effectful + * predicate on the input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it continues executing + * only while the provided effectful predicate returns `false` for incoming + * inputs. The predicate is an `Effect`, meaning it can involve asynchronous + * computations or dependency-based logic. + * + * @see {@link untilInput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const untilInputEffect: { + /** + * Returns a new schedule that stops execution when the given effectful + * predicate on the input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it continues executing + * only while the provided effectful predicate returns `false` for incoming + * inputs. The predicate is an `Effect`, meaning it can involve asynchronous + * computations or dependency-based logic. + * + * @see {@link untilInput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: (input: In) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that stops execution when the given effectful + * predicate on the input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it continues executing + * only while the provided effectful predicate returns `false` for incoming + * inputs. The predicate is an `Effect`, meaning it can involve asynchronous + * computations or dependency-based logic. + * + * @see {@link untilInput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: (input: In) => Effect.Effect): Schedule; +}; +/** + * Returns a new schedule that stops execution when the given predicate on the + * output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * executing while the given predicate returns false for its output values. Once + * the predicate evaluates to `true`, execution stops. + * + * The output of the resulting schedule remains the same, but its duration is + * now constrained by a stopping condition based on its own output. + * + * @see {@link untilOutputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const untilOutput: { + /** + * Returns a new schedule that stops execution when the given predicate on the + * output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * executing while the given predicate returns false for its output values. Once + * the predicate evaluates to `true`, execution stops. + * + * The output of the resulting schedule remains the same, but its duration is + * now constrained by a stopping condition based on its own output. + * + * @see {@link untilOutputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: Predicate): (self: Schedule) => Schedule; + /** + * Returns a new schedule that stops execution when the given predicate on the + * output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * executing while the given predicate returns false for its output values. Once + * the predicate evaluates to `true`, execution stops. + * + * The output of the resulting schedule remains the same, but its duration is + * now constrained by a stopping condition based on its own output. + * + * @see {@link untilOutputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: Predicate): Schedule; +}; +/** + * Returns a new schedule that stops execution when the given effectful + * predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * executing while the provided effectful predicate returns `false` for its + * output values. Once the predicate returns `true`, execution stops. + * + * @see {@link untilOutput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const untilOutputEffect: { + /** + * Returns a new schedule that stops execution when the given effectful + * predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * executing while the provided effectful predicate returns `false` for its + * output values. Once the predicate returns `true`, execution stops. + * + * @see {@link untilOutput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: (out: Out) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that stops execution when the given effectful + * predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * executing while the provided effectful predicate returns `false` for its + * output values. Once the predicate returns `true`, execution stops. + * + * @see {@link untilOutput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: (out: Out) => Effect.Effect): Schedule; +}; +/** + * Returns a new schedule that limits execution to a fixed duration. + * + * **Details** + * + * This function modifies an existing schedule to stop execution after a + * specified duration has passed. The schedule continues as normal until the + * duration is reached, at which point it stops automatically. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const upTo: { + /** + * Returns a new schedule that limits execution to a fixed duration. + * + * **Details** + * + * This function modifies an existing schedule to stop execution after a + * specified duration has passed. The schedule continues as normal until the + * duration is reached, at which point it stops automatically. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (duration: Duration.DurationInput): (self: Schedule) => Schedule; + /** + * Returns a new schedule that limits execution to a fixed duration. + * + * **Details** + * + * This function modifies an existing schedule to stop execution after a + * specified duration has passed. The schedule continues as normal until the + * duration is reached, at which point it stops automatically. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, duration: Duration.DurationInput): Schedule; +}; +/** + * Returns a new schedule that continues execution as long as the given + * predicate on the input is true. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while a specified predicate holds true for its input. If the + * predicate evaluates to `false` at any step, the schedule stops. + * + * @see {@link whileInputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const whileInput: { + /** + * Returns a new schedule that continues execution as long as the given + * predicate on the input is true. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while a specified predicate holds true for its input. If the + * predicate evaluates to `false` at any step, the schedule stops. + * + * @see {@link whileInputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: Predicate): (self: Schedule) => Schedule; + /** + * Returns a new schedule that continues execution as long as the given + * predicate on the input is true. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while a specified predicate holds true for its input. If the + * predicate evaluates to `false` at any step, the schedule stops. + * + * @see {@link whileInputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: Predicate): Schedule; +}; +/** + * Returns a new schedule that continues execution for as long as the given + * effectful predicate on the input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while an effectful predicate holds true for its input. If the + * predicate evaluates to `false` at any step, the schedule stops. + * + * @see {@link whileInput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const whileInputEffect: { + /** + * Returns a new schedule that continues execution for as long as the given + * effectful predicate on the input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while an effectful predicate holds true for its input. If the + * predicate evaluates to `false` at any step, the schedule stops. + * + * @see {@link whileInput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: (input: In) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that continues execution for as long as the given + * effectful predicate on the input evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while an effectful predicate holds true for its input. If the + * predicate evaluates to `false` at any step, the schedule stops. + * + * @see {@link whileInput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: (input: In) => Effect.Effect): Schedule; +}; +/** + * Returns a new schedule that continues execution for as long as the given + * predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while a provided condition holds true for its output. If the + * predicate returns `false`, the schedule stops. + * + * @see {@link whileOutputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const whileOutput: { + /** + * Returns a new schedule that continues execution for as long as the given + * predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while a provided condition holds true for its output. If the + * predicate returns `false`, the schedule stops. + * + * @see {@link whileOutputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: Predicate): (self: Schedule) => Schedule; + /** + * Returns a new schedule that continues execution for as long as the given + * predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while a provided condition holds true for its output. If the + * predicate returns `false`, the schedule stops. + * + * @see {@link whileOutputEffect} If you need to use an effectful predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: Predicate): Schedule; +}; +/** + * Returns a new schedule that continues execution for as long as the given + * effectful predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while an effectful condition holds true for its output. If the + * effectful predicate returns `false`, the schedule stops. + * + * @see {@link whileOutput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ +export declare const whileOutputEffect: { + /** + * Returns a new schedule that continues execution for as long as the given + * effectful predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while an effectful condition holds true for its output. If the + * effectful predicate returns `false`, the schedule stops. + * + * @see {@link whileOutput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (f: (out: Out) => Effect.Effect): (self: Schedule) => Schedule; + /** + * Returns a new schedule that continues execution for as long as the given + * effectful predicate on the output evaluates to `true`. + * + * **Details** + * + * This function modifies an existing schedule so that it only continues + * execution while an effectful condition holds true for its output. If the + * effectful predicate returns `false`, the schedule stops. + * + * @see {@link whileOutput} If you need to use a pure predicate. + * + * @since 2.0.0 + * @category Recurrence Conditions + */ + (self: Schedule, f: (out: Out) => Effect.Effect): Schedule; +}; +/** + * Creates a schedule that divides time into fixed `interval`-long windows, + * triggering execution at the start of each new window. + * + * **Details** + * + * This function produces a schedule that waits until the next time window + * boundary before executing. Each window spans a fixed duration specified by + * `interval`. If an action completes midway through a window, the schedule + * waits until the next full window starts before proceeding. + * + * For example, `windowed(Duration.seconds(10))` would produce a schedule as + * follows: + * + * ```text + * 10s 10s 10s 10s + * |----------|----------|----------|----------| + * |action------|sleep---|act|-sleep|action----| + * ``` + * + * @since 2.0.0 + * @category Constructors + */ +export declare const windowed: (interval: Duration.DurationInput) => Schedule; +/** + * The same as {@link intersect} but ignores the right output. + * + * @since 2.0.0 + * @category Composition + */ +export declare const zipLeft: { + /** + * The same as {@link intersect} but ignores the right output. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule): (self: Schedule) => Schedule; + /** + * The same as {@link intersect} but ignores the right output. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule): Schedule; +}; +/** + * The same as {@link intersect} but ignores the left output. + * + * @since 2.0.0 + * @category Composition + */ +export declare const zipRight: { + /** + * The same as {@link intersect} but ignores the left output. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule): (self: Schedule) => Schedule; + /** + * The same as {@link intersect} but ignores the left output. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule): Schedule; +}; +/** + * Equivalent to {@link intersect} followed by {@link map}. + * + * @since 2.0.0 + * @category Composition + */ +export declare const zipWith: { + /** + * Equivalent to {@link intersect} followed by {@link map}. + * + * @since 2.0.0 + * @category Composition + */ + (that: Schedule, f: (out: Out, out2: Out2) => Out3): (self: Schedule) => Schedule; + /** + * Equivalent to {@link intersect} followed by {@link map}. + * + * @since 2.0.0 + * @category Composition + */ + (self: Schedule, that: Schedule, f: (out: Out, out2: Out2) => Out3): Schedule; +}; +/** + * @since 3.15.0 + * @category models + */ +export interface CurrentIterationMetadata { + readonly _: unique symbol; +} +/** + * @since 3.15.0 + * @category models + */ +export interface IterationMetadata { + readonly input: unknown; + readonly output: unknown; + readonly recurrence: number; + readonly start: number; + readonly now: number; + readonly elapsed: Duration.Duration; + readonly elapsedSincePrevious: Duration.Duration; +} +/** + * @since 3.15.0 + * @category models + */ +export declare const CurrentIterationMetadata: Context.Reference; +//# sourceMappingURL=Schedule.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Schedule.d.ts.map b/backend/node_modules/effect/dist/dts/Schedule.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..181e6b46e981616fba05f6ca339712a14f0bfcca --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Schedule.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Schedule.d.ts","sourceRoot":"","sources":["../../src/Schedule.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAA;AACtC,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAA;AACpC,OAAO,KAAK,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,KAAK,SAAS,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAAgC,CAAA;AAEpE;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,OAAO,MAAsC,CAAA;AAEhF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,WAAW,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,KAAK,CAAE,SAAQ,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ;IAChH;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAA;IACrB;;OAEG;IACH,IAAI,CACF,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,GAAG,GACT,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAA;CACnF;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,QAAQ,CAAC;IAChC;;;OAGG;IACH,UAAiB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QAC7C,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE;YACzB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;YACnC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC,CAAA;YACrC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;SAChC,CAAA;KACF;IAED;;OAEG;IACH,UAAiB,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QACnD,QAAQ,CAAC,CAAC,oBAAoB,CAAC,EAAE;YAC/B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;YACnC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC,CAAA;YACrC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;SAChC,CAAA;KACF;CACF;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,KAAK,CAAE,SAAQ,QAAQ,CAAC,cAAc,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC;IAClH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACtC,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAA;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAA;IAC/D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACnC,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAA;CAC7D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,KAAK,EAChD,OAAO,EAAE,CAAC,EACV,IAAI,EAAE,CACJ,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,CAAC,KACL,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAC/E,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAA0B,CAAA;AAElD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAuB,CAAA;AAErG;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,QAAQ,CAAC,aAAa,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IAC3G;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACpF,CAAA;AAErB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE;IAC3B;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAC9I;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC,GAChE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACH,CAAA;AAE3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAClI;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAC5G,CAAA;AAEpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAChJ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACpH,CAAA;AAE1B;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,EAAE,EAAE;IACf;;;;;;;;;;;;;;OAcG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACpF;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACnE,CAAA;AAEf;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAmB,CAAA;AAGxG;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS,EAAE;IAEtB;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAE7I;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACrH,CAAA;AAEtB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IAC7G;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACzF,CAAA;AAElB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAChJ;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAClE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACN,CAAA;AAExB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAA6B,CAAA;AAE/F;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAChF,CAAA;AAE5B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAyB,CAAA;AAEtG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,EAAE,CAAC,EACpC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAC1C,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAA+B,CAAA;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAyB,CAAA;AAEtG;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,EAAE,CAAC,EACpC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAC1C,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAA+B,CAAA;AAEjE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACjH;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAC3F,CAAA;AAEpB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;IAC7F;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;CACtE,CAAA;AAErB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,EAAE;IAC3B;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAChI;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACnG,CAAA;AAE3B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B;;;;;;;;;;;;;OAaG;IACH,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;IAC7H;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GACnD,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;CACE,CAAA;AAE5B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAkB,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB;;;;;;;;;;;;;;OAcG;IACH,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC7C;;;;;;;;;;;;;;OAcG;IACH,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,CAAC,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAClE,CAAA;AAEjB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAA2B,CAAA;AAE3F;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAyB,CAAA;AAEvF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAsB,CAAA;AAE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAuB,CAAA;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAsB,CAAA;AAE9E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,aAAa,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IAC9H;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EACT,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,aAAa,GACzD,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACL,CAAA;AAEpB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,EAAE,EACD,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC,GACnF,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACxE;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC,GACnF,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACJ,CAAA;AAE1B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC,EAClC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC,KACzC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,EAAE,CAAC,CAA4B,CAAA;AAElE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAmB,CAAA;AAErH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EACjB,OAAO,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAA;KAAE,GACrF,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;IAC5D;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EACpB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,OAAO,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAA;KAAE,GACrF,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,CAAA;CACP,CAAA;AAEpB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EACzB,OAAO,EAAE;QACP,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;QAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;KAChE,GACA,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;IACtE;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAC5B,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,OAAO,EAAE;QACP,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;QAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;KAChE,GACA,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAA;CACX,CAAA;AAE1B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAC9B,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KACvB,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAmB,CAAA;AAGhE;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAqB,CAAA;AAG5G;;;;;GAKG;AACH,eAAO,MAAM,MAAM,EAAE;IAEnB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAEnI;;;;;OAKG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAC9G,CAAA;AAGnB;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE;IAEvB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EACZ,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS,GACzE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAEtF;;;;;OAKG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EACxB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS,GACzE,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACrB,CAAA;AAEvB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAoB,CAAA;AAEpE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IAChH;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACzF,CAAA;AAErB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,EAAE,CACxB,IAAI,EAAE,QAAQ,CAAC,aAAa,EAC5B,MAAM,CAAC,EAAE,MAAM,KACZ,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAwB,CAAA;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAsB,CAAA;AAEzG;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,MAAM,CAAkB,CAAA;AAE3F;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAoB,CAAA;AAEzD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAsB,CAAA;AAE3G;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,EAAE,CACvB,KAAK,EAAE,QAAQ,CAAC,aAAa,EAC7B,GAAG,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,aAAa,CAAC,KACrC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAuB,CAAA;AAEtD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAyB,CAAA;AAE3F;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,CAAC,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAqB,CAAA;AAElE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAwB,CAAA;AAEhH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACnI;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAC3G,CAAA;AAEtB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EACZ,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS,GACzE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACtF;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EACxB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS,GACzE,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAClB,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAqB,CAAA;AAE3G;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,EAAE;IACzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,CAAC,OAAO,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACnI;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EACT,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,OAAO,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAC9D,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACA,CAAA;AAEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAmB,CAAA;AAEpG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IAChG;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CAC9E,CAAA;AAEhB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACnI;;;;;;;;;;;;;;;;;;OAkBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EACnB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,GAC9C,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACT,CAAA;AAEtB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;;;;;;;;;;;;;OAeG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,aAAa,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACxI;;;;;;;;;;;;;;;OAeG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EACT,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,aAAa,GACnE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACD,CAAA;AAExB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE;IAC9B;;;;;;;;;;;;;;;OAeG;IACH,CAAC,GAAG,EAAE,EAAE,EACN,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC,GAC7F,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACnE;;;;;;;;;;;;;;;OAeG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC,GAC7F,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,EACT,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,gBAAgB,CAAC,gBAAgB,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GACxF,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACnE;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAChB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,gBAAgB,CAAC,gBAAgB,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GACxF,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACP,CAAA;AAEvB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAiB,CAAA;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,EAAE;IAC3B;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,CAAA;IACnG;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,CAAA;CACtE,CAAA;AAE3B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE;IAC3B;;;;;;;;;;;;;;;OAeG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACvI;;;;;;;;;;;;;;;OAeG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACf,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GACxB,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;CACV,CAAA;AAE3B;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAuB,CAAA;AAErF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAC7E,CAAA;AAE3B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAC1E,CAAA;AAE3B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAsB,CAAA;AAE9G;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAuB,CAAA;AAErF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAC7E,CAAA;AAE3B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAmB,CAAA;AAEtE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACtG;;;;;;;;;;;;;;;;OAgBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACjF,CAAA;AAEnB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,EAAE;IACzB;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACzI;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAChB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GACjD,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACH,CAAA;AAGzB;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAoB,CAAA;AAE/D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,CAAwB,CAAA;AAEpH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB;;;;;;;;;;;;;OAaG;IACH,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACpG;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CAC3E,CAAA;AAEvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACrF;;;;;;;;;;;;;OAaG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CAC7D,CAAA;AAEtB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;;;;;;;;;;;;OAcG;IACH,CAAC,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAA;IACzH;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAA;CACvG,CAAA;AAEhB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,MAAM,CAAmB,CAAA;AAE7F;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAiB,CAAA;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAoB,CAAA;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAiB,CAAA;AAE3E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;;;;;;;OAYG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACzI;;;;;;;;;;;;OAYG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAClH,CAAA;AAErB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;;;;;;;;OAYG;IACH,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAC3I;;;;;;;;;;;;OAYG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACpG,CAAA;AAEtB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAmB,CAAA;AAErF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACnI;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAC/G,CAAA;AAElB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EACZ,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS,GACzE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACtF;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EACxB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS,GACzE,QAAQ,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACtB,CAAA;AAEtB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB;;;;;;;;;;;;;;OAcG;IACH,CAAC,EAAE,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACpF;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CAC3D,CAAA;AAEvB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAC7B;;;;;;;;;;;;;;;OAeG;IACH,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAChI;;;;;;;;;;;;;;;OAeG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAClD,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACD,CAAA;AAE7B;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACrF;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CAC3D,CAAA;AAExB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,EAAE;IAC9B;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAC/H;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GACjD,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACA,CAAA;AAE9B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB;;;;;;;;;;;OAWG;IACH,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACpG;;;;;;;;;;;OAWG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CACjF,CAAA;AAEjB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB;;;;;;;;;;;;;;OAcG;IACH,CAAC,EAAE,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACpF;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CAC3D,CAAA;AAEvB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE;IAC7B;;;;;;;;;;;;;;OAcG;IACH,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAChI;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAClD,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACD,CAAA;AAE7B;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;IACrF;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;CAC3D,CAAA;AAExB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,EAAE;IAC9B;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAC/H;;;;;;;;;;;;;;OAcG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,GACjD,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACA,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,KAAK,QAAQ,CAAC,MAAM,CAAqB,CAAA;AAEjG;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAC3H;;;;;OAKG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACrG,CAAA;AAEpB;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IAC5H;;;;;OAKG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACrG,CAAA;AAErB;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;IACrK;;;;;OAKG;IACH,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAC9B,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,EAC7B,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,GAChC,QAAQ,CAAC,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CACjB,CAAA;AAEpB;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,CAAC,EAAE,OAAO,MAAM,CAAA;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAA;IACnC,QAAQ,CAAC,oBAAoB,EAAE,QAAQ,CAAC,QAAQ,CAAA;CACjD;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,OAAO,CAAC,SAAS,CACtD,wBAAwB,EACxB,iBAAiB,CACkB,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ScheduleInterval.d.ts b/backend/node_modules/effect/dist/dts/ScheduleInterval.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e2b806328cab79e0465ef93e7b63ca53bc0f334e --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ScheduleInterval.d.ts @@ -0,0 +1,204 @@ +/** + * @since 2.0.0 + */ +import type * as Duration from "./Duration.js"; +import type * as Option from "./Option.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const IntervalTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type IntervalTypeId = typeof IntervalTypeId; +/** + * An `Interval` represents an interval of time. Intervals can encompass all + * time, or no time at all. + * + * @since 2.0.0 + * @category models + */ +export interface Interval { + readonly [IntervalTypeId]: IntervalTypeId; + readonly startMillis: number; + readonly endMillis: number; +} +/** + * Constructs a new interval from the two specified endpoints. If the start + * endpoint greater than the end endpoint, then a zero size interval will be + * returned. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (startMillis: number, endMillis: number) => Interval; +/** + * An `Interval` of zero-width. + * + * @since 2.0.0 + * @category constructors + */ +export declare const empty: Interval; +/** + * Returns `true` if this `Interval` is less than `that` interval, `false` + * otherwise. + * + * @since 2.0.0 + * @category ordering + */ +export declare const lessThan: { + /** + * Returns `true` if this `Interval` is less than `that` interval, `false` + * otherwise. + * + * @since 2.0.0 + * @category ordering + */ + (that: Interval): (self: Interval) => boolean; + /** + * Returns `true` if this `Interval` is less than `that` interval, `false` + * otherwise. + * + * @since 2.0.0 + * @category ordering + */ + (self: Interval, that: Interval): boolean; +}; +/** + * Returns the minimum of two `Interval`s. + * + * @since 2.0.0 + * @category ordering + */ +export declare const min: { + /** + * Returns the minimum of two `Interval`s. + * + * @since 2.0.0 + * @category ordering + */ + (that: Interval): (self: Interval) => Interval; + /** + * Returns the minimum of two `Interval`s. + * + * @since 2.0.0 + * @category ordering + */ + (self: Interval, that: Interval): Interval; +}; +/** + * Returns the maximum of two `Interval`s. + * + * @since 2.0.0 + * @category ordering + */ +export declare const max: { + /** + * Returns the maximum of two `Interval`s. + * + * @since 2.0.0 + * @category ordering + */ + (that: Interval): (self: Interval) => Interval; + /** + * Returns the maximum of two `Interval`s. + * + * @since 2.0.0 + * @category ordering + */ + (self: Interval, that: Interval): Interval; +}; +/** + * Returns `true` if the specified `Interval` is empty, `false` otherwise. + * + * @since 2.0.0 + * @category ordering + */ +export declare const isEmpty: (self: Interval) => boolean; +/** + * Returns `true` if the specified `Interval` is non-empty, `false` otherwise. + * + * @since 2.0.0 + * @category ordering + */ +export declare const isNonEmpty: (self: Interval) => boolean; +/** + * Computes a new `Interval` which is the intersection of this `Interval` and + * that `Interval`. + * + * @since 2.0.0 + * @category ordering + */ +export declare const intersect: { + /** + * Computes a new `Interval` which is the intersection of this `Interval` and + * that `Interval`. + * + * @since 2.0.0 + * @category ordering + */ + (that: Interval): (self: Interval) => Interval; + /** + * Computes a new `Interval` which is the intersection of this `Interval` and + * that `Interval`. + * + * @since 2.0.0 + * @category ordering + */ + (self: Interval, that: Interval): Interval; +}; +/** + * Calculates the size of the `Interval` as the `Duration` from the start of the + * interval to the end of the interval. + * + * @since 2.0.0 + * @category getters + */ +export declare const size: (self: Interval) => Duration.Duration; +/** + * Computes a new `Interval` which is the union of this `Interval` and that + * `Interval` as a `Some`, otherwise returns `None` if the two intervals cannot + * form a union. + * + * @since 2.0.0 + * @category utils + */ +export declare const union: { + /** + * Computes a new `Interval` which is the union of this `Interval` and that + * `Interval` as a `Some`, otherwise returns `None` if the two intervals cannot + * form a union. + * + * @since 2.0.0 + * @category utils + */ + (that: Interval): (self: Interval) => Option.Option; + /** + * Computes a new `Interval` which is the union of this `Interval` and that + * `Interval` as a `Some`, otherwise returns `None` if the two intervals cannot + * form a union. + * + * @since 2.0.0 + * @category utils + */ + (self: Interval, that: Interval): Option.Option; +}; +/** + * Construct an `Interval` that includes all time equal to and after the + * specified start time. + * + * @since 2.0.0 + * @category constructors + */ +export declare const after: (startMilliseconds: number) => Interval; +/** + * Construct an `Interval` that includes all time equal to and before the + * specified end time. + * + * @category constructors + * @since 2.0.0 + */ +export declare const before: (endMilliseconds: number) => Interval; +//# sourceMappingURL=ScheduleInterval.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ScheduleInterval.d.ts.map b/backend/node_modules/effect/dist/dts/ScheduleInterval.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..efbd69fe8b8b8ffdb547f811e1dbc27ebc2b4d15 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ScheduleInterval.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ScheduleInterval.d.ts","sourceRoot":"","sources":["../../src/ScheduleInterval.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAE9C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAE1C;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAAgC,CAAA;AAEpE;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,cAAc,CAAA;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,QAAwB,CAAA;AAEvF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,QAAyB,CAAA;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;OAMG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAA;IAC7C;;;;;;OAMG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;CACtB,CAAA;AAErB;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAA;IAC9C;;;;;OAKG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAC5B,CAAA;AAEhB;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAA;IAC9C;;;;;OAKG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAC5B,CAAA;AAEhB;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAA0B,CAAA;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAA6B,CAAA;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;;OAMG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAA;IAC9C;;;;;;OAMG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;CACtB,CAAA;AAEtB;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAC,QAAwB,CAAA;AAExE;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;;;OAOG;IACH,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;IAC7D;;;;;;;OAOG;IACH,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;CACzC,CAAA;AAElB;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,iBAAiB,EAAE,MAAM,KAAK,QAAyB,CAAA;AAE5E;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,CAAC,eAAe,EAAE,MAAM,KAAK,QAA0B,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ScheduleIntervals.d.ts b/backend/node_modules/effect/dist/dts/ScheduleIntervals.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..da3c6c99d634a7862e1363970940063321dfa915 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ScheduleIntervals.d.ts @@ -0,0 +1,159 @@ +/** + * @since 2.0.0 + */ +import type * as Check from "./Chunk.js"; +import type * as Interval from "./ScheduleInterval.js"; +/** + * @since 2.0.0 + * @category symbols + */ +export declare const IntervalsTypeId: unique symbol; +/** + * @since 2.0.0 + * @category symbols + */ +export type IntervalsTypeId = typeof IntervalsTypeId; +/** + * An `Intervals` represents a list of several `Interval`s. + * + * @since 2.0.0 + * @category models + */ +export interface Intervals { + readonly [IntervalsTypeId]: IntervalsTypeId; + readonly intervals: Check.Chunk; +} +/** + * Creates a new `Intervals` from a `List` of `Interval`s. + * + * @since 2.0.0 + * @category constructors + */ +export declare const make: (intervals: Check.Chunk) => Intervals; +/** + * Constructs an empty list of `Interval`s. + * + * @since 2.0.0 + * @category constructors + */ +export declare const empty: Intervals; +/** + * Creates `Intervals` from the specified `Iterable`. + * + * @since 2.0.0 + * @category constructors + */ +export declare const fromIterable: (intervals: Iterable) => Intervals; +/** + * Computes the union of this `Intervals` and that `Intervals` + * + * @since 2.0.0 + * @category utils + */ +export declare const union: { + /** + * Computes the union of this `Intervals` and that `Intervals` + * + * @since 2.0.0 + * @category utils + */ + (that: Intervals): (self: Intervals) => Intervals; + /** + * Computes the union of this `Intervals` and that `Intervals` + * + * @since 2.0.0 + * @category utils + */ + (self: Intervals, that: Intervals): Intervals; +}; +/** + * Produces the intersection of this `Intervals` and that `Intervals`. + * + * @since 2.0.0 + * @category utils + */ +export declare const intersect: { + /** + * Produces the intersection of this `Intervals` and that `Intervals`. + * + * @since 2.0.0 + * @category utils + */ + (that: Intervals): (self: Intervals) => Intervals; + /** + * Produces the intersection of this `Intervals` and that `Intervals`. + * + * @since 2.0.0 + * @category utils + */ + (self: Intervals, that: Intervals): Intervals; +}; +/** + * The start of the earliest interval in the specified `Intervals`. + * + * @since 2.0.0 + * @category getters + */ +export declare const start: (self: Intervals) => number; +/** + * The end of the latest interval in the specified `Intervals`. + * + * @since 2.0.0 + * @category getters + */ +export declare const end: (self: Intervals) => number; +/** + * Returns `true` if the start of this `Intervals` is before the start of that + * `Intervals`, `false` otherwise. + * + * @since 2.0.0 + * @category ordering + */ +export declare const lessThan: { + /** + * Returns `true` if the start of this `Intervals` is before the start of that + * `Intervals`, `false` otherwise. + * + * @since 2.0.0 + * @category ordering + */ + (that: Intervals): (self: Intervals) => boolean; + /** + * Returns `true` if the start of this `Intervals` is before the start of that + * `Intervals`, `false` otherwise. + * + * @since 2.0.0 + * @category ordering + */ + (self: Intervals, that: Intervals): boolean; +}; +/** + * Returns `true` if this `Intervals` is non-empty, `false` otherwise. + * + * @since 2.0.0 + * @category getters + */ +export declare const isNonEmpty: (self: Intervals) => boolean; +/** + * Returns the maximum of the two `Intervals` (i.e. which has the latest start). + * + * @since 2.0.0 + * @category ordering + */ +export declare const max: { + /** + * Returns the maximum of the two `Intervals` (i.e. which has the latest start). + * + * @since 2.0.0 + * @category ordering + */ + (that: Intervals): (self: Intervals) => Intervals; + /** + * Returns the maximum of the two `Intervals` (i.e. which has the latest start). + * + * @since 2.0.0 + * @category ordering + */ + (self: Intervals, that: Intervals): Intervals; +}; +//# sourceMappingURL=ScheduleIntervals.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/ScheduleIntervals.d.ts.map b/backend/node_modules/effect/dist/dts/ScheduleIntervals.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..78e5391b641750ff939dbd53e6960cf2b76362e1 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/ScheduleIntervals.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"ScheduleIntervals.d.ts","sourceRoot":"","sources":["../../src/ScheduleIntervals.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC,OAAO,KAAK,KAAK,QAAQ,MAAM,uBAAuB,CAAA;AAEtD;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,OAAO,MAAiC,CAAA;AAEtE;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAA;AAEpD;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,CAAC,eAAe,CAAC,EAAE,eAAe,CAAA;IAC3C,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;CACnD;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,SAAyB,CAAA;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,SAA0B,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,SAAiC,CAAA;AAExG;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IACjD;;;;;OAKG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,CAAA;CAC7B,CAAA;AAElB;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IACjD;;;;;OAKG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,CAAA;CACzB,CAAA;AAEtB;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAuB,CAAA;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAqB,CAAA;AAE5D;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB;;;;;;OAMG;IACH,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/C;;;;;;OAMG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;CACxB,CAAA;AAErB;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,OAA6B,CAAA;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;;;;OAKG;IACH,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IACjD;;;;;OAKG;IACH,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,CAAA;CAC/B,CAAA"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Scheduler.d.ts b/backend/node_modules/effect/dist/dts/Scheduler.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..384bdc7737afd2eb2530165226ab109d90eddbe3 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Scheduler.d.ts @@ -0,0 +1,161 @@ +/** + * @since 2.0.0 + */ +import type { RuntimeFiber } from "./Fiber.js"; +/** + * @since 2.0.0 + * @category models + */ +export type Task = () => void; +/** + * @since 2.0.0 + * @category models + */ +export interface Scheduler { + shouldYield(fiber: RuntimeFiber): number | false; + scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber): void; +} +/** + * @since 3.20.0 + * @category models + */ +export declare class SchedulerRunner { + readonly scheduleDrain: (depth: number, drain: (depth: number) => void) => void; + running: boolean; + tasks: PriorityBuckets; + constructor(scheduleDrain: (depth: number, drain: (depth: number) => void) => void); + private starveInternal; + private starve; + scheduleTask(task: Task, priority: number): void; + /** + * @since 3.20.0 + * @category constructors + */ + static cached(scheduleDrain: (depth: number, drain: (depth: number) => void) => void): (fiber?: RuntimeFiber) => SchedulerRunner; +} +/** + * @since 2.0.0 + * @category utils + */ +export declare class PriorityBuckets { + /** + * @since 2.0.0 + */ + buckets: Array<[number, Array]>; + /** + * @since 2.0.0 + */ + scheduleTask(task: T, priority: number): void; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare class MixedScheduler implements Scheduler { + /** + * @since 2.0.0 + */ + readonly maxNextTickBeforeTimer: number; + private readonly getRunner; + constructor( + /** + * @since 2.0.0 + */ + maxNextTickBeforeTimer: number); + /** + * @since 2.0.0 + */ + shouldYield(fiber: RuntimeFiber): number | false; + /** + * @since 2.0.0 + */ + scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber): void; +} +/** + * @since 2.0.0 + * @category schedulers + */ +export declare const defaultScheduler: Scheduler; +/** + * @since 2.0.0 + * @category constructors + */ +export declare class SyncScheduler implements Scheduler { + /** + * @since 2.0.0 + */ + tasks: PriorityBuckets; + /** + * @since 2.0.0 + */ + deferred: boolean; + /** + * @since 2.0.0 + */ + scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber): void; + /** + * @since 2.0.0 + */ + shouldYield(fiber: RuntimeFiber): number | false; + /** + * @since 2.0.0 + */ + flush(): void; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare class ControlledScheduler implements Scheduler { + /** + * @since 2.0.0 + */ + tasks: PriorityBuckets; + /** + * @since 2.0.0 + */ + deferred: boolean; + /** + * @since 2.0.0 + */ + scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber): void; + /** + * @since 2.0.0 + */ + shouldYield(fiber: RuntimeFiber): number | false; + /** + * @since 2.0.0 + */ + step(): void; +} +/** + * @since 2.0.0 + * @category constructors + */ +export declare const makeMatrix: (...record: Array<[number, Scheduler]>) => Scheduler; +/** + * @since 2.0.0 + * @category utilities + */ +export declare const defaultShouldYield: Scheduler["shouldYield"]; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const make: (scheduleTask: Scheduler["scheduleTask"], shouldYield?: Scheduler["shouldYield"]) => Scheduler; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const makeBatched: (callback: (runBatch: () => void) => void, shouldYield?: Scheduler["shouldYield"]) => Scheduler; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const timer: (ms: number, shouldYield?: Scheduler["shouldYield"]) => Scheduler; +/** + * @since 2.0.0 + * @category constructors + */ +export declare const timerBatched: (ms: number, shouldYield?: Scheduler["shouldYield"]) => Scheduler; +//# sourceMappingURL=Scheduler.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Scheduler.d.ts.map b/backend/node_modules/effect/dist/dts/Scheduler.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..ec2c1c7a67bfc2fa8c18d49e610102accc2680d4 --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Scheduler.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"Scheduler.d.ts","sourceRoot":"","sources":["../../src/Scheduler.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/backend/node_modules/effect/dist/dts/Schema.d.ts b/backend/node_modules/effect/dist/dts/Schema.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..68f4b892822fa73efb05775a0e54b3e70953f84d --- /dev/null +++ b/backend/node_modules/effect/dist/dts/Schema.d.ts @@ -0,0 +1,5094 @@ +/** + * @since 3.10.0 + */ +import type { StandardSchemaV1 } from "@standard-schema/spec"; +import type { ArbitraryAnnotation, LazyArbitrary } from "./Arbitrary.js"; +import * as array_ from "./Array.js"; +import * as bigDecimal_ from "./BigDecimal.js"; +import type { Brand } from "./Brand.js"; +import * as cause_ from "./Cause.js"; +import * as chunk_ from "./Chunk.js"; +import * as config_ from "./Config.js"; +import * as dateTime from "./DateTime.js"; +import * as duration_ from "./Duration.js"; +import * as Effect from "./Effect.js"; +import * as either_ from "./Either.js"; +import * as Equivalence from "./Equivalence.js"; +import * as exit_ from "./Exit.js"; +import * as fiberId_ from "./FiberId.js"; +import type { LazyArg } from "./Function.js"; +import * as hashMap_ from "./HashMap.js"; +import * as hashSet_ from "./HashSet.js"; +import * as list_ from "./List.js"; +import * as option_ from "./Option.js"; +import type * as Order from "./Order.js"; +import * as ParseResult from "./ParseResult.js"; +import type { Pipeable } from "./Pipeable.js"; +import type * as pretty_ from "./Pretty.js"; +import * as redacted_ from "./Redacted.js"; +import * as Request from "./Request.js"; +import type { ParseOptions } from "./SchemaAST.js"; +import * as AST from "./SchemaAST.js"; +import * as sortedSet_ from "./SortedSet.js"; +import type * as Types from "./Types.js"; +/** + * @since 3.10.0 + */ +export type Simplify = { + [K in keyof A]: A[K]; +} & {}; +/** + * @since 3.10.0 + */ +export type SimplifyMutable = { + -readonly [K in keyof A]: A[K]; +} extends infer B ? B : never; +/** + * @since 3.10.0 + * @category symbol + */ +export declare const TypeId: unique symbol; +/** + * @since 3.10.0 + * @category symbol + */ +export type TypeId = typeof TypeId; +/** + * @category model + * @since 3.10.0 + */ +export interface Schema extends Schema.Variance, Pipeable { + readonly Type: A; + readonly Encoded: I; + readonly Context: R; + readonly ast: AST.AST; + /** + * Merges a set of new annotations with existing ones, potentially overwriting + * any duplicates. + */ + annotations(annotations: Annotations.GenericSchema): Schema; +} +/** + * @category annotations + * @since 3.10.0 + */ +export interface Annotable, A, I = A, R = never> extends Schema { + annotations(annotations: Annotations.GenericSchema): Self; +} +/** + * @category annotations + * @since 3.10.0 + */ +export interface AnnotableClass, A, I = A, R = never> extends Annotable { + new (_: never): Schema.Variance; +} +/** + * @category model + * @since 3.10.0 + */ +export interface SchemaClass extends AnnotableClass, A, I, R> { +} +/** + * @category constructors + * @since 3.10.0 + */ +export declare function make(ast: AST.AST): SchemaClass; +/** + * Returns a "Standard Schema" object conforming to the [Standard Schema + * v1](https://standardschema.dev/) specification. + * + * This function creates a schema whose `validate` method attempts to decode and + * validate the provided input synchronously. If the underlying `Schema` + * includes any asynchronous components (e.g., asynchronous message resolutions + * or checks), then validation will necessarily return a `Promise` instead. + * + * Any detected defects will be reported via a single issue containing no + * `path`. + * + * @example + * ```ts + * import { Schema } from "effect" + * + * const schema = Schema.Struct({ + * name: Schema.String + * }) + * + * // ┌─── StandardSchemaV1<{ readonly name: string; }> + * // ▼ + * const standardSchema = Schema.standardSchemaV1(schema) + * ``` + * + * @category Standard Schema + * @since 3.13.0 + */ +export declare const standardSchemaV1: (schema: Schema, overrideOptions?: AST.ParseOptions) => StandardSchemaV1 & SchemaClass; +/** + * @category annotations + * @since 3.10.0 + */ +export declare namespace Annotable { + /** + * @since 3.10.0 + */ + type Self = ReturnType; + /** + * @since 3.10.0 + */ + type Any = Annotable; + /** + * @since 3.10.0 + */ + type All = Any | Annotable | Annotable | Annotable; +} +/** + * @since 3.10.0 + */ +export declare function asSchema(schema: S): Schema, Schema.Encoded, Schema.Context>; +/** + * @category formatting + * @since 3.10.0 + */ +export declare const format: (schema: S) => string; +/** + * @since 3.10.0 + */ +export declare namespace Schema { + /** + * @since 3.10.0 + */ + interface Variance { + readonly [TypeId]: { + readonly _A: Types.Invariant; + readonly _I: Types.Invariant; + readonly _R: Types.Covariant; + }; + } + /** + * @since 3.10.0 + */ + type Type = S extends Schema.Variance ? A : never; + /** + * @since 3.10.0 + */ + type Encoded = S extends Schema.Variance ? I : never; + /** + * @since 3.10.0 + */ + type Context = S extends Schema.Variance ? R : never; + /** + * @since 3.10.0 + */ + type ToAsserts = (input: unknown, options?: AST.ParseOptions) => asserts input is Schema.Type; + /** + * Any schema, except for `never`. + * + * @since 3.10.0 + */ + type Any = Schema; + /** + * Any schema with `Context = never`, except for `never`. + * + * @since 3.10.0 + */ + type AnyNoContext = Schema; + /** + * Any schema, including `never`. + * + * @since 3.10.0 + */ + type All = Any | Schema | Schema | Schema; + /** + * Type-level counterpart of `Schema.asSchema` function. + * + * @since 3.10.0 + */ + type AsSchema = Schema, Encoded, Context>; +} +/** + * The `encodedSchema` function allows you to extract the `Encoded` portion of a + * schema, creating a new schema that conforms to the properties defined in the + * original schema without retaining any refinements or transformations that + * were applied previously. + * + * @since 3.10.0 + */ +export declare const encodedSchema: (schema: Schema) => SchemaClass; +/** + * The `encodedBoundSchema` function is similar to `encodedSchema` but preserves + * the refinements up to the first transformation point in the original schema. + * + * @since 3.10.0 + */ +export declare const encodedBoundSchema: (schema: Schema) => SchemaClass; +/** + * The `typeSchema` function allows you to extract the `Type` portion of a + * schema, creating a new schema that conforms to the properties defined in the + * original schema without considering the initial encoding or transformation + * processes. + * + * @since 3.10.0 + */ +export declare const typeSchema: (schema: Schema) => SchemaClass; +export { +/** + * By default the option `exact` is set to `true`. + * + * @throws `ParseError` + * @category validation + * @since 3.10.0 + */ +asserts, +/** + * @category decoding + * @since 3.10.0 + */ +decodeOption, +/** + * @throws `ParseError` + * @category decoding + * @since 3.10.0 + */ +decodeSync, +/** + * @category decoding + * @since 3.10.0 + */ +decodeUnknownOption, +/** + * @throws `ParseError` + * @category decoding + * @since 3.10.0 + */ +decodeUnknownSync, +/** + * @category encoding + * @since 3.10.0 + */ +encodeOption, +/** + * @throws `ParseError` + * @category encoding + * @since 3.10.0 + */ +encodeSync, +/** + * @category encoding + * @since 3.10.0 + */ +encodeUnknownOption, +/** + * @throws `ParseError` + * @category encoding + * @since 3.10.0 + */ +encodeUnknownSync, +/** + * By default the option `exact` is set to `true`. + * + * @category validation + * @since 3.10.0 + */ +is, +/** + * @category validation + * @since 3.10.0 + */ +validateOption, +/** + * @throws `ParseError` + * @category validation + * @since 3.10.0 + */ +validateSync } from "./ParseResult.js"; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknown: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknownEither: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => either_.Either; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeUnknownPromise: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Promise; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encode: (schema: Schema, options?: ParseOptions) => (a: A, overrideOptions?: ParseOptions) => Effect.Effect; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodeEither: (schema: Schema, options?: ParseOptions) => (a: A, overrideOptions?: ParseOptions) => either_.Either; +/** + * @category encoding + * @since 3.10.0 + */ +export declare const encodePromise: (schema: Schema, options?: ParseOptions) => (a: A, overrideOptions?: ParseOptions) => Promise; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknown: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknownEither: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => either_.Either; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeUnknownPromise: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Promise; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decode: (schema: Schema, options?: ParseOptions) => (i: I, overrideOptions?: ParseOptions) => Effect.Effect; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodeEither: (schema: Schema, options?: ParseOptions) => (i: I, overrideOptions?: ParseOptions) => either_.Either; +/** + * @category decoding + * @since 3.10.0 + */ +export declare const decodePromise: (schema: Schema, options?: ParseOptions) => (i: I, overrideOptions?: ParseOptions) => Promise; +/** + * @category validation + * @since 3.10.0 + */ +export declare const validate: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect; +/** + * @category validation + * @since 3.10.0 + */ +export declare const validateEither: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => either_.Either; +/** + * @category validation + * @since 3.10.0 + */ +export declare const validatePromise: (schema: Schema, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Promise; +/** + * Tests if a value is a `Schema`. + * + * @category guards + * @since 3.10.0 + */ +export declare const isSchema: (u: unknown) => u is Schema.Any; +/** + * @category api interface + * @since 3.10.0 + */ +export interface Literal> extends AnnotableClass, Literals[number]> { + readonly literals: Readonly; +} +/** + * @category constructors + * @since 3.10.0 + */ +export declare function Literal>(...literals: Literals): Literal; +export declare function Literal(): Never; +export declare function Literal>(...literals: Literals): SchemaClass; +/** + * Creates a new `Schema` from a literal schema. + * + * @example + * ```ts + * import * as assert from "node:assert" + * import { Either, Schema } from "effect" + * + * const schema = Schema.Literal("a", "b", "c").pipe(Schema.pickLiteral("a", "b")) + * + * assert.deepStrictEqual(Schema.decodeSync(schema)("a"), "a") + * assert.deepStrictEqual(Schema.decodeSync(schema)("b"), "b") + * assert.strictEqual(Either.isLeft(Schema.decodeUnknownEither(schema)("c")), true) + * ``` + * + * @category constructors + * @since 3.10.0 + */ +export declare const pickLiteral: >(...literals: L) => (_schema: Schema) => Literal<[...L]>; +/** + * @category constructors + * @since 3.10.0 + */ +export declare const UniqueSymbolFromSelf: (symbol: S) => SchemaClass; +/** + * @category api interface + * @since 3.10.0 + */ +export interface Enums extends AnnotableClass, A[keyof A]> { + readonly enums: A; +} +/** + * @since 3.10.0 + */ +export type EnumsDefinition = { + [x: string]: string | number; +}; +/** + * @category constructors + * @since 3.10.0 + */ +export declare const Enums: (enums: A) => Enums; +type AppendType

, f: Fn]) => (self: Matcher) => Matcher>>, Types.ApplyFilters>>>, A | ReturnType, Pr, Ret>; +/** + * Matches values where a specified field starts with a given prefix. + * + * **Details** + * + * This function is useful for working with discriminated unions where the + * discriminant field follows a hierarchical or namespaced structure. It allows + * you to match values based on whether the specified field starts with a given + * prefix, making it easier to handle grouped cases. + * + * Instead of checking for exact matches, this function lets you match values + * that share a common prefix. For example, if your discriminant field contains + * hierarchical names like `"A"`, `"A.A"`, and `"B"`, you can match all values + * starting with `"A"` using a single rule. + * + * @example + * ```ts + * import { Match, pipe } from "effect" + * + * const match = pipe( + * Match.type<{ type: "A" } | { type: "B" } | { type: "A.A" } | {}>(), + * Match.discriminatorStartsWith("type")("A", (_) => 1 as const), + * Match.discriminatorStartsWith("type")("B", (_) => 2 as const), + * Match.orElse((_) => 3 as const) + * ) + * + * console.log(match({ type: "A" })) // 1 + * console.log(match({ type: "B" })) // 2 + * console.log(match({ type: "A.A" })) // 1 + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const discriminatorStartsWith: (field: D) => >) => Ret>(pattern: P, f: Fn) => (self: Matcher) => Matcher>>, Types.ApplyFilters>>>, A | ReturnType, Pr, Ret>; +/** + * Matches values based on a field that serves as a discriminator, mapping each + * possible value to a corresponding handler. + * + * **Details** + * + * This function simplifies working with discriminated unions by letting you + * define a set of handlers for each possible value of a given field. Instead of + * chaining multiple calls to {@link discriminator}, this function allows + * defining all possible cases at once using an object where the keys are the + * possible values of the field, and the values are the corresponding handler + * functions. + * + * @example + * ```ts + * import { Match, pipe } from "effect" + * + * const match = pipe( + * Match.type<{ type: "A"; a: string } | { type: "B"; b: number } | { type: "C"; c: boolean }>(), + * Match.discriminators("type")({ + * A: (a) => a.a, + * B: (b) => b.b, + * C: (c) => c.c + * }), + * Match.exhaustive + * ) + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const discriminators: (field: D) => & string]?: ((_: Extract>) => Ret) | undefined; +} & { + readonly [Tag in Exclude>]: never; +}>(fields: P) => (self: Matcher) => Matcher>>, Types.ApplyFilters>>>, A | ReturnType, Pr, Ret>; +/** + * Matches values based on a discriminator field and **ensures all cases are + * handled**. + * + * **Details*+ + * + * This function is similar to {@link discriminators}, but **requires that all + * possible cases** are explicitly handled. It is useful when working with + * discriminated unions, where a specific field (e.g., `"type"`) determines the + * shape of an object. Each possible value of the field must have a + * corresponding handler, ensuring **exhaustiveness checking** at compile time. + * + * This function **does not require** `Match.exhaustive` at the end of the + * pipeline because it enforces exhaustiveness by design. + * + * @example + * ```ts + * import { Match, pipe } from "effect" + * + * const match = pipe( + * Match.type<{ type: "A"; a: string } | { type: "B"; b: number } | { type: "C"; c: boolean }>(), + * Match.discriminatorsExhaustive("type")({ + * A: (a) => a.a, + * B: (b) => b.b, + * C: (c) => c.c + * }) + * ) + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const discriminatorsExhaustive: (field: D) => & string]: (_: Extract>) => Ret; +} & { + readonly [Tag in Exclude>]: never; +}>(fields: P) => (self: Matcher) => [Pr] extends [never] ? (u: I) => Unify> : Unify>; +/** + * The `Match.tag` function allows pattern matching based on the `_tag` field in + * a [Discriminated Union](https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes-func.html#discriminated-unions). + * You can specify multiple tags to match within a single pattern. + * + * **Note** + * + * The `Match.tag` function relies on the convention within the Effect ecosystem + * of naming the tag field as `"_tag"`. Ensure that your discriminated unions + * follow this naming convention for proper functionality. + * + * **Example** (Matching a Discriminated Union by Tag) + * + * ```ts + * import { Match } from "effect" + * + * type Event = + * | { readonly _tag: "fetch" } + * | { readonly _tag: "success"; readonly data: string } + * | { readonly _tag: "error"; readonly error: Error } + * | { readonly _tag: "cancel" } + * + * // Create a Matcher for Either + * const match = Match.type().pipe( + * // Match either "fetch" or "success" + * Match.tag("fetch", "success", () => `Ok!`), + * // Match "error" and extract the error message + * Match.tag("error", (event) => `Error: ${event.error.message}`), + * // Match "cancel" + * Match.tag("cancel", () => "Cancelled"), + * Match.exhaustive + * ) + * + * console.log(match({ _tag: "success", data: "Hello" })) + * // Output: "Ok!" + * + * console.log(match({ _tag: "error", error: new Error("Oops!") })) + * // Output: "Error: Oops!" + * ``` + * + * @category Defining patterns + * @since 1.0.0 + */ +export declare const tag: & string, Ret, Fn extends (_: Extract>) => Ret>(...pattern: [first: P, ...values: Array