OptionFromOptional<S>Decodes an optional or undefined value A to a required Option<A>
value.
Details
Decoding maps a missing key or a present undefined value to None, and
maps all other values to Some. Encoding maps None to a missing key and
maps Some to its value.
export interface interface OptionFromOptional<S extends Constraint>Decodes an optional or undefined value A to a required Option<A>
value.
Details
Decoding maps a missing key or a present undefined value to None, and
maps all other values to Some. Encoding maps None to a missing key and
maps Some to its value.
Type-level representation returned by
OptionFromOptional
.
OptionFromOptional<function (type parameter) S in OptionFromOptional<S extends Constraint>S extends Constraint> extends interface decodeTo<To extends Constraint, From extends Constraint, RD = never, RE = never>Creates a schema that transforms from a source schema to a target schema.
When to use
Use when decoding should change the schema's decoded type or encoded shape,
with an optional custom bidirectional transformation.
Details
Call it with the target schema to and then pipe the source schema from
into the returned function. The resulting schema decodes from
From["Encoded"] to To["Type"] and encodes from To["Type"] back to
From["Encoded"].
When no transformation is provided, SchemaTransformation.passthrough() is
used, so From["Type"] must already be compatible with To["Encoded"].
The resulting schema combines decoding and encoding services from both
schemas and any custom transformation.
Gotchas
In a custom transformation, decode maps From["Type"] to To["Encoded"]
and is used on the encoding path, while encode maps To["Encoded"] to
From["Type"] and is used on the decoding path.
Example (Transforming strings to numbers with a schema transformation)
import { Schema, SchemaGetter } from "effect"
const NumberFromString = Schema.String.pipe(
Schema.decodeTo(
Schema.Number,
{
decode: SchemaGetter.transform((s) => Number(s)),
encode: SchemaGetter.transform((n) => String(n))
}
)
)
const result = Schema.decodeUnknownSync(NumberFromString)("123")
// result: 123
Type-level representation returned by
decodeTo
.
decodeTo<interface Option<A extends Constraint>Schema for Option<A> values.
Type-level representation returned by
Option
.
Option<interface toType<S extends Constraint>Type-level representation returned by
toType
.
Extracts the type-side schema: sets Encoded to equal the decoded Type,
discarding the encoding transformation path.
toType<function (type parameter) S in OptionFromOptional<S extends Constraint>S>>, interface optional<S extends Constraint>Type-level representation returned by
optional
.
Marks a struct field as optional, allowing the key to be absent or
undefined.
Details
The resulting property may be absent or explicitly set to undefined.
Equivalent to optionalKey(UndefinedOr(S)).
Use
optionalKey
instead if you want exact optional semantics (absent
only, not undefined).
Example (Defining an optional field accepting undefined)
import { Schema } from "effect"
const schema = Schema.Struct({
name: Schema.String,
age: Schema.optional(Schema.Number)
})
// { readonly name: string; readonly age?: number | undefined }
type Person = typeof schema.Type
optional<function (type parameter) S in OptionFromOptional<S extends Constraint>S>> {
readonly "Rebuild": interface OptionFromOptional<S extends Constraint>Decodes an optional or undefined value A to a required Option<A>
value.
Details
Decoding maps a missing key or a present undefined value to None, and
maps all other values to Some. Encoding maps None to a missing key and
maps Some to its value.
Type-level representation returned by
OptionFromOptional
.
OptionFromOptional<function (type parameter) S in OptionFromOptional<S extends Constraint>S>
}
/**
* Decodes an optional or `undefined` value `A` to a required `Option<A>`
* value.
*
* **Details**
*
* Decoding maps a missing key or a present `undefined` value to `None`, and
* maps all other values to `Some`. Encoding maps `None` to a missing key and
* maps `Some` to its value.
*
* @category Option
* @since 4.0.0
*/
export function function OptionFromOptional<
S extends Constraint
>(schema: S): OptionFromOptional<S>
Decodes an optional or undefined value A to a required Option<A>
value.
Details
Decoding maps a missing key or a present undefined value to None, and
maps all other values to Some. Encoding maps None to a missing key and
maps Some to its value.
OptionFromOptional<function (type parameter) S in OptionFromOptional<S extends Constraint>(schema: S): OptionFromOptional<S>S extends Constraint>(schema: S extends Constraintschema: function (type parameter) S in OptionFromOptional<S extends Constraint>(schema: S): OptionFromOptional<S>S): interface OptionFromOptional<S extends Constraint>Decodes an optional or undefined value A to a required Option<A>
value.
Details
Decoding maps a missing key or a present undefined value to None, and
maps all other values to Some. Encoding maps None to a missing key and
maps Some to its value.
Type-level representation returned by
OptionFromOptional
.
OptionFromOptional<function (type parameter) S in OptionFromOptional<S extends Constraint>(schema: S): OptionFromOptional<S>S> {
return const optional: optionalLambda
;<S>(self: S) => optional<S>
Type-level representation returned by
optional
.
Marks a struct field as optional, allowing the key to be absent or
undefined.
Details
The resulting property may be absent or explicitly set to undefined.
Equivalent to optionalKey(UndefinedOr(S)).
Use
optionalKey
instead if you want exact optional semantics (absent
only, not undefined).
Example (Defining an optional field accepting undefined)
import { Schema } from "effect"
const schema = Schema.Struct({
name: Schema.String,
age: Schema.optional(Schema.Number)
})
// { readonly name: string; readonly age?: number | undefined }
type Person = typeof schema.Type
optional(schema: S extends Constraintschema).pipe(function decodeTo<Option<toType<S>>, Constraint, never, never>(to: Option<toType<S>>, transformation: {
readonly decode: SchemaGetter.Getter<Option_.Option<A["Encoded"]>, unknown, never>;
readonly encode: SchemaGetter.Getter<unknown, Option_.Option<A["Encoded"]>, never>;
}): (from: Constraint) => decodeTo<Option<toType<S>>, Constraint, never, never> (+1 overload)
Creates a schema that transforms from a source schema to a target schema.
When to use
Use when decoding should change the schema's decoded type or encoded shape,
with an optional custom bidirectional transformation.
Details
Call it with the target schema to and then pipe the source schema from
into the returned function. The resulting schema decodes from
From["Encoded"] to To["Type"] and encodes from To["Type"] back to
From["Encoded"].
When no transformation is provided, SchemaTransformation.passthrough() is
used, so From["Type"] must already be compatible with To["Encoded"].
The resulting schema combines decoding and encoding services from both
schemas and any custom transformation.
Gotchas
In a custom transformation, decode maps From["Type"] to To["Encoded"]
and is used on the encoding path, while encode maps To["Encoded"] to
From["Type"] and is used on the decoding path.
Example (Transforming strings to numbers with a schema transformation)
import { Schema, SchemaGetter } from "effect"
const NumberFromString = Schema.String.pipe(
Schema.decodeTo(
Schema.Number,
{
decode: SchemaGetter.transform((s) => Number(s)),
encode: SchemaGetter.transform((n) => String(n))
}
)
)
const result = Schema.decodeUnknownSync(NumberFromString)("123")
// result: 123
decodeTo(
function Option<A extends Constraint>(
value: A
): Option<A>
Schema for Option<A> values.
Option(const toType: toTypeLambda
;<S>(self: S) => toType<S>
Type-level representation returned by
toType
.
Extracts the type-side schema: sets Encoded to equal the decoded Type,
discarding the encoding transformation path.
toType(schema: S extends Constraintschema)),
import SchemaTransformationSchemaTransformation.function optionFromOptional<
T
>(): Transformation<
Option.Option<T>,
T | undefined
>
Decodes optional values into Option<T> and encodes Option.none() back to
an omitted optional value.
When to use
Use when you need a schema transformation to convert optional (possibly
undefined) values to Option.
Details
Decoding maps an absent or undefined value to Some(None) and a present
value to Some(Some(v)). Encoding maps Some(None) to None to omit the
value, and maps Some(Some(v)) to Some(v). This uses
transformOptional under the hood and filters out undefined on decode.
Example (Converting an optional value to an Option)
import { Schema, SchemaTransformation } from "effect"
const schema = Schema.Struct({
age: Schema.optional(Schema.Number).pipe(
Schema.decodeTo(
Schema.Option(Schema.Number),
SchemaTransformation.optionFromOptional()
)
)
})
optionFromOptional<any>()
))
}