<S extends Schema.Constraint>(schema: S): <
IE = never,
Done = unknown
>() => Channel.Channel<
Arr.NonEmptyReadonlyArray<S["Type"]>,
IE | Schema.SchemaError,
Done,
Arr.NonEmptyReadonlyArray<S["Encoded"]>,
IE,
Done,
S["DecodingServices"]
>Creates a channel that decodes non-empty chunks from the schema's encoded representation into schema values.
When to use
Use to validate and decode encoded channel output into typed schema values before application code consumes it.
Details
Decoding failures are emitted as SchemaError, and any decoding services
required by the schema become channel requirements.
Source effect/ChannelSchema.ts:9815 lines
export const const decode: <
S extends Schema.Constraint
>(
schema: S
) => <
IE = never,
Done = unknown
>() => Channel.Channel<
Arr.NonEmptyReadonlyArray<S["Type"]>,
IE | Schema.SchemaError,
Done,
Arr.NonEmptyReadonlyArray<S["Encoded"]>,
IE,
Done,
S["DecodingServices"]
>
Creates a channel that decodes non-empty chunks from the schema's encoded
representation into schema values.
When to use
Use to validate and decode encoded channel output into typed schema values
before application code consumes it.
Details
Decoding failures are emitted as SchemaError, and any decoding services
required by the schema become channel requirements.
decode = <function (type parameter) S in <S extends Schema.Constraint>(schema: S): <IE = never, Done = unknown>() => Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>S extends import SchemaSchema.Constraint>(
schema: S extends Schema.Constraintschema: function (type parameter) S in <S extends Schema.Constraint>(schema: S): <IE = never, Done = unknown>() => Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>S
) =>
<function (type parameter) IE in <IE = never, Done = unknown>(): Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>IE = never, function (type parameter) Done in <IE = never, Done = unknown>(): Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>Done = unknown>(): import ChannelChannel.type Channel.Channel = /*unresolved*/ anyChannel<
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) S in <S extends Schema.Constraint>(schema: S): <IE = never, Done = unknown>() => Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>S["Type"]>,
function (type parameter) IE in <IE = never, Done = unknown>(): Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>IE | import SchemaSchema.class SchemaError
export SchemaError
class SchemaError {
message: string;
toString: () => string;
name: string;
stack: string;
cause: unknown;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toJSON: () => unknown;
_tag: Tag;
issue: Issue;
}
Error thrown (or returned as the error channel value) when schema decoding
or encoding fails.
Details
The issue field contains a structured
SchemaIssue.Issue
tree describing
every validation failure, including the path to the problematic value,
expected types, and actual values received. message renders the issue tree
as a human-readable string.
Use
isSchemaError
to narrow an unknown value to SchemaError.
Example (Catching a SchemaError)
import { Schema } from "effect"
try {
Schema.decodeUnknownSync(Schema.Number)("not a number")
} catch (err) {
if (Schema.isSchemaError(err)) {
console.log(err.message)
// Expected number, actual "not a number"
}
}
SchemaError,
function (type parameter) Done in <IE = never, Done = unknown>(): Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>Done,
import ArrArr.type Arr.NonEmptyReadonlyArray = /*unresolved*/ anyNonEmptyReadonlyArray<function (type parameter) S in <S extends Schema.Constraint>(schema: S): <IE = never, Done = unknown>() => Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>S["Encoded"]>,
function (type parameter) IE in <IE = never, Done = unknown>(): Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>IE,
function (type parameter) Done in <IE = never, Done = unknown>(): Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>Done,
function (type parameter) S in <S extends Schema.Constraint>(schema: S): <IE = never, Done = unknown>() => Channel.Channel<Arr.NonEmptyReadonlyArray<S["Type"]>, IE | Schema.SchemaError, Done, Arr.NonEmptyReadonlyArray<S["Encoded"]>, IE, Done, S["DecodingServices"]>S["DecodingServices"]
> => {
const const decode: (
input: readonly [
S["Encoded"],
...S["Encoded"][]
],
options?: SchemaAST.ParseOptions
) => Effect.Effect<
readonly [S["Type"], ...S["Type"][]],
SchemaError,
S["DecodingServices"]
>
import SchemaSchema.const decodeEffect: <
S extends Constraint
>(
schema: S,
options?: SchemaAST.ParseOptions
) => (
input: S["Encoded"],
options?: SchemaAST.ParseOptions
) => Effect.Effect<
S["Type"],
SchemaError,
S["DecodingServices"]
>
Decodes a typed input (the schema's Encoded type) against a schema,
returning an Effect that succeeds with the decoded value or fails with a
When to use
Use when you need to decode input already typed as the schema's Encoded
type in an Effect whose failure channel is SchemaError.
Details
For unknown input use
decodeUnknownEffect
.
Options may be provided either when creating the decoder or when applying it;
application options override creation options.
decodeEffect(import SchemaSchema.const NonEmptyArray: NonEmptyArrayLambda
;<S>(self: S) => Schema.NonEmptyArray<S>
Type-level representation returned by
NonEmptyArray
.
Defines a non-empty ReadonlyArray schema — at least one element required.
Type is readonly [T, ...T[]].
Example (Defining a non-empty array of numbers)
import { Schema } from "effect"
const schema = Schema.NonEmptyArray(Schema.Number)
Schema.decodeUnknownSync(schema)([1, 2, 3]) // ok
Schema.decodeUnknownSync(schema)([]) // throws
NonEmptyArray(schema: S extends Schema.Constraintschema))
return import ChannelChannel.fromTransform((upstream: Pull<
readonly [S["Encoded"], ...S["Encoded"][]],
IE,
Done,
never
>
(parameter) upstream: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
_scope: Scope(parameter) _scope: {
strategy: "sequential" | "parallel";
state: State.Open | State.Closed | State.Empty;
}
import EffectEffect.const succeed: <A>(value: A) => Effect<A>Creates an Effect that always succeeds with a given value.
When to use
Use when an effect should complete successfully with a specific value without any errors
or external dependencies.
Example (Creating a successful effect)
import { Effect } from "effect"
// Creating an effect that represents a successful scenario
//
// ┌─── Effect<number, never, never>
// ▼
const success = Effect.succeed(42)
succeed(import EffectEffect.const flatMap: {
<A, B, E1, R1>(
f: (a: A) => Effect<B, E1, R1>
): <E, R>(
self: Effect<A, E, R>
) => Effect<B, E1 | E, R1 | R>
<A, E, R, B, E1, R1>(
self: Effect<A, E, R>,
f: (a: A) => Effect<B, E1, R1>
): Effect<B, E | E1, R | R1>
}
upstream: Pull<
readonly [S["Encoded"], ...S["Encoded"][]],
IE,
Done,
never
>
(parameter) upstream: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
chunk: unknown(parameter) chunk: {
0: S['Encoded'];
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<S['Encoded']>>): Array<S['Encoded']>; (...items: Array<S['Encoded'] | ConcatArray<S['Encoded']>>): Array<S['Encoded']> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<S['Encoded']>;
indexOf: (searchElement: S['Encoded'], fromIndex?: number) => number;
lastIndexOf: (searchElement: S['Encoded'], fromIndex?: number) => number;
every: { (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, th…;
some: (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => void, thisArg?: any) => void;
map: (callbackfn: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): Array<S>; (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any)…;
reduce: { (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], currentIndex: number, array: ReadonlyArray<S['Encoded']>) => S['Encoded']): S['Encoded']; (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], curre…;
reduceRight: { (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], currentIndex: number, array: ReadonlyArray<S['Encoded']>) => S['Encoded']): S['Encoded']; (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], curre…;
find: { (predicate: (value: S['Encoded'], index: number, obj: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): S | undefined; (predicate: (value: S['Encoded'], index: number, obj: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any…;
findIndex: (predicate: (value: S['Encoded'], index: number, obj: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, S['Encoded']]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<S['Encoded']>;
includes: (searchElement: S['Encoded'], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: S['Encoded'], index: number, array: Array<S['Encoded']>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => S['Encoded'] | undefined;
findLast: { (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): S | undefined; (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?:…;
findLastIndex: (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any) => number;
toReversed: () => Array<S['Encoded']>;
toSorted: (compareFn?: ((a: S['Encoded'], b: S['Encoded']) => number) | undefined) => Array<S['Encoded']>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<S['Encoded']>): Array<S['Encoded']>; (start: number, deleteCount?: number): Array<S['Encoded']> };
with: (index: number, value: S['Encoded']) => Array<S['Encoded']>;
}
const decode: (
input: readonly [
S["Encoded"],
...S["Encoded"][]
],
options?: SchemaAST.ParseOptions
) => Effect.Effect<
readonly [S["Type"], ...S["Type"][]],
SchemaError,
S["DecodingServices"]
>
chunk: unknown(parameter) chunk: {
0: S['Encoded'];
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<S['Encoded']>>): Array<S['Encoded']>; (...items: Array<S['Encoded'] | ConcatArray<S['Encoded']>>): Array<S['Encoded']> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<S['Encoded']>;
indexOf: (searchElement: S['Encoded'], fromIndex?: number) => number;
lastIndexOf: (searchElement: S['Encoded'], fromIndex?: number) => number;
every: { (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, th…;
some: (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => void, thisArg?: any) => void;
map: (callbackfn: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): Array<S>; (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any)…;
reduce: { (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], currentIndex: number, array: ReadonlyArray<S['Encoded']>) => S['Encoded']): S['Encoded']; (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], curre…;
reduceRight: { (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], currentIndex: number, array: ReadonlyArray<S['Encoded']>) => S['Encoded']): S['Encoded']; (callbackfn: (previousValue: S['Encoded'], currentValue: S['Encoded'], curre…;
find: { (predicate: (value: S['Encoded'], index: number, obj: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): S | undefined; (predicate: (value: S['Encoded'], index: number, obj: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any…;
findIndex: (predicate: (value: S['Encoded'], index: number, obj: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, S['Encoded']]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<S['Encoded']>;
includes: (searchElement: S['Encoded'], fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: S['Encoded'], index: number, array: Array<S['Encoded']>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => S['Encoded'] | undefined;
findLast: { (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => value is S, thisArg?: any): S | undefined; (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?:…;
findLastIndex: (predicate: (value: S['Encoded'], index: number, array: ReadonlyArray<S['Encoded']>) => unknown, thisArg?: any) => number;
toReversed: () => Array<S['Encoded']>;
toSorted: (compareFn?: ((a: S['Encoded'], b: S['Encoded']) => number) | undefined) => Array<S['Encoded']>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<S['Encoded']>): Array<S['Encoded']>; (start: number, deleteCount?: number): Array<S['Encoded']> };
with: (index: number, value: S['Encoded']) => Array<S['Encoded']>;
}
Referenced by 2 symbols