Skip to main content Link Search Menu Expand Document (external link)

Data overview

Added in v1.0.0


Table of contents


constructors

Class

Provides a constructor for a Case Class.

Signature

export declare const Class: new <A extends Record<string, any>>(
  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
) => Data<A>

Added in v1.0.0

Structural (class)

Signature

export declare class Structural<A> {
  constructor(args: Omit<A, keyof Equal.Equal>)
}

Added in v1.0.0

[Hash.symbol] (method)

Signature

[Hash.symbol](this: Equal.Equal)

Added in v1.0.0

[Equal.symbol] (method)

Signature

[Equal.symbol](this: Equal.Equal, that: Equal.Equal)

Added in v1.0.0

TaggedClass

Provides a Tagged constructor for a Case Class.

Signature

export declare const TaggedClass: <Key extends string>(
  tag: Key
) => new <A extends Record<string, any>>(
  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
) => Data<A & { _tag: Key }>

Added in v1.0.0

array

Signature

export declare const array: <As extends readonly any[]>(as: As) => Data<As>

Added in v1.0.0

case

Provides a constructor for the specified Case.

Signature

export declare const case: <A extends Case>() => Case.Constructor<A, never>

Added in v1.0.0

struct

Signature

export declare const struct: <As extends Readonly<Record<string, any>>>(as: As) => Data<As>

Added in v1.0.0

tagged

Provides a tagged constructor for the specified Case.

Signature

export declare const tagged: <A extends Case & { _tag: string }>(tag: A['_tag']) => Case.Constructor<A, '_tag'>

Added in v1.0.0

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.

Signature

export declare const taggedEnum: {
  <Z extends TaggedEnum.WithGenerics<1>>(): <K extends Z['taggedEnum']['_tag']>(
    tag: K
  ) => <A>(
    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, unknown, unknown, unknown>, K>
  ) => Extract<TaggedEnum.Kind<Z, A, unknown, unknown, unknown>, { readonly _tag: K }>
  <Z extends TaggedEnum.WithGenerics<2>>(): <K extends Z['taggedEnum']['_tag']>(
    tag: K
  ) => <A, B>(
    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B, unknown, unknown>, K>
  ) => Extract<TaggedEnum.Kind<Z, A, B, unknown, unknown>, { readonly _tag: K }>
  <Z extends TaggedEnum.WithGenerics<3>>(): <K extends Z['taggedEnum']['_tag']>(
    tag: K
  ) => <A, B, C>(
    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B, C, unknown>, K>
  ) => Extract<TaggedEnum.Kind<Z, A, B, C, unknown>, { readonly _tag: K }>
  <Z extends TaggedEnum.WithGenerics<4>>(): <K extends Z['taggedEnum']['_tag']>(
    tag: K
  ) => <A, B, C, D>(
    args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B, C, D>, K>
  ) => Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: K }>
  <A extends Data<{ readonly _tag: string }>>(): <K extends A['_tag']>(
    tag: K
  ) => Case.Constructor<Extract<A, { readonly _tag: K }>, '_tag'>
}

Example

import * as Data from '@effect/data/Data'

const HttpError = Data.taggedEnum<
  | Data.Data<{ _tag: 'BadRequest'; status: 400; message: string }>
  | Data.Data<{ _tag: 'NotFound'; status: 404; message: string }>
>()

const notFound = HttpError('NotFound')({ status: 404, message: 'Not Found' })

Example

import * as Data from '@effect/data/Data'

type MyResult<E, A> = Data.TaggedEnum<{
  Failure: { error: E }
  Success: { value: A }
}>
interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> {
  readonly taggedEnum: MyResult<this['A'], this['B']>
}
const MyResult = Data.taggedEnum<MyResultDefinition>()

const success = MyResult('Success')({ value: 1 })

Added in v1.0.0

tuple

Signature

export declare const tuple: <As extends readonly any[]>(...as: As) => Data<As>

Added in v1.0.0

unsafeArray

Signature

export declare const unsafeArray: <As extends readonly any[]>(as: As) => Data<As>

Added in v1.0.0

unsafeStruct

Signature

export declare const unsafeStruct: <As extends Readonly<Record<string, any>>>(as: As) => Data<As>

Added in v1.0.0

models

Case (interface)

Case represents a datatype similar to a case class in Scala. Namely, a datatype created using Case will, by default, provide an implementation for a constructor, Hash, and Equal.

Signature

export interface Case extends Equal.Equal {}

Added in v1.0.0

Data (type alias)

Signature

export type Data<A extends Readonly<Record<string, any>> | ReadonlyArray<any>> = Readonly<A> & Equal.Equal

Added in v1.0.0

TaggedEnum (type alias)

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

import * as Data from '@effect/data/Data'

type HttpError = Data.TaggedEnum<{
  BadRequest: { status: 400; message: string }
  NotFound: { status: 404; message: string }
}>

// Equivalent to:
type HttpErrorPlain =
  | Data.Data<{
      readonly _tag: 'BadRequest'
      readonly status: 400
      readonly message: string
    }>
  | Data.Data<{
      readonly _tag: 'NotFound'
      readonly status: 404
      readonly message: string
    }>

Signature

export type TaggedEnum<A extends Record<string, Record<string, any>>> = {
  readonly [Tag in keyof A]: Data<Readonly<Types.Simplify<A[Tag] & { _tag: Tag }>>>
}[keyof A]

Added in v1.0.0

utils

Case (namespace)

Added in v1.0.0

Constructor (interface)

Signature

export interface Constructor<A extends Case, T extends keyof A = never> {
  (args: Omit<A, T | keyof Equal.Equal> extends Record<PropertyKey, never> ? void : Omit<A, T | keyof Equal.Equal>): A
}

Added in v1.0.0

TaggedEnum (namespace)

Added in v1.0.0

WithGenerics (interface)

Signature

export interface WithGenerics<Count extends number> {
  readonly taggedEnum: Data<{ readonly _tag: string }>
  readonly numberOfGenerics: Count

  readonly A: unknown
  readonly B: unknown
  readonly C: unknown
  readonly D: unknown
}

Added in v1.0.0

Args (type alias)

Signature

export type Args<A extends Data<{ readonly _tag: string }>, K extends A['_tag']> = Omit<
  Extract<A, { readonly _tag: K }>,
  '_tag' | keyof Case
> extends infer T
  ? {} extends T
    ? void
    : T
  : never

Added in v1.0.0

Kind (type alias)

Signature

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']

Added in v1.0.0

Value (type alias)

Signature

export type Value<A extends Data<{ readonly _tag: string }>, K extends A['_tag']> = Extract<A, { readonly _tag: K }>

Added in v1.0.0