Union<Members>Creates a union schema from an array of member schemas. Members are tested in order; the first match is returned.
Details
Optionally, specify mode:
"anyOf"(default) — matches if any member matches."oneOf"— matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42constructors
Source effect/Schema.ts:472090 lines
export interface interface Union<Members extends ReadonlyArray<Constraint>>Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Type-level representation returned by
Union
.
Union<function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members extends interface ReadonlyArray<T>ReadonlyArray<Constraint>> extends
interface BottomLazy<out Ast extends SchemaAST.AST, out Rebuild extends Top, in out TypeParameters extends ReadonlyArray<Constraint> = readonly [], out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required">Lazy Bottom variant for schema implementations that compute their public
views on demand.
When to use
Use as an implementation base for schema interfaces that must expose
Bottom behavior without forcing TypeScript to eagerly evaluate expensive
Type, Encoded, or service views.
Details
The laziness is purely type-level; runtime behavior is unchanged.
BottomLazy keeps the structural operations inherited from Bottom, but
erases the expensive schema views to unknown. Concrete schema interfaces can
then redeclare the precise views they expose. This keeps wide schemas such as
Struct and Union cheaper when generic code reads a single view, while
preserving their exact public types.
BottomLazy<
import SchemaASTSchemaAST.class Union<A extends SchemaAST.AST = SchemaAST.AST>class Union {
_tag: 'Union';
types: ReadonlyArray<A>;
mode: "anyOf" | "oneOf";
encodingChecks: Checks | undefined;
getParser: (recur: (ast: AST) => SchemaParser.Parser) => SchemaParser.Parser;
_rebuild: (recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) => Union<AST>;
recur: (recur: (ast: AST) => AST) => Union<AST>;
flip: (recur: (ast: AST) => AST) => Union<AST>;
matchPart: (s: string, options: ParseOptions) => LiteralValue | undefined;
getExpected: (getExpected: (ast: AST) => string) => string;
annotations: Schema.Annotations.Annotations | undefined;
checks: Checks | undefined;
encoding: Encoding | undefined;
context: Context | undefined;
toString: () => string;
}
AST node representing a union of schemas.
Details
types — the member AST nodes.mode — "anyOf" succeeds on the first match (like TypeScript unions);
"oneOf" requires exactly one member to match (fails if multiple do).
During parsing, members are tried in order. An internal candidate index
narrows which members to try based on the runtime type of the input and
discriminant ("sentinel") fields, making large unions efficient.
Example (Inspecting a union AST)
import { Schema, SchemaAST } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
const ast = schema.ast
if (SchemaAST.isUnion(ast)) {
console.log(ast.types.length) // 2
console.log(ast.mode) // "anyOf"
}
Union<{ [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["ast"] }[number]>,
interface Union<Members extends ReadonlyArray<Constraint>>Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Type-level representation returned by
Union
.
Union<function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members>
>
{
readonly "Type": { [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["Type"] }[number]
readonly "Encoded": { [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["Encoded"] }[number]
readonly "DecodingServices": { [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["DecodingServices"] }[number]
readonly "EncodingServices": { [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["EncodingServices"] }[number]
readonly "~type.make.in": { [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["~type.make"] }[number]
readonly "~type.make": { [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["~type.make"] }[number]
readonly "Iso": { [function (type parameter) KK in keyof function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members]: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members[function (type parameter) KK]["Iso"] }[number]
readonly Union<Members extends ReadonlyArray<Constraint>>.members: Members extends ReadonlyArray<Constraint>members: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members
/**
* Returns a new union with the members modified by the provided function.
*
* **Details**
*
* Options:
*
* - `unsafePreserveChecks` - if `true`, keep any `.check(...)` constraints
* that were attached to the original union. Defaults to `false`.
*
* **Warning**: This is an unsafe operation. Since `mapFields`
* transformations change the schema type, the original refinement functions
* may no longer be valid or safe to apply to the transformed schema. Only
* use this option if you have verified that your refinements remain correct
* after the transformation.
*/
Union<To extends ReadonlyArray<Constraint>>(f: (members: Members) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined): Union<Simplify<Readonly<To>>>Returns a new union with the members modified by the provided function.
Details
Options:
-
unsafePreserveChecks - if true, keep any .check(...) constraints
that were attached to the original union. Defaults to false.
Warning: This is an unsafe operation. Since mapFields
transformations change the schema type, the original refinement functions
may no longer be valid or safe to apply to the transformed schema. Only
use this option if you have verified that your refinements remain correct
after the transformation.
mapMembers<function (type parameter) To in Union<Members extends ReadonlyArray<Constraint>>.mapMembers<To extends ReadonlyArray<Constraint>>(f: (members: Members) => To, options?: {
readonly unsafePreserveChecks?: boolean | undefined;
} | undefined): Union<Simplify<Readonly<To>>>
interface ReadonlyArray<T>ReadonlyArray<Constraint>>(
f: (members: Members) => Tof: (members: Members extends ReadonlyArray<Constraint>members: function (type parameter) Members in Union<Members extends ReadonlyArray<Constraint>>Members) => function (type parameter) To in Union<Members extends ReadonlyArray<Constraint>>.mapMembers<To extends ReadonlyArray<Constraint>>(f: (members: Members) => To, options?: {
readonly unsafePreserveChecks?: boolean | undefined;
} | undefined): Union<Simplify<Readonly<To>>>
options: | {
readonly unsafePreserveChecks?:
| boolean
| undefined
}
| undefined
unsafePreserveChecks?: boolean | undefinedunsafePreserveChecks?: boolean | undefined
} | undefined
): interface Union<Members extends ReadonlyArray<Constraint>>Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Type-level representation returned by
Union
.
Union<type Simplify<T> = { [K in keyof T]: T[K]; }Flattens intersection types into a single object type for readability.
When to use
Use when hovering over a type shows A & B & C instead of the merged shape.
Details
This helper is purely cosmetic at the type level and has no runtime effect.
It preserves readonly modifiers; use
Mutable
to strip them.
Example (Flattening an intersection)
import type { Struct } from "effect"
type Original = { a: string } & { b: number }
// Without Simplify, the type displays as `{ a: string } & { b: number }`
type Simplified = Struct.Simplify<Original>
// { a: string; b: number }
Simplify<type Readonly<T> = {
readonly [P in keyof T]: T[P]
}
Make all properties in T readonly
Readonly<function (type parameter) To in Union<Members extends ReadonlyArray<Constraint>>.mapMembers<To extends ReadonlyArray<Constraint>>(f: (members: Members) => To, options?: {
readonly unsafePreserveChecks?: boolean | undefined;
} | undefined): Union<Simplify<Readonly<To>>>
function makeUnion<
Members extends ReadonlyArray<Constraint>
>(
ast: SchemaAST.Union<Members[number]["ast"]>,
members: Members
): Union<Members>
function (type parameter) Members in makeUnion<Members extends ReadonlyArray<Constraint>>(ast: SchemaAST.Union<Members[number]["ast"]>, members: Members): Union<Members>Members extends interface ReadonlyArray<T>ReadonlyArray<Constraint>>(
ast: SchemaAST.Union<Members[number]["ast"]>(parameter) ast: {
_tag: 'Union';
types: ReadonlyArray<A>;
mode: "anyOf" | "oneOf";
encodingChecks: Checks | undefined;
getParser: (recur: (ast: AST) => SchemaParser.Parser) => SchemaParser.Parser;
_rebuild: (recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) => Union<AST>;
recur: (recur: (ast: AST) => AST) => Union<AST>;
flip: (recur: (ast: AST) => AST) => Union<AST>;
matchPart: (s: string, options: ParseOptions) => LiteralValue | undefined;
getExpected: (getExpected: (ast: AST) => string) => string;
annotations: Schema.Annotations.Annotations | undefined;
checks: Checks | undefined;
encoding: Encoding | undefined;
context: Context | undefined;
toString: () => string;
}
import SchemaASTSchemaAST.class Union<A extends SchemaAST.AST = SchemaAST.AST>class Union {
_tag: 'Union';
types: ReadonlyArray<A>;
mode: "anyOf" | "oneOf";
encodingChecks: Checks | undefined;
getParser: (recur: (ast: AST) => SchemaParser.Parser) => SchemaParser.Parser;
_rebuild: (recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) => Union<AST>;
recur: (recur: (ast: AST) => AST) => Union<AST>;
flip: (recur: (ast: AST) => AST) => Union<AST>;
matchPart: (s: string, options: ParseOptions) => LiteralValue | undefined;
getExpected: (getExpected: (ast: AST) => string) => string;
annotations: Schema.Annotations.Annotations | undefined;
checks: Checks | undefined;
encoding: Encoding | undefined;
context: Context | undefined;
toString: () => string;
}
AST node representing a union of schemas.
Details
types — the member AST nodes.mode — "anyOf" succeeds on the first match (like TypeScript unions);
"oneOf" requires exactly one member to match (fails if multiple do).
During parsing, members are tried in order. An internal candidate index
narrows which members to try based on the runtime type of the input and
discriminant ("sentinel") fields, making large unions efficient.
Example (Inspecting a union AST)
import { Schema, SchemaAST } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
const ast = schema.ast
if (SchemaAST.isUnion(ast)) {
console.log(ast.types.length) // 2
console.log(ast.mode) // "anyOf"
}
Union<function (type parameter) Members in makeUnion<Members extends ReadonlyArray<Constraint>>(ast: SchemaAST.Union<Members[number]["ast"]>, members: Members): Union<Members>Members[number]["ast"]>,
members: Members extends ReadonlyArray<Constraint>members: function (type parameter) Members in makeUnion<Members extends ReadonlyArray<Constraint>>(ast: SchemaAST.Union<Members[number]["ast"]>, members: Members): Union<Members>Members
): interface Union<Members extends ReadonlyArray<Constraint>>Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Type-level representation returned by
Union
.
Union<function (type parameter) Members in makeUnion<Members extends ReadonlyArray<Constraint>>(ast: SchemaAST.Union<Members[number]["ast"]>, members: Members): Union<Members>Members> {
return const make: <S extends Constraint>(
ast: S["ast"],
options?: object
) => S
Creates a schema from an AST (Abstract Syntax Tree) node.
Details
This is the fundamental constructor for all schemas in the Effect Schema
library. It takes an AST node and wraps it in a fully-typed schema that
preserves all type information and provides the complete schema API.
The make function is used internally to create all primitive schemas like
String, Number, Boolean, etc., as well as more complex schemas. It's
the bridge between the untyped AST representation and the strongly-typed
schema.
make(ast: SchemaAST.Union<Members[number]["ast"]>(parameter) ast: {
_tag: 'Union';
types: ReadonlyArray<A>;
mode: "anyOf" | "oneOf";
encodingChecks: Checks | undefined;
getParser: (recur: (ast: AST) => SchemaParser.Parser) => SchemaParser.Parser;
_rebuild: (recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) => Union<AST>;
recur: (recur: (ast: AST) => AST) => Union<AST>;
flip: (recur: (ast: AST) => AST) => Union<AST>;
matchPart: (s: string, options: ParseOptions) => LiteralValue | undefined;
getExpected: (getExpected: (ast: AST) => string) => string;
annotations: Schema.Annotations.Annotations | undefined;
checks: Checks | undefined;
encoding: Encoding | undefined;
context: Context | undefined;
toString: () => string;
}
members: Members extends ReadonlyArray<Constraint>members,
mapMembers<To extends ReadonlyArray<Constraint>>(this: Union<Members>, f: (members: Members) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined): Union<Simplify<Readonly<To>>>mapMembers<function (type parameter) To in mapMembers<To extends ReadonlyArray<Constraint>>(this: Union<Members>, f: (members: Members) => To, options?: {
readonly unsafePreserveChecks?: boolean | undefined;
} | undefined): Union<Simplify<Readonly<To>>>
interface ReadonlyArray<T>ReadonlyArray<Constraint>>(
this: Union<Members>(parameter) this: {
Type: { [K in keyof Members]: Members[K]["Type"]; }[number];
Encoded: { [K in keyof Members]: Members[K]["Encoded"]; }[number];
DecodingServices: { [K in keyof Members]: Members[K]["DecodingServices"]; }[number];
EncodingServices: { [K in keyof Members]: Members[K]["EncodingServices"]; }[number];
Iso: { [K in keyof Members]: Members[K]["Iso"]; }[number];
members: Members;
mapMembers: (f: (members: Members) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Annotations.Bottom<{ [K in keyof Members]: Members[K]['Type']; }[number], readonly []>) => Union<Members>;
annotateKey: (annotations: Annotations.Key<{ [K in keyof Members]: Members[K]['Type']; }[number]>) => Union<Members>;
check: (checks_0: SchemaAST.Check<{ [K in keyof Members]: Members[K]['Type']; }[number]>, ...checks: Array<SchemaAST.Check<{ [K in keyof Members]: Members[K]['Type']; }[number]>>) => Union<Members>;
rebuild: (ast: SchemaAST.Union<{ [K in keyof Members]: Members[K]['ast']; }[number]>) => Union<Members>;
make: (input: { [K in keyof Members]: Members[K]['~type.make']; }[number], options?: MakeOptions) => { [K in keyof Members]: Members[K]['Type']; }[number];
makeOption: (input: { [K in keyof Members]: Members[K]['~type.make']; }[number], options?: MakeOptions) => Option_.Option<{ [K in keyof Members]: Members[K]['Type']; }[number]>;
makeEffect: (input: { [K in keyof Members]: Members[K]['~type.make']; }[number], options?: MakeOptions) => Effect.Effect<{ [K in keyof Members]: Members[K]['Type']; }[number], SchemaError, never>;
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; <…;
}
interface Union<Members extends ReadonlyArray<Constraint>>Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Type-level representation returned by
Union
.
Union<function (type parameter) Members in makeUnion<Members extends ReadonlyArray<Constraint>>(ast: SchemaAST.Union<Members[number]["ast"]>, members: Members): Union<Members>Members>,
f: (members: Members) => Tof: (members: Members extends ReadonlyArray<Constraint>members: function (type parameter) Members in makeUnion<Members extends ReadonlyArray<Constraint>>(ast: SchemaAST.Union<Members[number]["ast"]>, members: Members): Union<Members>Members) => function (type parameter) To in mapMembers<To extends ReadonlyArray<Constraint>>(this: Union<Members>, f: (members: Members) => To, options?: {
readonly unsafePreserveChecks?: boolean | undefined;
} | undefined): Union<Simplify<Readonly<To>>>
options: | {
readonly unsafePreserveChecks?:
| boolean
| undefined
}
| undefined
unsafePreserveChecks?: boolean | undefinedunsafePreserveChecks?: boolean | undefined
} | undefined
): interface Union<Members extends ReadonlyArray<Constraint>>Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Type-level representation returned by
Union
.
Union<type Simplify<T> = { [K in keyof T]: T[K]; }Flattens intersection types into a single object type for readability.
When to use
Use when hovering over a type shows A & B & C instead of the merged shape.
Details
This helper is purely cosmetic at the type level and has no runtime effect.
It preserves readonly modifiers; use
Mutable
to strip them.
Example (Flattening an intersection)
import type { Struct } from "effect"
type Original = { a: string } & { b: number }
// Without Simplify, the type displays as `{ a: string } & { b: number }`
type Simplified = Struct.Simplify<Original>
// { a: string; b: number }
Simplify<type Readonly<T> = {
readonly [P in keyof T]: T[P]
}
Make all properties in T readonly
Readonly<function (type parameter) To in mapMembers<To extends ReadonlyArray<Constraint>>(this: Union<Members>, f: (members: Members) => To, options?: {
readonly unsafePreserveChecks?: boolean | undefined;
} | undefined): Union<Simplify<Readonly<To>>>
const members: To extends ReadonlyArray<Constraint>members = f: (members: Members) => Tof(this.Union<Members>.members: Members extends ReadonlyArray<Constraint>members)
return function makeUnion<
Members extends ReadonlyArray<Constraint>
>(
ast: SchemaAST.Union<Members[number]["ast"]>,
members: Members
): Union<Members>
import SchemaASTSchemaAST.function union<
Members extends ReadonlyArray<{
readonly ast: AST
}>
>(
members: Members,
mode: "anyOf" | "oneOf",
checks: Checks | undefined
): Union<Members[number]["ast"]>
const members: To extends ReadonlyArray<Constraint>members, this.Bottom<unknown, unknown, unknown, unknown, Union<...>, Union<...>, unknown, unknown, readonly [], unknown, "readonly", "required", "no-default", "readonly", "required">["ast"]: SchemaAST.Union<{ [K in keyof Members]: Members[K]["ast"]; }[number]>(property) Bottom<unknown, unknown, unknown, unknown, Union<...>, Union<...>, unknown, unknown, readonly [], unknown, "readonly", "required", "no-default", "readonly", "required">["ast"]: {
_tag: 'Union';
types: ReadonlyArray<A>;
mode: "anyOf" | "oneOf";
encodingChecks: Checks | undefined;
getParser: (recur: (ast: AST) => SchemaParser.Parser) => SchemaParser.Parser;
_rebuild: (recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) => Union<AST>;
recur: (recur: (ast: AST) => AST) => Union<AST>;
flip: (recur: (ast: AST) => AST) => Union<AST>;
matchPart: (s: string, options: ParseOptions) => LiteralValue | undefined;
getExpected: (getExpected: (ast: AST) => string) => string;
annotations: Schema.Annotations.Annotations | undefined;
checks: Checks | undefined;
encoding: Encoding | undefined;
context: Context | undefined;
toString: () => string;
}
Union<A extends AST = AST>.mode: "anyOf" | "oneOf"mode, options: | {
readonly unsafePreserveChecks?:
| boolean
| undefined
}
| undefined
unsafePreserveChecks?: boolean | undefinedunsafePreserveChecks ? this.Bottom<unknown, unknown, unknown, unknown, Union<...>, Union<...>, unknown, unknown, readonly [], unknown, "readonly", "required", "no-default", "readonly", "required">["ast"]: SchemaAST.Union<{ [K in keyof Members]: Members[K]["ast"]; }[number]>(property) Bottom<unknown, unknown, unknown, unknown, Union<...>, Union<...>, unknown, unknown, readonly [], unknown, "readonly", "required", "no-default", "readonly", "required">["ast"]: {
_tag: 'Union';
types: ReadonlyArray<A>;
mode: "anyOf" | "oneOf";
encodingChecks: Checks | undefined;
getParser: (recur: (ast: AST) => SchemaParser.Parser) => SchemaParser.Parser;
_rebuild: (recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) => Union<AST>;
recur: (recur: (ast: AST) => AST) => Union<AST>;
flip: (recur: (ast: AST) => AST) => Union<AST>;
matchPart: (s: string, options: ParseOptions) => LiteralValue | undefined;
getExpected: (getExpected: (ast: AST) => string) => string;
annotations: Schema.Annotations.Annotations | undefined;
checks: Checks | undefined;
encoding: Encoding | undefined;
context: Context | undefined;
toString: () => string;
}
Base.checks: Checks | undefinedchecks : var undefinedundefined),
const members: To extends ReadonlyArray<Constraint>members
)
}
})
}
/**
* Creates a union schema from an array of member schemas. Members are tested in
* order; the first match is returned.
*
* **Details**
*
* Optionally, specify `mode`:
* - `"anyOf"` (default) — matches if any member matches.
* - `"oneOf"` — matches if exactly one member matches.
*
* **Example** (Defining a string or number union)
*
* ```ts
* import { Schema } from "effect"
*
* const schema = Schema.Union([Schema.String, Schema.Number])
*
* Schema.decodeUnknownSync(schema)("hello") // "hello"
* Schema.decodeUnknownSync(schema)(42) // 42
* ```
*
* @category constructors
* @since 3.10.0
*/
export function function Union<
Members extends ReadonlyArray<Constraint>
>(
members: Members,
options?: { mode?: "anyOf" | "oneOf" }
): Union<Members>
Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Union<const function (type parameter) Members in Union<const Members extends ReadonlyArray<Constraint>>(members: Members, options?: {
mode?: "anyOf" | "oneOf";
}): Union<Members>
interface ReadonlyArray<T>ReadonlyArray<Constraint>>(
members: const Members extends ReadonlyArray<Constraint>members: function (type parameter) Members in Union<const Members extends ReadonlyArray<Constraint>>(members: Members, options?: {
mode?: "anyOf" | "oneOf";
}): Union<Members>
options: | {
mode?: "anyOf" | "oneOf"
}
| undefined
mode?: "anyOf" | "oneOf" | undefinedmode?: "anyOf" | "oneOf" }
): interface Union<Members extends ReadonlyArray<Constraint>>Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Type-level representation returned by
Union
.
Union<function (type parameter) Members in Union<const Members extends ReadonlyArray<Constraint>>(members: Members, options?: {
mode?: "anyOf" | "oneOf";
}): Union<Members>
function makeUnion<
Members extends ReadonlyArray<Constraint>
>(
ast: SchemaAST.Union<Members[number]["ast"]>,
members: Members
): Union<Members>
import SchemaASTSchemaAST.function union<
Members extends ReadonlyArray<{
readonly ast: AST
}>
>(
members: Members,
mode: "anyOf" | "oneOf",
checks: Checks | undefined
): Union<Members[number]["ast"]>
members: const Members extends ReadonlyArray<Constraint>members, options: | {
mode?: "anyOf" | "oneOf"
}
| undefined
mode?: "anyOf" | "oneOf" | undefinedmode ?? "anyOf", var undefinedundefined), members: const Members extends ReadonlyArray<Constraint>members)
}Referenced by 36 symbols
Config.ArrayConfig.RecordSchema.ArrayEnsureSchema.CauseReasonSchema.DurationSchema.ExitSchema.FormDataSchema.LiteralsSchema.NullOrSchema.NullishOrSchema.OptionSchema.PropertyKeySchema.ResultSchema.StandardSchemaV1FailureResultSchema.TaggedUnionSchema.TreeSchema.UndefinedOrSchema.toTaggedUnionSchemaRepresentation.$DateMetaSchemaRepresentation.$DeclarationMetaSchemaRepresentation.$EnumSchemaRepresentation.$LiteralValueSchemaRepresentation.$NumberMetaSchemaRepresentation.$ObjectsMetaSchemaRepresentation.$PrimitiveTreeSchemaRepresentation.$RepresentationSchemaRepresentation.$SizeMetaSchemaRepresentation.$StringMetaSchemaRepresentation.toSchemaCustomQueueHyperlink.customQueueLevel (hyperlink-ts)CustomQueueHyperlink.customQueueSpec (hyperlink-ts)FleetHealth.nodeReport (hyperlink-ts)QueueHyperlink.jsonValue (hyperlink-ts)QueueHyperlink.queueReleaseEncodingError (hyperlink-ts)QueueHyperlink.queueSpec (hyperlink-ts)Telemetry.metricDatum (hyperlink-ts)