Skip to content
Effect Days 2026 Get your ticket

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>

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


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
)

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">

Example

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

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

Example

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

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>

Example

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)

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