@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/Data.ts

@@ -1,596 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Cause from "./Cause.js"
-import * as core from "./internal/core.js"
-import * as internal from "./internal/data.js"
-import { StructuralPrototype } from "./internal/effectable.js"
-import * as Predicate from "./Predicate.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
-   */
-  export interface Constructor<A, Tag extends keyof A = never> {
-    (
-      args: Types.Equals<Omit<A, Tag>, {}> extends true ? void
-        : { 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 const struct: <A extends Record<string, any>>(a: A) => { readonly [P in keyof A]: A[P] } = internal.struct
-
-/**
- * @category constructors
- * @since 2.0.0
- */
-export const unsafeStruct = <A extends Record<string, any>>(as: A): { readonly [P in keyof A]: A[P] } =>
-  Object.setPrototypeOf(as, StructuralPrototype)
-
-/**
- * @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 const tuple = <As extends ReadonlyArray<any>>(...as: As): Readonly<As> => unsafeArray(as)
-
-/**
- * @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 const array = <As extends ReadonlyArray<any>>(as: As): Readonly<As> => unsafeArray(as.slice(0) as unknown as As)
-
-/**
- * @category constructors
- * @since 2.0.0
- */
-export const unsafeArray = <As extends ReadonlyArray<any>>(as: As): Readonly<As> =>
-  Object.setPrototypeOf(as, internal.ArrayProto)
-
-const _case = <A>(): Case.Constructor<A> => (args) =>
-  (args === undefined ? Object.create(StructuralPrototype) : struct(args)) as any
-
-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<Person>()
-   *
-   * // 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>("Person")
- *
- * const mike = Person({ name: "Mike" })
- *
- * assert.deepEqual(mike, { _tag: "Person", name: "Mike" })
- * ```
- *
- * @since 2.0.0
- * @category constructors
- */
-export const tagged = <A extends { readonly _tag: string }>(
-  tag: A["_tag"]
-): Case.Constructor<A, "_tag"> =>
-(args) => {
-  const value = args === undefined ? Object.create(StructuralPrototype) : struct(args)
-  value._tag = tag
-  return value
-}
-
-/**
- * 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 const Class: new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A]: A[P] }
-) => Readonly<A> = internal.Structural as any
-
-/**
- * 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 const TaggedClass = <Tag extends string>(
-  tag: Tag
-): new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
-) => Readonly<A> & { readonly _tag: Tag } => {
-  class Base extends Class<any> {
-    readonly _tag = tag
-  }
-  return Base as any
-}
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const Structural: new<A>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A]: A[P] }
-) => {} = internal.Structural as any
-
-/**
- * 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<
-  A extends Record<string, Record<string, any>> & UntaggedChildren<A>
-> = 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<A> = keyof A extends infer K ? K extends keyof A ? "_tag" extends keyof A[K] ? true
-    : false
-  : never
-  : never
-
-type UntaggedChildren<A> = true extends ChildrenAreTagged<A>
-  ? "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
-   */
-  export interface WithGenerics<Count extends number> {
-    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
-   */
-  export type Kind<
-    Z extends WithGenerics<number>,
-    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
-   */
-  export type Args<
-    A extends { readonly _tag: string },
-    K extends A["_tag"],
-    E = Extract<A, { readonly _tag: K }>
-  > = { readonly [K in keyof E as K extends "_tag" ? never : K]: E[K] } extends infer T ? {} extends T ? void : T
-    : never
-
-  /**
-   * @since 2.0.0
-   */
-  export type Value<
-    A extends { readonly _tag: string },
-    K extends A["_tag"]
-  > = Extract<A, { readonly _tag: K }>
-
-  /**
-   * @since 3.1.0
-   */
-  export type Constructor<A extends { readonly _tag: string }> = Types.Simplify<
-    & {
-      readonly [Tag in A["_tag"]]: Case.Constructor<Extract<A, { readonly _tag: Tag }>, "_tag">
-    }
-    & {
-      readonly $is: <Tag extends A["_tag"]>(tag: Tag) => (u: unknown) => u is Extract<A, { readonly _tag: Tag }>
-      readonly $match: {
-        <
-          const Cases extends {
-            readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
-          }
-        >(
-          cases: Cases & { [K in Exclude<keyof Cases, A["_tag"]>]: never }
-        ): (value: A) => Unify<ReturnType<Cases[A["_tag"]]>>
-        <
-          const Cases extends {
-            readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
-          }
-        >(
-          value: A,
-          cases: Cases & { [K in Exclude<keyof Cases, A["_tag"]>]: never }
-        ): Unify<ReturnType<Cases[A["_tag"]]>>
-      }
-    }
-  >
-
-  /**
-   * @since 3.2.0
-   */
-  export interface GenericMatchers<Z extends WithGenerics<number>> {
-    readonly $is: <Tag extends Z["taggedEnum"]["_tag"]>(
-      tag: Tag
-    ) => {
-      <T extends TaggedEnum.Kind<Z, any, any, any, any>>(
-        u: T
-      ): u is T & { readonly _tag: Tag }
-      (u: unknown): u is Extract<TaggedEnum.Kind<Z>, { readonly _tag: Tag }>
-    }
-    readonly $match: {
-      <
-        A,
-        B,
-        C,
-        D,
-        Cases extends {
-          readonly [Tag in Z["taggedEnum"]["_tag"]]: (
-            args: Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
-          ) => any
-        }
-      >(
-        cases: Cases & { [K in Exclude<keyof Cases, Z["taggedEnum"]["_tag"]>]: never }
-      ): (self: TaggedEnum.Kind<Z, A, B, C, D>) => Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
-      <
-        A,
-        B,
-        C,
-        D,
-        Cases extends {
-          readonly [Tag in Z["taggedEnum"]["_tag"]]: (
-            args: Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
-          ) => any
-        }
-      >(
-        self: TaggedEnum.Kind<Z, A, B, C, D>,
-        cases: Cases & { [K in Exclude<keyof Cases, Z["taggedEnum"]["_tag"]>]: never }
-      ): Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
-    }
-  }
-}
-
-/**
- * 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<E, A> = Data.TaggedEnum<{
- *   Failure: { readonly error: E }
- *   Success: { readonly value: A }
- * }>
- * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> {
- *   readonly taggedEnum: MyResult<this["A"], this["B"]>
- * }
- * const { Failure, Success } = Data.taggedEnum<MyResultDefinition>()
- *
- * const success = Success({ value: 1 })
- *
- * @category constructors
- * @since 2.0.0
- */
-export const taggedEnum: {
-  <Z extends TaggedEnum.WithGenerics<1>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  <Z extends TaggedEnum.WithGenerics<2>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  <Z extends TaggedEnum.WithGenerics<3>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B, C>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B, C>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  <Z extends TaggedEnum.WithGenerics<4>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C, D>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B, C, D>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  <A extends { readonly _tag: string }>(): TaggedEnum.Constructor<A>
-} = () =>
-  new Proxy({}, {
-    get(_target, tag, _receiver) {
-      if (tag === "$is") {
-        return Predicate.isTagged
-      } else if (tag === "$match") {
-        return taggedMatch
-      }
-      return tagged(tag as string)
-    }
-  }) as any
-
-function taggedMatch<
-  A extends { readonly _tag: string },
-  Cases extends {
-    readonly [K in A["_tag"]]: (args: Extract<A, { readonly _tag: K }>) => any
-  }
->(self: A, cases: Cases): ReturnType<Cases[A["_tag"]]>
-function taggedMatch<
-  A extends { readonly _tag: string },
-  Cases extends {
-    readonly [K in A["_tag"]]: (args: Extract<A, { readonly _tag: K }>) => any
-  }
->(cases: Cases): (value: A) => ReturnType<Cases[A["_tag"]]>
-function taggedMatch<
-  A extends { readonly _tag: string },
-  Cases extends {
-    readonly [K in A["_tag"]]: (args: Extract<A, { readonly _tag: K }>) => any
-  }
->(): any {
-  if (arguments.length === 1) {
-    const cases = arguments[0] as Cases
-    return function(value: A): ReturnType<Cases[A["_tag"]]> {
-      return cases[value._tag as A["_tag"]](value as any)
-    }
-  }
-  const value = arguments[0] as A
-  const cases = arguments[1] as Cases
-  return cases[value._tag as A["_tag"]](value as any)
-}
-
-/**
- * Provides a constructor for a Case Class.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const Error: new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A]: A[P] }
-) => Cause.YieldableError & Readonly<A> = (function() {
-  const plainArgsSymbol = Symbol.for("effect/Data/Error/plainArgs")
-  const O = {
-    BaseEffectError: class extends core.YieldableError {
-      constructor(args: any) {
-        super(args?.message, args?.cause ? { cause: args.cause } : undefined)
-        if (args) {
-          Object.assign(this, args)
-          // @effect-diagnostics-next-line floatingEffect:off
-          Object.defineProperty(this, plainArgsSymbol, { value: args, enumerable: false })
-        }
-      }
-      toJSON() {
-        return { ...(this as any)[plainArgsSymbol], ...this }
-      }
-    } as any
-  }
-  return O.BaseEffectError
-})()
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
-) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A> => {
-  const O = {
-    BaseEffectError: class extends Error<{}> {
-      readonly _tag = tag
-    }
-  }
-  ;(O.BaseEffectError.prototype as any).name = tag
-  return O.BaseEffectError as any
-}