<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()
)
)
})export function 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<function (type parameter) T in optionFromOptional<T>(): Transformation<Option.Option<T>, T | undefined>T>(): class Transformation<in out T, in out E, RD = never, RE = never>class Transformation {
_tag: 'Transformation';
decode: SchemaGetter.Getter<T, E, RD>;
encode: SchemaGetter.Getter<E, T, RE>;
flip: () => Transformation<E, T, RE, RD>;
compose: <T2, RD2, RE2>(other: Transformation<T2, T, RD2, RE2>) => Transformation<T2, E, RD | RD2, RE | RE2>;
}
Represents a bidirectional transformation between a decoded type T and an encoded
type E, built from a pair of Getters.
When to use
Use when you need a schema transformation that defines how a schema converts
between two representations.
- You want to compose multiple transformations into a pipeline.
- You want to flip a transformation to swap decode/encode.
Details
This is the primary building block for Schema.decodeTo, Schema.encodeTo,
Schema.decode, Schema.encode, and Schema.link. Each direction is a
SchemaGetter.Getter that handles optionality, failure, and Effect services.
- Immutable —
flip() and compose() return new instances.
flip() swaps the decode and encode getters.compose(other) chains: this.decode then other.decode for decoding,
other.encode then this.encode for encoding.
Example (Composing two transformations)
import { SchemaTransformation } from "effect"
const trimAndLower = SchemaTransformation.trim().compose(
SchemaTransformation.toLowerCase()
)
// decode: trim then lowercase
// encode: passthrough (both directions)
Transformation<import OptionOption.type Option.Option = /*unresolved*/ anyOption<function (type parameter) T in optionFromOptional<T>(): Transformation<Option.Option<T>, T | undefined>T>, function (type parameter) T in optionFromOptional<T>(): Transformation<Option.Option<T>, T | undefined>T | undefined> {
return function transformOptional<
T,
E
>(options: {
readonly decode: (
input: Option.Option<E>
) => Option.Option<T>
readonly encode: (
input: Option.Option<T>
) => Option.Option<E>
}): Transformation<T, E>
Creates a Transformation where decode and encode operate on Option
values, giving full control over missing-key handling.
When to use
Use when you need a schema transformation to produce or consume Option.None
for absent keys.
- You are working with optional struct fields.
Details
- Each function receives
Option<input> and returns Option<output>.
Option.None input means the key is absent; returning Option.None
omits the key from the output.- Pure and synchronous.
Example (Converting an optional key to Option)
import { Option, Schema, SchemaTransformation } from "effect"
const schema = Schema.Struct({
a: Schema.optionalKey(Schema.Number).pipe(
Schema.decodeTo(
Schema.Option(Schema.Number),
SchemaTransformation.transformOptional({
decode: Option.some,
encode: Option.flatten
})
)
)
})
transformOptional<import OptionOption.type Option.Option = /*unresolved*/ anyOption<function (type parameter) T in optionFromOptional<T>(): Transformation<Option.Option<T>, T | undefined>T>, function (type parameter) T in optionFromOptional<T>(): Transformation<Option.Option<T>, T | undefined>T | undefined>({
decode: (
input: Option.Option<T | undefined>
) => Option.Option<Option.Option<T>>
ot: Option.Option<T | undefined>ot) => ot: Option.Option<T | undefined>ot.pipe(import OptionOption.filter(import PredicatePredicate.isNotUndefined), import OptionOption.some),
encode: <A>(
self: Option<Option<A>>
) => Option<A>
import OptionOption.flatten
})
}