Data
Constructors
Signature
declare function array<As extends readonly Array<any>>(as: As): Readonly<As>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)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>;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] }>) => {};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>;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
}
Provides a constructor for a Case Class.