<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>Creates a getter that always fails with a Forbidden issue.
When to use
Use when you need a schema getter to disallow a field or direction (encode/decode) entirely.
- You want a clear "forbidden" error message in schema validation output.
Details
- Always fails with
SchemaIssue.Forbidden. - The message function receives the
Option<E>input for context.
Example (Forbidding a decode direction)
import { SchemaGetter } from "effect"
const noEncode = SchemaGetter.forbidden<string, number>(
() => "encoding is not supported"
)export function function forbidden<T, E>(
message: (oe: Option.Option<E>) => string
): Getter<T, E>
Creates a getter that always fails with a Forbidden issue.
When to use
Use when you need a schema getter to disallow a field or direction
(encode/decode) entirely.
- You want a clear "forbidden" error message in schema validation output.
Details
- Always fails with
SchemaIssue.Forbidden.
- The message function receives the
Option<E> input for context.
Example (Forbidding a decode direction)
import { SchemaGetter } from "effect"
const noEncode = SchemaGetter.forbidden<string, number>(
() => "encoding is not supported"
)
forbidden<function (type parameter) T in forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>T, function (type parameter) E in forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>E>(message: (oe: Option.Option<E>) => stringmessage: (oe: Option.Option<E>oe: import OptionOption.type Option.Option = /*unresolved*/ anyOption<function (type parameter) E in forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>E>) => string): class Getter<out T, in E, R = never>class Getter {
run: (input: Option.Option<E>, options: SchemaAST.ParseOptions) => Effect.Effect<Option.Option<T>, SchemaIssue.Issue, R>;
map: <T2>(f: (t: T) => T2) => Getter<T2, E, R>;
compose: <T2, R2>(other: Getter<T2, T, R2>) => Getter<T2, E, R | R2>;
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; <…;
}
Represents a composable transformation from an encoded type E to a decoded type T.
When to use
Use when you need a schema getter to build and compose custom transformations
for Schema.decodeTo or Schema.decode.
Details
A getter wraps a function Option<E> -> Effect<Option<T>, Issue, R>. It
receives Option.None when the encoded key is absent, such as a missing
struct field, and returns Option.None to omit the value from the decoded
output. It fails with Issue on invalid input and may require Effect
services via R. .map(f) applies f to the decoded value inside Some
while leaving None unchanged. .compose(other) chains two getters by
feeding the output of this into other; passthrough getters on either side
are optimized away.
Example (Creating and composing getters)
import { SchemaGetter } from "effect"
const parseNumber = SchemaGetter.transform<number, string>((s) => Number(s))
const double = SchemaGetter.transform<number, number>((n) => n * 2)
const composed = parseNumber.compose(double)
// composed: Getter<number, string> — parses then doubles
Getter<function (type parameter) T in forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>T, function (type parameter) E in forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>E> {
return function fail<T, E>(
f: (oe: Option.Option<E>) => SchemaIssue.Issue
): Getter<T, E>
Creates a getter that always fails with the given issue.
When to use
Use when you need a schema getter that unconditionally rejects input.
- Building custom validation getters that produce specific error types.
Details
- Always fails with the
Issue returned by f.
- The failure function receives the original
Option<E> input for error context.
Example (Defining an always-failing getter)
import { Option, SchemaGetter, SchemaIssue } from "effect"
const rejectAll = SchemaGetter.fail<string, string>(
(oe) => new SchemaIssue.InvalidValue(oe, { message: "not allowed" })
)
fail<function (type parameter) T in forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>T, function (type parameter) E in forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E>E>((oe: Option.Option<E>oe) => new import SchemaIssueSchemaIssue.constructor Forbidden(actual: Option.Option<unknown>, annotations: Schema.Annotations.Issue | undefined): SchemaIssue.ForbiddenRepresents a schema issue produced when a forbidden operation is encountered during parsing,
such as an asynchronous Effect running inside Schema.decodeUnknownSync.
When to use
Use when you need to detect that a schema requires async execution but was run
synchronously.
Details
actual is Option.some(value) when the input is known, or
Option.none() when absent.annotations optionally carries a message string.- The default formatter renders this as
"Forbidden operation".
Example (Creating a Forbidden issue)
import { Option, SchemaIssue } from "effect"
const issue = new SchemaIssue.Forbidden(
Option.none(),
{ message: "async operation not allowed in sync context" }
)
console.log(String(issue))
// "async operation not allowed in sync context"
Forbidden(oe: Option.Option<E>oe, { message: stringmessage: message: (oe: Option.Option<E>) => stringmessage(oe: Option.Option<E>oe) }))
}