OptionFromOptionalKey<S>Decodes an optional value A to a required Option<A> value.
Details
Decoding maps a missing key to None and a present value to Some.
Encoding maps None to a missing key and maps Some to its value.
export interface interface OptionFromOptionalKey<S extends Constraint>Decodes an optional value A to a required Option<A> value.
Details
Decoding maps a missing key to None and a present value to Some.
Encoding maps None to a missing key and maps Some to its value.
Type-level representation returned by
OptionFromOptionalKey
.
OptionFromOptionalKey<function (type parameter) S in OptionFromOptionalKey<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 OptionFromOptionalKey<S extends Constraint>S>>, interface optionalKey<S extends Constraint>Type-level representation returned by
optionalKey
.
Creates an exact optional key schema for struct fields. Unlike optional,
this creates exact optional properties (not | undefined) that can be
completely omitted from the object.
Example (Creating a struct with optional key)
import { Schema } from "effect"
const schema = Schema.Struct({
name: Schema.String,
age: Schema.optionalKey(Schema.Number)
})
// Type: { readonly name: string; readonly age?: number }
type Person = typeof schema["Type"]
optionalKey<function (type parameter) S in OptionFromOptionalKey<S extends Constraint>S>> {
readonly "Rebuild": interface OptionFromOptionalKey<S extends Constraint>Decodes an optional value A to a required Option<A> value.
Details
Decoding maps a missing key to None and a present value to Some.
Encoding maps None to a missing key and maps Some to its value.
Type-level representation returned by
OptionFromOptionalKey
.
OptionFromOptionalKey<function (type parameter) S in OptionFromOptionalKey<S extends Constraint>S>
}
/**
* Decodes an optional value `A` to a required `Option<A>` value.
*
* **Details**
*
* Decoding maps a missing key to `None` and a present value to `Some`.
* Encoding maps `None` to a missing key and maps `Some` to its value.
*
* @category Option
* @since 4.0.0
*/
export function function OptionFromOptionalKey<
S extends Constraint
>(schema: S): OptionFromOptionalKey<S>
Decodes an optional value A to a required Option<A> value.
Details
Decoding maps a missing key to None and a present value to Some.
Encoding maps None to a missing key and maps Some to its value.
OptionFromOptionalKey<function (type parameter) S in OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFromOptionalKey<S>S extends Constraint>(schema: S extends Constraintschema: function (type parameter) S in OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFromOptionalKey<S>S): interface OptionFromOptionalKey<S extends Constraint>Decodes an optional value A to a required Option<A> value.
Details
Decoding maps a missing key to None and a present value to Some.
Encoding maps None to a missing key and maps Some to its value.
Type-level representation returned by
OptionFromOptionalKey
.
OptionFromOptionalKey<function (type parameter) S in OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFromOptionalKey<S>S> {
return const optionalKey: optionalKeyLambda
;<S>(self: S) => optionalKey<S>
Type-level representation returned by
optionalKey
.
Creates an exact optional key schema for struct fields. Unlike optional,
this creates exact optional properties (not | undefined) that can be
completely omitted from the object.
Example (Creating a struct with optional key)
import { Schema } from "effect"
const schema = Schema.Struct({
name: Schema.String,
age: Schema.optionalKey(Schema.Number)
})
// Type: { readonly name: string; readonly age?: number }
type Person = typeof schema["Type"]
optionalKey(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 optionFromOptionalKey<
T
>(): Transformation<Option.Option<T>, T>
Decodes an optional struct key into Option<T> and encodes Option<T>
back to an optional key.
When to use
Use when you need a schema transformation to convert optional struct keys
(declared with Schema.optionalKey) to Option values.
Details
Decoding maps an absent key (None) to Some(None) and a present key
(Some(v)) to Some(Some(v)). Encoding maps Some(None) to None to omit
the key, and maps Some(Some(v)) to Some(v). This uses
transformOptional under the hood.
Example (Converting an optional key to an Option)
import { Schema, SchemaTransformation } from "effect"
const schema = Schema.Struct({
name: Schema.optionalKey(Schema.String).pipe(
Schema.decodeTo(
Schema.Option(Schema.String),
SchemaTransformation.optionFromOptionalKey()
)
)
})
optionFromOptionalKey()
))
}