<S extends ConstraintEncoder<unknown>>(
schema: S,
options?: SchemaAST.ParseOptions
): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"]Encodes an unknown input against a schema synchronously, throwing a
SchemaError for schema mismatches.
When to use
Use when you need to serialize unknown data at a synchronous boundary and
want schema mismatches to throw SchemaError.
Details
For alternatives that do not throw on schema mismatches, see
encodeUnknownOption, encodeUnknownExit, or
encodeUnknownEffect. For values already typed as the schema's Type
use encodeSync. Options may be provided either when creating the
encoder or when applying it; application options override creation options.
Gotchas
Non-schema failures may throw a runtime failure instead of SchemaError.
export function function encodeUnknownSync<
S extends ConstraintEncoder<unknown>
>(
schema: S,
options?: SchemaAST.ParseOptions
): (
input: unknown,
options?: SchemaAST.ParseOptions
) => S["Encoded"]
Encodes an unknown input against a schema synchronously, throwing a
SchemaError
for schema mismatches.
When to use
Use when you need to serialize unknown data at a synchronous boundary and
want schema mismatches to throw SchemaError.
Details
For alternatives that do not throw on schema mismatches, see
encodeUnknownOption
,
encodeUnknownExit
, or
encodeUnknownEffect
. For values already typed as the schema's Type
use
encodeSync
. Options may be provided either when creating the
encoder or when applying it; application options override creation options.
Gotchas
Non-schema failures may throw a runtime failure instead of SchemaError.
encodeUnknownSync<function (type parameter) S in encodeUnknownSync<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"]S extends interface ConstraintEncoder<out E, out RE = never>Lightweight structural constraint for APIs that need encoder type views but
do not need the full schema protocol.
When to use
Use when you need to preserve a schema's encoded type and encoding services,
but the API does not constrain the decoded type, decoding services, or call
schema methods such as annotate, check, rebuild, make, or
makeEffect.
ConstraintEncoder<unknown>>(schema: S extends ConstraintEncoder<unknown>schema: function (type parameter) S in encodeUnknownSync<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"]S, options: SchemaAST.ParseOptionsoptions?: import SchemaASTSchemaAST.ParseOptions) {
const const parser: (
input: unknown,
options?: SchemaAST.ParseOptions
) => Effect.Effect<
S["Encoded"],
SchemaError,
S["EncodingServices"]
>
parser = function encodeUnknownEffect<
S extends Constraint
>(
schema: S,
options?: SchemaAST.ParseOptions
): (
input: unknown,
options?: SchemaAST.ParseOptions
) => Effect.Effect<
S["Encoded"],
SchemaError,
S["EncodingServices"]
>
Encodes an unknown input against a schema, returning an Effect that
succeeds with the encoded value or fails with a
SchemaError
.
When to use
Use when you need to encode unknown input in an Effect whose failure
channel is SchemaError.
Details
Prefer
encodeEffect
when the value is already typed as the schema's
Type.
Options may be provided either when creating the encoder or when applying it;
application options override creation options.
Example (Encoding a value to a string)
import { Effect, Schema } from "effect"
const NumberFromString = Schema.NumberFromString
Effect.runPromise(Schema.encodeUnknownEffect(NumberFromString)(42)).then(console.log)
// Output: "42"
encodeUnknownEffect(schema: S extends ConstraintEncoder<unknown>schema, options: SchemaAST.ParseOptionsoptions)
return (input: unknowninput: unknown, options: SchemaAST.ParseOptionsoptions?: import SchemaASTSchemaAST.ParseOptions): function (type parameter) S in encodeUnknownSync<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"]S["Encoded"] => {
return function runSchemaErrorSync<A>(
self: Effect.Effect<A, SchemaError>
): A
runSchemaErrorSync(const parser: (
input: unknown,
options?: SchemaAST.ParseOptions
) => Effect.Effect<
S["Encoded"],
SchemaError,
S["EncodingServices"]
>
parser(input: unknowninput, options: SchemaAST.ParseOptionsoptions) as import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<function (type parameter) S in encodeUnknownSync<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"]S["Encoded"], class SchemaErrorclass SchemaError {
message: string;
toString: () => string;
name: string;
stack: string;
cause: unknown;
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; <…;
toJSON: () => unknown;
_tag: Tag;
issue: SchemaIssue.Issue;
}
Error thrown (or returned as the error channel value) when schema decoding
or encoding fails.
Details
The issue field contains a structured
Issue
tree describing
every validation failure, including the path to the problematic value,
expected types, and actual values received. message renders the issue tree
as a human-readable string.
Use
isSchemaError
to narrow an unknown value to SchemaError.
Example (Catching a SchemaError)
import { Schema } from "effect"
try {
Schema.decodeUnknownSync(Schema.Number)("not a number")
} catch (err) {
if (Schema.isSchemaError(err)) {
console.log(err.message)
// Expected number, actual "not a number"
}
}
SchemaError>)
}
}