Skip to content

Data

16 exports Added in v2.0.0 Source

Constructors

array

Added in v2.0.0 Source

Signature

declare function array<As extends readonly Array<any>>(as: As): Readonly<As>

Class

Added in v2.0.0 Source

Provides a constructor for a Case Class.

Signature

declare const Class: <A extends Record<string, any> = {}>(
  args: Types.VoidIfEmpty<{ [P in keyof A]: A[P] }>,
) => Readonly<A>;

Example

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)

Error

Added in v2.0.0 Source

Provides a constructor for a Case Class.

Signature

declare const Error: <A extends Record<string, any> = {}>(
  args: Types.VoidIfEmpty<{ [P in keyof A]: A[P] }>,
) => Cause.YieldableError & Readonly<A>;

struct

Added in v2.0.0 Source

Signature

declare const struct: <A extends Record<string, any>>(a: A) => { [P in keyof A]: A[P] };

Example

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)

Structural

Added in v2.0.0 Source

Signature

declare const Structural: <A>(args: Types.VoidIfEmpty<{ [P in keyof A]: A[P] }>) => {};

tagged

Added in v2.0.0 Source

Provides a tagged constructor for the specified Case.

Signature

declare function tagged<
  A extends {
    readonly _tag: string;
  },
>(tag: A["_tag"]): Constructor<A, "_tag">;

TaggedClass

Added in v2.0.0 Source

Provides a Tagged constructor for a Case Class.

Signature

declare function TaggedClass<Tag extends string>(
  tag: Tag,
): <A extends Record<string, any> = {}>(
  args: VoidIfEmpty<{ [P in string | number | symbol]: A[P] }>,
) => Readonly<A> & {
  readonly _tag: Tag;
};

taggedEnum

Added in v2.0.0 Source

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.

Signature

declare const taggedEnum: {
  <Z extends WithGenerics<1>>(): Simplify<
    {
      [Tag in string]: <A>(
        args: Args<
          Kind<Z, A, unknown, unknown, unknown>,
          Tag,
          Extract<
            Kind<Z, A, unknown, unknown, unknown>,
            {
              readonly _tag: Tag;
            }
          >
        >,
      ) => Extract<
        Kind<Z, A, unknown, unknown, unknown>,
        {
          readonly _tag: K;
        }
      >;
    } & GenericMatchers<Z>
  >;
  <Z extends WithGenerics<2>>(): Simplify<
    {
      [Tag in string]: <A, B>(
        args: Args<
          Kind<Z, A, B, unknown, unknown>,
          Tag,
          Extract<
            Kind<Z, A, B, unknown, unknown>,
            {
              readonly _tag: Tag;
            }
          >
        >,
      ) => Extract<
        Kind<Z, A, B, unknown, unknown>,
        {
          readonly _tag: K;
        }
      >;
    } & GenericMatchers<Z>
  >;
  <Z extends WithGenerics<3>>(): Simplify<
    {
      [Tag in string]: <A, B, C>(
        args: Args<
          Kind<Z, A, B, C, unknown>,
          Tag,
          Extract<
            Kind<Z, A, B, C, unknown>,
            {
              readonly _tag: Tag;
            }
          >
        >,
      ) => Extract<
        Kind<Z, A, B, C, unknown>,
        {
          readonly _tag: K;
        }
      >;
    } & GenericMatchers<Z>
  >;
  <Z extends WithGenerics<4>>(): Simplify<
    {
      [Tag in string]: <A, B, C, D>(
        args: Args<
          Kind<Z, A, B, C, D>,
          Tag,
          Extract<
            Kind<Z, A, B, C, D>,
            {
              readonly _tag: Tag;
            }
          >
        >,
      ) => Extract<
        Kind<Z, A, B, C, D>,
        {
          readonly _tag: K;
        }
      >;
    } & GenericMatchers<Z>
  >;
  <
    A extends {
      readonly _tag: string;
    },
  >(): Simplify<
    {
      [Tag in string]: 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: {
        <
          Cases extends {
            [Tag in string]: (
              args: Extract<
                A,
                {
                  readonly _tag: Tag;
                }
              >,
            ) => any;
          },
        >(
          cases: Cases & { [K in string | number | symbol]: never },
        ): (value: A) => Unify<ReturnType<Cases[A["_tag"]]>>;
        <
          Cases extends {
            [Tag in string]: (
              args: Extract<
                A,
                {
                  readonly _tag: Tag;
                }
              >,
            ) => any;
          },
        >(
          value: A,
          cases: Cases & { [K in string | number | symbol]: never },
        ): Unify<ReturnType<Cases[A["_tag"]]>>;
      };
    }
  >;
};

Example

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 })

TaggedError

Added in v2.0.0 Source

Signature

declare function TaggedError<Tag extends string>(
  tag: Tag,
): <A extends Record<string, any> = {}>(
  args: VoidIfEmpty<{ [P in string | number | symbol]: A[P] }>,
) => YieldableError & {
  readonly _tag: Tag;
} & Readonly<A>;

tuple

Added in v2.0.0 Source

Signature

declare function tuple<As extends readonly Array<any>>(...as: As): Readonly<As>

unsafeArray

Added in v2.0.0 Source

Signature

declare function unsafeArray<As extends readonly Array<any>>(as: As): Readonly<As>

unsafeStruct

Added in v2.0.0 Source

Signature

declare function unsafeStruct<A extends Record<string, any>>(
  as: A,
): { [P in string | number | symbol]: A[P] };

Models

TaggedEnum type

Added in v2.0.0 Source

Create a tagged enum data type, which is a union of Data structs.

Signature

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;
          } & { [K in keyof A[Tag]]: A[Tag][K] }
        >
      : never
    : never;

Example

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
    }

Other

case

Source

Signature

declare function case<A>(): Constructor<A>

Case

Added in v2.0.0 Source

TaggedEnum

Added in v2.0.0 Source