<T>(options: {
readonly order: Order.Order<T>
readonly annotate?:
| ((exclusiveMaximum: T) => Annotations.Filter)
| undefined
readonly formatter?: Formatter<T> | undefined
}): (
exclusiveMaximum: T,
annotations?: Annotations.Filter
) => SchemaAST.Filter<T>Creates a less-than (<) check for any ordered type from an Order.Order
instance.
export function function makeIsLessThan<T>(options: {
readonly order: Order.Order<T>
readonly annotate?:
| ((
exclusiveMaximum: T
) => Annotations.Filter)
| undefined
readonly formatter?: Formatter<T> | undefined
}): (
exclusiveMaximum: T,
annotations?: Annotations.Filter
) => SchemaAST.Filter<T>
Creates a less-than (<) check for any ordered type from an Order.Order
instance.
makeIsLessThan<function (type parameter) T in makeIsLessThan<T>(options: {
readonly order: Order.Order<T>;
readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<...>
options: {
readonly order: Order.Order<T>
readonly annotate?:
| ((
exclusiveMaximum: T
) => Annotations.Filter)
| undefined
readonly formatter?: Formatter<T> | undefined
}
order: Order.Order<T>order: import OrderOrder.interface Order<in A>Represents a total ordering for values of type A.
When to use
Use when you need to define how values of a type are compared.
Details
An order returns -1 when the first value is less than the second, 0 when
the values are equal according to this ordering, and 1 when the first value
is greater than the second. It must satisfy total ordering laws: totality,
antisymmetry, and transitivity.
Example (Defining a custom Order)
import { Order } from "effect"
const byAge: Order.Order<{ name: string; age: number }> = (self, that) => {
if (self.age < that.age) return -1
if (self.age > that.age) return 1
return 0
}
const person1 = { name: "Alice", age: 30 }
const person2 = { name: "Bob", age: 25 }
console.log(byAge(person1, person2)) // 1
Order<function (type parameter) T in makeIsLessThan<T>(options: {
readonly order: Order.Order<T>;
readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<...>
annotate?: | ((exclusiveMaximum: T) => Annotations.Filter)
| undefined
exclusiveMaximum: TexclusiveMaximum: function (type parameter) T in makeIsLessThan<T>(options: {
readonly order: Order.Order<T>;
readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<...>
interface Annotations.FilterAnnotations for filter schema nodes (created via Schema.filter). Extends
Augment
with an optional error message, identifier, and metadata.
Filters are intentionally non-parametric to keep them covariant.
Filter) | undefined
readonly formatter?: Formatter<T> | undefinedformatter?: interface Formatter<in Value, out Format = string>A callable interface representing a function that converts a Value into a Format, which defaults to string.
When to use
Use when you want to type a formatting or rendering function generically, or when you are building a pipeline that accepts pluggable formatters.
Details
This is a pure callable type and carries no runtime implementation. It is contravariant in Value and covariant in Format.
Example (Defining a custom formatter)
import type { Formatter } from "effect"
const upper: Formatter.Formatter<string> = (s) => s.toUpperCase()
console.log(upper("hello"))
// HELLO
Formatter<function (type parameter) T in makeIsLessThan<T>(options: {
readonly order: Order.Order<T>;
readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<...>
const lt: {
(that: T): (self: T) => boolean
(self: T, that: T): boolean
}
import OrderOrder.const isLessThan: <A>(O: Order<A>) => {
(that: A): (self: A) => boolean
(self: A, that: A): boolean
}
Checks whether one value is strictly less than another according to the given order.
When to use
Use when you need a boolean less-than predicate using an Order.
Details
Returns true if the order returns -1, meaning the first value is less
than the second. Equal or greater values return false.
Example (Checking less-than comparisons)
import { Order } from "effect"
const isLessThanNumber = Order.isLessThan(Order.Number)
console.log(isLessThanNumber(1, 2)) // true
console.log(isLessThanNumber(2, 1)) // false
console.log(isLessThanNumber(1, 1)) // false
isLessThan(options: {
readonly order: Order.Order<T>
readonly annotate?:
| ((
exclusiveMaximum: T
) => Annotations.Filter)
| undefined
readonly formatter?: Formatter<T> | undefined
}
order: Order.Order<T>order)
const const formatter:
| ((
input: unknown,
options?: {
readonly space?:
| number
| string
| undefined
readonly ignoreToString?:
| boolean
| undefined
}
) => string)
| Formatter<T, string>
options: {
readonly order: Order.Order<T>
readonly annotate?:
| ((
exclusiveMaximum: T
) => Annotations.Filter)
| undefined
readonly formatter?: Formatter<T> | undefined
}
formatter?: Formatter<T> | undefinedformatter ?? function format(input: unknown, options?: {
readonly space?: number | string | undefined;
readonly ignoreToString?: boolean | undefined;
}): string
Converts any JavaScript value into a human-readable string.
When to use
Use when you need to format arbitrary JavaScript values for debugging,
logging, or error messages.
Details
- Output is not valid JSON; use
formatJson
when you need
parseable JSON.
- Handles
BigInt, Symbol, Set, Map, Date, RegExp, and class
instances that JSON.stringify cannot represent.
- Circular references are shown as
"[Circular]" instead of throwing.
- Primitives: stringified naturally (
null, undefined, 123, true).
Strings are JSON-quoted.
- Objects with a custom
toString (not Object.prototype.toString):
toString() is called unless ignoreToString is true.
- Errors with a
cause: formatted as "<message> (cause: <cause>)".
- Iterables (
Set, Map, etc.): formatted as
ClassName([...elements]).
- Class instances: wrapped as
ClassName({...}).
Redactable values are automatically redacted.- Arrays/objects with 0–1 entries are inline; larger ones are
pretty-printed when
space is set.
space — indentation unit (number of spaces, or a string like
"\t"). Defaults to 0 (compact).ignoreToString — skip calling toString(). Defaults to false.
Example (Formatting compact output)
import { Formatter } from "effect"
console.log(Formatter.format({ a: 1, b: [2, 3] }))
// {"a":1,"b":[2,3]}
Example (Pretty-printed output)
import { Formatter } from "effect"
console.log(Formatter.format({ a: 1, b: [2, 3] }, { space: 2 }))
// {
// "a": 1,
// "b": [
// 2,
// 3
// ]
// }
Example (Handling circular references)
import { Formatter } from "effect"
const obj: any = { name: "loop" }
obj.self = obj
console.log(Formatter.format(obj))
// {"name":"loop","self":[Circular]}
format
return (exclusiveMaximum: TexclusiveMaximum: function (type parameter) T in makeIsLessThan<T>(options: {
readonly order: Order.Order<T>;
readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<...>
annotations: Annotations.Filter | undefinedannotations?: Annotations.interface Annotations.FilterAnnotations for filter schema nodes (created via Schema.filter). Extends
Augment
with an optional error message, identifier, and metadata.
Filters are intentionally non-parametric to keep them covariant.
Filter) => {
return const makeFilter: <T>(
filter: (
input: T,
ast: SchemaAST.AST,
options: SchemaAST.ParseOptions
) => FilterOutput,
annotations?: Annotations.Filter | undefined,
abort?: boolean
) => SchemaAST.Filter<T>
Creates a custom validation filter from a predicate function.
Details
The predicate receives the decoded input value, the schema AST, and parse
options, and returns a FilterOutput. Non-success outputs are normalized into
schema issues. The annotations parameter annotates the filter itself; with
the default formatter, failures use message first, expected second, and
<filter> when neither is provided.
When abort is true, parsing stops after this filter fails instead of
collecting later check failures.
Example (Reporting failure at a nested path)
import { Schema } from "effect"
const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(
Schema.makeFilter((o) =>
o.password === o.confirmPassword
? undefined
: { path: ["password"], issue: "password and confirmPassword must match" }
)
)
console.log(String(Schema.decodeUnknownExit(schema)({ password: "123456", confirmPassword: "1234567" })))
// Failure(Cause([Fail(SchemaError: password and confirmPassword must match
// at ["password"])]))
Example (Reporting multiple failures at once)
import { Schema } from "effect"
const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(
Schema.makeFilter((o) => {
const issues: Array<Schema.FilterIssue> = []
if (o.a > 0) {
if (o.b <= 0) issues.push({ path: ["b"], issue: "b must be greater than 0" })
if (o.c <= 0) issues.push({ path: ["c"], issue: "c must be greater than 0" })
}
return issues
})
)
console.log(String(Schema.decodeUnknownExit(schema)({ a: 1, b: 0, c: 0 })))
// Failure(Cause([Fail(SchemaError: b must be greater than 0
// at ["b"]
// c must be greater than 0
// at ["c"])]))
makeFilter<function (type parameter) T in makeIsLessThan<T>(options: {
readonly order: Order.Order<T>;
readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<...>
input: Tinput) => const lt: (self: T, that: T) => boolean (+1 overload)lt(input: Tinput, exclusiveMaximum: TexclusiveMaximum),
{
Annotations.Augment.expected?: string | undefinedHuman-readable description of what a value is expected to satisfy.
Details
For filter and refinement failures, the default formatter uses
message first, then expected, and finally falls back to <filter>.
Use this to name a failed filter in the default message:
Expected <expected>, got <actual>.
expected: `a value less than ${const formatter: (value: T) => stringformatter(exclusiveMaximum: TexclusiveMaximum)}`,
Annotations.Filter.arbitrary?: Annotations.ToArbitrary.Filter | undefined(property) Annotations.Filter.arbitrary?: {
constraint: { ordered: { order: Order.Order<T>; maximum: T; exclusiveMaximum: true } };
}
Optional hints used by arbitrary derivation for this filter.
Details
The same annotation can be attached to a single filter or a
FilterGroup. Group hints apply to the same schema node while child
filters are still collected and checked normally.
arbitrary: {
Annotations.ToArbitrary.Filter.constraint?: Annotations.ToArbitrary.GenerationConstraint | undefined(property) Annotations.ToArbitrary.Filter.constraint?: {
ordered: { order: Order.Order<T>; maximum: T; exclusiveMaximum: true };
}
Annotations.ToArbitrary.GenerationConstraint.ordered?: Annotations.ToArbitrary.OrderedConstraint<any> | undefined(property) Annotations.ToArbitrary.GenerationConstraint.ordered?: {
order: Order.Order<T>;
maximum: T;
exclusiveMaximum: true;
}
Annotations.ToArbitrary.OrderedConstraint<any>.order: Order.Order<T>order: options: {
readonly order: Order.Order<T>
readonly annotate?:
| ((
exclusiveMaximum: T
) => Annotations.Filter)
| undefined
readonly formatter?: Formatter<T> | undefined
}
order: Order.Order<T>order,
Annotations.ToArbitrary.OrderedConstraint<any>.maximum?: anymaximum: exclusiveMaximum: TexclusiveMaximum,
Annotations.ToArbitrary.OrderedConstraint<any>.exclusiveMaximum?: boolean | undefinedexclusiveMaximum: true
}
}
},
...options: {
readonly order: Order.Order<T>
readonly annotate?:
| ((
exclusiveMaximum: T
) => Annotations.Filter)
| undefined
readonly formatter?: Formatter<T> | undefined
}
annotate?: | ((exclusiveMaximum: T) => Annotations.Filter)
| undefined
exclusiveMaximum: TexclusiveMaximum),
...annotations: Annotations.Filter | undefinedannotations
}
)
}
}