<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(
success: Su,
head: H,
tail: T
): Method<
Schema.Tuple<readonly [H, T]>,
Su,
Schema.Never,
false,
PairMethodAnnotations
>
<
Su extends Schema.Top,
P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>
>(
success: Su,
payload: P
): Method<P, Su, Schema.Never, false, PairMethodAnnotations>Like effectFn, but the payload must be a 2-tuple schema surfaced as two call
arguments (first, second?) — used by custom-queue add(item, level?).
spec fieldseffectFn
Source src/Hyperlink.ts:151431 lines
export function function mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations> (+1 overload)Like
effectFn
, but the payload must be a 2-tuple schema surfaced as two call
arguments (first, second?) — used by custom-queue add(item, level?).
mutatePair<
function (type parameter) Su in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>Su extends import SchemaSchema.Top,
function (type parameter) H in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>H extends import SchemaSchema.Top,
function (type parameter) T in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>T extends import SchemaSchema.Top,
>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>Su,
head: H extends Schema.Tophead: function (type parameter) H in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>H,
tail: T extends Schema.Toptail: function (type parameter) T in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>T,
): interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<import SchemaSchema.interface Tuple<Elements extends Schema.Tuple.Elements>Defines a fixed-length tuple schema from an array of element schemas.
Example (Defining a pair of string and number)
import { Schema } from "effect"
const schema = Schema.Tuple([Schema.String, Schema.Number])
const pair = Schema.decodeUnknownSync(schema)(["hello", 42])
console.log(pair)
// [ 'hello', 42 ]
Namespace for Tuple type utilities.
Details
Tuple.Elements — constraint for the element schema arrayTuple.Type<E> — decoded tuple typeTuple.Encoded<E> — encoded tuple typeTuple.MakeIn<E> — constructor input tuple
Type-level representation returned by
Tuple
.
Tuple<readonly [function (type parameter) H in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>H, function (type parameter) T in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>T]>, function (type parameter) Su in mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations>Su, import SchemaSchema.Never, false, type PairMethodAnnotations =
MethodAnnotations & {
readonly callStyle: "pair"
}
function mutatePair<Su extends Schema.Top, P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>>(success: Su, payload: P): Method<P, Su, Schema.Never, false, PairMethodAnnotations> (+1 overload)Like
effectFn
, but the payload must be a 2-tuple schema surfaced as two call
arguments (first, second?) — used by custom-queue add(item, level?).
mutatePair<function (type parameter) Su in mutatePair<Su extends Schema.Top, P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>>(success: Su, payload: P): Method<P, Su, Schema.Never, false, PairMethodAnnotations>Su extends import SchemaSchema.Top, function (type parameter) P in mutatePair<Su extends Schema.Top, P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>>(success: Su, payload: P): Method<P, Su, Schema.Never, false, PairMethodAnnotations>P extends import SchemaSchema.interface Tuple<Elements extends Schema.Tuple.Elements>Defines a fixed-length tuple schema from an array of element schemas.
Example (Defining a pair of string and number)
import { Schema } from "effect"
const schema = Schema.Tuple([Schema.String, Schema.Number])
const pair = Schema.decodeUnknownSync(schema)(["hello", 42])
console.log(pair)
// [ 'hello', 42 ]
Namespace for Tuple type utilities.
Details
Tuple.Elements — constraint for the element schema arrayTuple.Type<E> — decoded tuple typeTuple.Encoded<E> — encoded tuple typeTuple.MakeIn<E> — constructor input tuple
Type-level representation returned by
Tuple
.
Tuple<readonly [import SchemaSchema.Top, import SchemaSchema.Top]>>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in mutatePair<Su extends Schema.Top, P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>>(success: Su, payload: P): Method<P, Su, Schema.Never, false, PairMethodAnnotations>Su,
payload: P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>payload: function (type parameter) P in mutatePair<Su extends Schema.Top, P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>>(success: Su, payload: P): Method<P, Su, Schema.Never, false, PairMethodAnnotations>P,
): interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<function (type parameter) P in mutatePair<Su extends Schema.Top, P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>>(success: Su, payload: P): Method<P, Su, Schema.Never, false, PairMethodAnnotations>P, function (type parameter) Su in mutatePair<Su extends Schema.Top, P extends Schema.Tuple<readonly [Schema.Top, Schema.Top]>>(success: Su, payload: P): Method<P, Su, Schema.Never, false, PairMethodAnnotations>Su, import SchemaSchema.Never, false, type PairMethodAnnotations =
MethodAnnotations & {
readonly callStyle: "pair"
}
function mutatePair<Su extends Schema.Top, H extends Schema.Top, T extends Schema.Top>(success: Su, head: H, tail: T): Method<Schema.Tuple<readonly [H, T]>, Su, Schema.Never, false, PairMethodAnnotations> (+1 overload)Like
effectFn
, but the payload must be a 2-tuple schema surfaced as two call
arguments (first, second?) — used by custom-queue add(item, level?).
mutatePair(
success: Schema.Top(parameter) success: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
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; <…;
}
import SchemaSchema.Top,
headOrPayload: Schema.Top(parameter) headOrPayload: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
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; <…;
}
import SchemaSchema.Top,
tail: Schema.Top | undefinedtail?: import SchemaSchema.Top,
): interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<import SchemaSchema.interface Tuple<Elements extends Schema.Tuple.Elements>Defines a fixed-length tuple schema from an array of element schemas.
Example (Defining a pair of string and number)
import { Schema } from "effect"
const schema = Schema.Tuple([Schema.String, Schema.Number])
const pair = Schema.decodeUnknownSync(schema)(["hello", 42])
console.log(pair)
// [ 'hello', 42 ]
Namespace for Tuple type utilities.
Details
Tuple.Elements — constraint for the element schema arrayTuple.Type<E> — decoded tuple typeTuple.Encoded<E> — encoded tuple typeTuple.MakeIn<E> — constructor input tuple
Type-level representation returned by
Tuple
.
Tuple<readonly [import SchemaSchema.Top, import SchemaSchema.Top]>, import SchemaSchema.Top, import SchemaSchema.Never, false, type PairMethodAnnotations =
MethodAnnotations & {
readonly callStyle: "pair"
}
const payload:
| Schema.Top
| Schema.Tuple<
readonly [Schema.Top, Schema.Top]
>
tail: Schema.Top | undefinedtail === var undefinedundefined
? headOrPayload: Schema.Top(parameter) headOrPayload: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
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; <…;
}
import SchemaSchema.function Tuple<readonly [Schema.Top, Schema.Top]>(elements: readonly [Schema.Top, Schema.Top]): Schema.Tuple<readonly [Schema.Top, Schema.Top]>Defines a fixed-length tuple schema from an array of element schemas.
Example (Defining a pair of string and number)
import { Schema } from "effect"
const schema = Schema.Tuple([Schema.String, Schema.Number])
const pair = Schema.decodeUnknownSync(schema)(["hello", 42])
console.log(pair)
// [ 'hello', 42 ]
Tuple([headOrPayload: Schema.Top(parameter) headOrPayload: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
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; <…;
}
tail: Schema.Top(parameter) tail: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
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; <…;
}
const makeMethod: <
P extends
| Schema.Struct.Fields
| Schema.Top
| undefined,
Su extends Schema.Top,
E extends Schema.Top,
Str extends boolean,
Ann extends MethodAnnotations = MethodAnnotations,
Client = Derive
>(
kind: MethodKind,
payload: P,
success: Su,
error: E,
stream: Str,
annotations: Ann
) => Method<P, Su, E, Str, Ann, Client>
The single
Method
constructor —
effect
,
effectFn
,
constant
,
value
, and
stream
all go through it.
makeMethod(
"mutate",
const payload:
| Schema.Top
| Schema.Tuple<
readonly [Schema.Top, Schema.Top]
>
import SchemaSchema.interface Tuple<Elements extends Schema.Tuple.Elements>Defines a fixed-length tuple schema from an array of element schemas.
Example (Defining a pair of string and number)
import { Schema } from "effect"
const schema = Schema.Tuple([Schema.String, Schema.Number])
const pair = Schema.decodeUnknownSync(schema)(["hello", 42])
console.log(pair)
// [ 'hello', 42 ]
Namespace for Tuple type utilities.
Details
Tuple.Elements — constraint for the element schema arrayTuple.Type<E> — decoded tuple typeTuple.Encoded<E> — encoded tuple typeTuple.MakeIn<E> — constructor input tuple
Type-level representation returned by
Tuple
.
Tuple<readonly [import SchemaSchema.Top, import SchemaSchema.Top]>,
success: Schema.Top(parameter) success: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
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; <…;
}
import SchemaSchema.const Never: Schema.Neverconst Never: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<never, readonly []>) => Schema.Never;
annotateKey: (annotations: Schema.Annotations.Key<never>) => Schema.Never;
check: (checks_0: Check<never>, ...checks: Array<Check<never>>) => Schema.Never;
rebuild: (ast: Never) => Schema.Never;
make: (input: never, options?: Schema.MakeOptions) => never;
makeOption: (input: never, options?: Schema.MakeOptions) => Option.Option<never>;
makeEffect: (input: never, options?: Schema.MakeOptions) => Effect.Effect<never, Schema.SchemaError, never>;
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; <…;
}
Type-level representation of
Never
.
Schema for the never type. Always fails validation — no value satisfies it.
Never,
false,
{ callStyle: "pair"callStyle: "pair" },
);
}
Referenced by 1 symbols