<S>(self: optional<S>): SReverses optional and returns the inner schema.
When to use
Use to remove optional wrapping from a schema field that was previously wrapped with optional.
Details
This also unwraps the UndefinedOr member added by optional.
combinatorsoptional
Source effect/Schema.ts:24091 lines
export const const required: requiredLambdaReverses optional and returns the inner schema.
When to use
Use to remove optional wrapping from a schema field that was previously
wrapped with
optional
.
Details
This also unwraps the UndefinedOr member added by optional.
required = import Struct_Struct_.const lambda: <requiredLambda>(
f: (a: optional<Constraint>) => Constraint
) => requiredLambda
Wraps a plain function as a
Lambda
value so it can be used with
When to use
Use to create a typed lambda for struct mapping APIs that need type-level
input and output tracking.
Details
The type parameter L encodes both the input and output types at the type
level, allowing the compiler to track how struct value types change. At
runtime, the returned value is the same function; lambda only adjusts the
type.
Example (Wrapping values in arrays)
import { pipe, Struct } from "effect"
interface AsArray extends Struct.Lambda {
<A>(self: A): Array<A>
readonly "~lambda.out": Array<this["~lambda.in"]>
}
const asArray = Struct.lambda<AsArray>((a) => [a])
const result = pipe({ x: 1, y: "hello" }, Struct.map(asArray))
console.log(result) // { x: [1], y: ["hello"] }
lambda<requiredLambda>((self: optional<Constraint>(parameter) self: {
Rebuild: optional<S>;
Type: S["Type"];
Encoded: S["Encoded"];
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: S["Iso"];
schema: S;
ast: Ast;
annotate: (annotations: Annotations.Bottom<unknown, readonly []>) => optional<Constraint>;
annotateKey: (annotations: Annotations.Key<unknown>) => optional<Constraint>;
check: (checks_0: SchemaAST.Check<unknown>, ...checks: Array<SchemaAST.Check<unknown>>) => optional<Constraint>;
rebuild: (ast: SchemaAST.Union<SchemaAST.AST>) => optional<Constraint>;
make: (input: unknown, options?: MakeOptions) => unknown;
makeOption: (input: unknown, options?: MakeOptions) => Option_.Option<unknown>;
makeEffect: (input: unknown, options?: MakeOptions) => Effect.Effect<unknown, 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; <…;
}
self: optional<Constraint>(parameter) self: {
Rebuild: optional<S>;
Type: S["Type"];
Encoded: S["Encoded"];
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: S["Iso"];
schema: S;
ast: Ast;
annotate: (annotations: Annotations.Bottom<unknown, readonly []>) => optional<Constraint>;
annotateKey: (annotations: Annotations.Key<unknown>) => optional<Constraint>;
check: (checks_0: SchemaAST.Check<unknown>, ...checks: Array<SchemaAST.Check<unknown>>) => optional<Constraint>;
rebuild: (ast: SchemaAST.Union<SchemaAST.AST>) => optional<Constraint>;
make: (input: unknown, options?: MakeOptions) => unknown;
makeOption: (input: unknown, options?: MakeOptions) => Option_.Option<unknown>;
makeEffect: (input: unknown, options?: MakeOptions) => Effect.Effect<unknown, 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; <…;
}
optionalKey<UndefinedOr<Constraint>>.schema: UndefinedOr<Constraint>(property) optionalKey<UndefinedOr<Constraint>>.schema: {
Rebuild: UndefinedOr<S>;
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: readonly [Constraint, Undefined]) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
ast: Ast;
annotate: (annotations: Annotations.Bottom<unknown, readonly []>) => UndefinedOr<Constraint>;
annotateKey: (annotations: Annotations.Key<unknown>) => UndefinedOr<Constraint>;
check: (checks_0: SchemaAST.Check<unknown>, ...checks: Array<SchemaAST.Check<unknown>>) => UndefinedOr<Constraint>;
rebuild: (ast: SchemaAST.Union<SchemaAST.AST>) => UndefinedOr<Constraint>;
make: (input: unknown, options?: MakeOptions) => unknown;
makeOption: (input: unknown, options?: MakeOptions) => Option_.Option<unknown>;
makeEffect: (input: unknown, options?: MakeOptions) => Effect.Effect<unknown, 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; <…;
}
Union<readonly [Constraint, Undefined]>.members: readonly [Constraint, Undefined](property) Union<readonly [Constraint, Undefined]>.members: {
0: Constraint;
1: Undefined;
length: 2;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<Constraint | Undefined>>): Array<Constraint | Undefined>; (...items: Array<Constraint | Undefined | ConcatArray<Constraint | Undefined>>): Array<Constraint | Undefined> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<Constraint | Undefined>;
indexOf: (searchElement: Constraint | Undefined, fromIndex?: number) => number;
lastIndexOf: (searchElement: Constraint | Undefined, fromIndex?: number) => number;
every: { (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint | Undefined>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray…;
some: (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint | Undefined>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint | Undefined>) => void, thisArg?: any) => void;
map: (callbackfn: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint | Undefined>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint | Undefined>) => value is S, thisArg?: any): Array<S>; (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint …;
reduce: { (callbackfn: (previousValue: Constraint | Undefined, currentValue: Constraint | Undefined, currentIndex: number, array: ReadonlyArray<Constraint | Undefined>) => Constraint | Undefined): Constraint | Undefined; (callbackfn: (previousValu…;
reduceRight: { (callbackfn: (previousValue: Constraint | Undefined, currentValue: Constraint | Undefined, currentIndex: number, array: ReadonlyArray<Constraint | Undefined>) => Constraint | Undefined): Constraint | Undefined; (callbackfn: (previousValu…;
find: { (predicate: (value: Constraint | Undefined, index: number, obj: ReadonlyArray<Constraint | Undefined>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Constraint | Undefined, index: number, obj: ReadonlyArray<Constraint…;
findIndex: (predicate: (value: Constraint | Undefined, index: number, obj: ReadonlyArray<Constraint | Undefined>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, Constraint | Undefined]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<Constraint | Undefined>;
includes: (searchElement: Constraint | Undefined, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: Constraint | Undefined, index: number, array: Array<Constraint | Undefined>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => Constraint | Undefined | undefined;
findLast: { (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint | Undefined>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constr…;
findLastIndex: (predicate: (value: Constraint | Undefined, index: number, array: ReadonlyArray<Constraint | Undefined>) => unknown, thisArg?: any) => number;
toReversed: () => Array<Constraint | Undefined>;
toSorted: (compareFn?: ((a: Constraint | Undefined, b: Constraint | Undefined) => number) | undefined) => Array<Constraint | Undefined>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<Constraint | Undefined>): Array<Constraint | Undefined>; (start: number, deleteCount?: number): Array<Constraint | Undefined> };
with: (index: number, value: Constraint | Undefined) => Array<Constraint | Undefined>;
}