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

ParseResult overview

Added in v3.10.0

Table of contents

constructors

fail

Signature

export declare const fail: (issue: ParseIssue) => Either.Either<never, ParseIssue>

Added in v3.10.0

fromOption

Signature

export declare const fromOption: {
  (onNone: () => ParseIssue): <A>(self: Option.Option<A>) => Either.Either<A, ParseIssue>
  <A>(self: Option.Option<A>, onNone: () => ParseIssue): Either.Either<A, ParseIssue>
}

Added in v3.10.0

parseError

Signature

export declare const parseError: (issue: ParseIssue) => ParseError

Added in v3.10.0

succeed

Signature

export declare const succeed: <A>(a: A) => Either.Either<A, ParseIssue>

Added in v3.10.0

try

Signature

export declare const try: <A>(options: { try: LazyArg<A>; catch: (e: unknown) => ParseIssue; }) => Either.Either<A, ParseIssue>

Added in v3.10.0

decoding

decode

Signature

export declare const decode: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (i: I, overrideOptions?: AST.ParseOptions) => Effect.Effect<A, ParseIssue, R>

Added in v3.10.0

decodeEither

Signature

export declare const decodeEither: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (i: I, overrideOptions?: AST.ParseOptions) => Either.Either<A, ParseIssue>

Added in v3.10.0

decodeOption

Signature

export declare const decodeOption: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (i: I, overrideOptions?: AST.ParseOptions) => Option.Option<A>

Added in v3.10.0

decodePromise

Signature

export declare const decodePromise: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (i: I, overrideOptions?: AST.ParseOptions) => Promise<A>

Added in v3.10.0

decodeSync

Signature

export declare const decodeSync: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (i: I, overrideOptions?: AST.ParseOptions) => A

Added in v3.10.0

decodeUnknown

Signature

export declare const decodeUnknown: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Effect.Effect<A, ParseIssue, R>

Added in v3.10.0

decodeUnknownEither

Signature

export declare const decodeUnknownEither: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Either.Either<A, ParseIssue>

Added in v3.10.0

decodeUnknownOption

Signature

export declare const decodeUnknownOption: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Option.Option<A>

Added in v3.10.0

decodeUnknownPromise

Signature

export declare const decodeUnknownPromise: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Promise<A>

Added in v3.10.0

decodeUnknownSync

Signature

export declare const decodeUnknownSync: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => A

Added in v3.10.0

encoding

encode

Signature

export declare const encode: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (a: A, overrideOptions?: AST.ParseOptions) => Effect.Effect<I, ParseIssue, R>

Added in v3.10.0

encodeEither

Signature

export declare const encodeEither: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (a: A, overrideOptions?: AST.ParseOptions) => Either.Either<I, ParseIssue>

Added in v3.10.0

encodeOption

Signature

export declare const encodeOption: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (input: A, overrideOptions?: AST.ParseOptions) => Option.Option<I>

Added in v3.10.0

encodePromise

Signature

export declare const encodePromise: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (a: A, overrideOptions?: AST.ParseOptions) => Promise<I>

Added in v3.10.0

encodeSync

Signature

export declare const encodeSync: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (a: A, overrideOptions?: AST.ParseOptions) => I

Added in v3.10.0

encodeUnknown

Signature

export declare const encodeUnknown: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Effect.Effect<I, ParseIssue, R>

Added in v3.10.0

encodeUnknownEither

Signature

export declare const encodeUnknownEither: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Either.Either<I, ParseIssue>

Added in v3.10.0

encodeUnknownOption

Signature

export declare const encodeUnknownOption: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Option.Option<I>

Added in v3.10.0

encodeUnknownPromise

Signature

export declare const encodeUnknownPromise: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Promise<I>

Added in v3.10.0

encodeUnknownSync

Signature

export declare const encodeUnknownSync: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => I

Added in v3.10.0

formatting

ArrayFormatter

Signature

export declare const ArrayFormatter: ParseResultFormatter<ArrayFormatterIssue[]>

Added in v3.10.0

ParseResultFormatter (interface)

Signature

export interface ParseResultFormatter<A> {
  readonly formatIssue: (issue: ParseIssue) => Effect.Effect<A>
  readonly formatIssueSync: (issue: ParseIssue) => A
  readonly formatError: (error: ParseError) => Effect.Effect<A>
  readonly formatErrorSync: (error: ParseError) => A
}

Added in v3.10.0

TreeFormatter

Signature

export declare const TreeFormatter: ParseResultFormatter<string>

Added in v3.10.0

guards

isComposite

Returns true if the value is a Composite.

Signature

export declare const isComposite: (issue: ParseIssue) => issue is Extract<ParseIssue, { _tag: "Composite" }>

Added in v3.10.0

model

ArrayFormatterIssue (interface)

Signature

export interface ArrayFormatterIssue {
  readonly _tag: ParseIssue["_tag"]
  readonly path: ReadonlyArray<PropertyKey>
  readonly message: string
}

Added in v3.10.0

Composite (class)

Error that contains multiple issues.

Signature

export declare class Composite { constructor(
    readonly ast: AST.AST,
    readonly actual: unknown,
    readonly issues: SingleOrNonEmpty<ParseIssue>,
    readonly output?: unknown
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Composite"

Added in v3.10.0

Forbidden (class)

The Forbidden variant of the ParseIssue type represents a forbidden operation, such as when encountering an Effect that is not allowed to execute (e.g., using runSync).

Signature

export declare class Forbidden { constructor(
    readonly ast: AST.AST,
    readonly actual: unknown,
    readonly message?: string
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Forbidden"

Added in v3.10.0

Missing (class)

Error that occurs when a required key or index is missing.

Signature

export declare class Missing { constructor(
    /**
     * @since 3.10.0
     */
    readonly ast: AST.Type,
    /**
     * @since 3.10.0
     */
    readonly message?: string
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Missing"

Added in v3.10.0

actual (property)

Signature

readonly actual: undefined

Added in v3.10.0

ParseIssue (type alias)

ParseIssue is a type that represents the different types of errors that can occur when decoding/encoding a value.

Signature

export type ParseIssue =
  // leaf
  | Type
  | Missing
  | Unexpected
  | Forbidden
  // composite
  | Pointer
  | Refinement
  | Transformation
  | Composite

Added in v3.10.0

Path (type alias)

Signature

export type Path = SingleOrNonEmpty<PropertyKey>

Added in v3.10.0

Pointer (class)

Signature

export declare class Pointer { constructor(
    readonly path: Path,
    readonly actual: unknown,
    readonly issue: ParseIssue
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Pointer"

Added in v3.10.0

Refinement (class)

Error that occurs when a refinement has an error.

Signature

export declare class Refinement { constructor(
    readonly ast: AST.Refinement,
    readonly actual: unknown,
    readonly kind: "From" | "Predicate",
    readonly issue: ParseIssue
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Refinement"

Added in v3.10.0

SingleOrNonEmpty (type alias)

Signature

export type SingleOrNonEmpty<A> = A | array_.NonEmptyReadonlyArray<A>

Added in v3.10.0

Transformation (class)

Error that occurs when a transformation has an error.

Signature

export declare class Transformation { constructor(
    readonly ast: AST.Transformation,
    readonly actual: unknown,
    readonly kind: "Encoded" | "Transformation" | "Type",
    readonly issue: ParseIssue
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Transformation"

Added in v3.10.0

Type (class)

The Type variant of the ParseIssue type represents an error that occurs when the actual value is not of the expected type. The ast field specifies the expected type, and the actual field contains the value that caused the error.

Signature

export declare class Type { constructor(
    readonly ast: AST.AST,
    readonly actual: unknown,
    readonly message?: string
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Type"

Added in v3.10.0

Unexpected (class)

Error that occurs when an unexpected key or index is present.

Signature

export declare class Unexpected { constructor(
    readonly actual: unknown,
    /**
     * @since 3.10.0
     */
    readonly message?: string
  ) }

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "Unexpected"

Added in v3.10.0

optimisation

eitherOrUndefined

Signature

export declare const eitherOrUndefined: <A, E, R>(self: Effect.Effect<A, E, R>) => Either.Either<A, E> | undefined

Added in v3.10.0

flatMap

Signature

export declare const flatMap: {
  <A, B, E1, R1>(
    f: (a: A) => Effect.Effect<B, E1, R1>
  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E1 | E, R1 | R>
  <A, E, R, B, E1, R1>(
    self: Effect.Effect<A, E, R>,
    f: (a: A) => Effect.Effect<B, E1, R1>
  ): Effect.Effect<B, E | E1, R | R1>
}

Added in v3.10.0

map

Signature

export declare const map: {
  <A, B>(f: (a: A) => B): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
  <A, E, R, B>(self: Effect.Effect<A, E, R>, f: (a: A) => B): Effect.Effect<B, E, R>
}

Added in v3.10.0

mapBoth

Signature

export declare const mapBoth: {
  <E, E2, A, A2>(options: {
    readonly onFailure: (e: E) => E2
    readonly onSuccess: (a: A) => A2
  }): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2, E2, R>
  <A, E, R, E2, A2>(
    self: Effect.Effect<A, E, R>,
    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
  ): Effect.Effect<A2, E2, R>
}

Added in v3.10.0

mapError

Signature

export declare const mapError: {
  <E, E2>(f: (e: E) => E2): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2, R>
  <A, E, R, E2>(self: Effect.Effect<A, E, R>, f: (e: E) => E2): Effect.Effect<A, E2, R>
}

Added in v3.10.0

orElse

Signature

export declare const orElse: {
  <E, A2, E2, R2>(
    f: (e: E) => Effect.Effect<A2, E2, R2>
  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A2 | A, E2, R2 | R>
  <A, E, R, A2, E2, R2>(
    self: Effect.Effect<A, E, R>,
    f: (e: E) => Effect.Effect<A2, E2, R2>
  ): Effect.Effect<A2 | A, E2, R2 | R>
}

Added in v3.10.0

type id

ParseErrorTypeId

Signature

export declare const ParseErrorTypeId: typeof ParseErrorTypeId

Added in v3.10.0

ParseErrorTypeId (type alias)

Signature

export type ParseErrorTypeId = typeof ParseErrorTypeId

Added in v3.10.0

utils

DeclarationDecodeUnknown (type alias)

Signature

export type DeclarationDecodeUnknown<Out, R> = (
  u: unknown,
  options: AST.ParseOptions,
  ast: AST.Declaration
) => Effect.Effect<Out, ParseIssue, R>

Added in v3.10.0

DecodeUnknown (type alias)

Signature

export type DecodeUnknown<Out, R> = (u: unknown, options?: AST.ParseOptions) => Effect.Effect<Out, ParseIssue, R>

Added in v3.10.0

ParseError (class)

Signature

export declare class ParseError

Added in v3.10.0

toString (method)

Signature

toString()

Added in v3.10.0

toJSON (method)

Signature

toJSON()

Added in v3.10.0

[Inspectable.NodeInspectSymbol] (method)

Signature

;[Inspectable.NodeInspectSymbol]()

Added in v3.10.0

[ParseErrorTypeId] (property)

Signature

readonly [ParseErrorTypeId]: symbol

Added in v3.10.0

isParseError

Signature

export declare const isParseError: (u: unknown) => u is ParseError

Added in v3.10.0

validation

asserts

By default the option exact is set to true.

Signature

export declare const asserts: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => asserts u is A

Added in v3.10.0

is

By default the option exact is set to true.

Signature

export declare const is: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions | number) => u is A

Added in v3.10.0

validate

Signature

export declare const validate: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (a: unknown, overrideOptions?: AST.ParseOptions) => Effect.Effect<A, ParseIssue, R>

Added in v3.10.0

validateEither

Signature

export declare const validateEither: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Either.Either<A, ParseIssue>

Added in v3.10.0

validateOption

Signature

export declare const validateOption: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Option.Option<A>

Added in v3.10.0

validatePromise

Signature

export declare const validatePromise: <A, I>(
  schema: Schema.Schema<A, I, never>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => Promise<A>

Added in v3.10.0

validateSync

Signature

export declare const validateSync: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: AST.ParseOptions
) => (u: unknown, overrideOptions?: AST.ParseOptions) => A

Added in v3.10.0