new <
A extends Record<string, any>,
Success,
Error = never,
Context = never
>(
args: Types.Equals<
Omit<A, keyof Request<unknown, unknown>>,
{}
> extends true
? void
: {
readonly [P in keyof A as P extends keyof Request<any, any, any>
? never
: P]: A[P]
}
) => Request<Success, Error, Context> & Readonly<A>Defines request types with TypeScript classes.
Details
Subclasses pass their data fields to super, and instances are marked as
Request values while retaining the provided readonly fields.
Example (Defining request classes)
import { Request } from "effect"
class GetUser extends Request.Class<{ id: number }, string, Error> {
constructor(readonly id: number) {
super({ id })
}
}
const getUserRequest = new GetUser(123)
console.log(getUserRequest.id) // 123constructors
Source effect/Request.ts:36312 lines
export const const Class: new <
A extends Record<string, any>,
Success,
Error = never,
Context = never
>(
args: Types.Equals<
Omit<A, keyof Request<unknown, unknown>>,
{}
> extends true
? void
: {
readonly [P in keyof A as P extends keyof Request<
any,
any,
any
>
? never
: P]: A[P]
}
) => Request<Success, Error, Context> &
Readonly<A>
Defines request types with TypeScript classes.
Details
Subclasses pass their data fields to super, and instances are marked as
Request values while retaining the provided readonly fields.
Example (Defining request classes)
import { Request } from "effect"
class GetUser extends Request.Class<{ id: number }, string, Error> {
constructor(readonly id: number) {
super({ id })
}
}
const getUserRequest = new GetUser(123)
console.log(getUserRequest.id) // 123
Class: new<function (type parameter) A in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>A extends type Record<K extends keyof any, T> = {
[P in K]: T
}
Construct a type with a set of properties K of type T
Record<string, any>, function (type parameter) Success in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>Success, function (type parameter) Error in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>Error = never, function (type parameter) Context in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>Context = never>(
args: Types.Equals<
Omit<A, keyof Request<unknown, unknown>>,
{}
> extends true
? void
: {
readonly [P in keyof A as P extends keyof Request<
any,
any,
any
>
? never
: P]: A[P]
}
import TypesTypes.type Equals<X, Y> = (<T>() => T extends X
? 1
: 2) extends <T>() => T extends Y ? 1 : 2
? true
: false
Determines if two types are exactly equal at the type level.
When to use
Use to assert type equality in conditional types or type-level tests.
Details
- Uses the
<T>() => T extends X ? 1 : 2 trick for exact equality,
distinguishing between any, unknown, never, and other types.
- Resolves to
true if X and Y are identical, false otherwise.
Example (Checking type equality)
import type { Types } from "effect"
type Yes = Types.Equals<{ a: number }, { a: number }> // true
type No = Types.Equals<{ a: number }, { a: string }> // false
type AnyCheck = Types.Equals<any, string> // false
Equals<type Omit<T, K extends keyof any> = {
[P in Exclude<keyof T, K>]: T[P]
}
Construct a type with the properties of T except for those in type K.
Omit<function (type parameter) A in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>A, keyof interface Request<out A, out E = never, out R = never>A Request<A, E, R> is a request from a data source for a value of type A
that may fail with an E and have requirements of type R.
Example (Defining typed requests)
import type { Request } from "effect"
// Define a request that fetches a user by ID
interface GetUser extends Request.Request<string, Error> {
readonly _tag: "GetUser"
readonly id: number
}
// Define a request that fetches all users
interface GetAllUsers extends Request.Request<ReadonlyArray<string>, Error> {
readonly _tag: "GetAllUsers"
}
Request<unknown, unknown>>, {}> extends true ? void
: { readonly [function (type parameter) PP in keyof function (type parameter) A in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>A as function (type parameter) PP extends keyof interface Request<out A, out E = never, out R = never>A Request<A, E, R> is a request from a data source for a value of type A
that may fail with an E and have requirements of type R.
Example (Defining typed requests)
import type { Request } from "effect"
// Define a request that fetches a user by ID
interface GetUser extends Request.Request<string, Error> {
readonly _tag: "GetUser"
readonly id: number
}
// Define a request that fetches all users
interface GetAllUsers extends Request.Request<ReadonlyArray<string>, Error> {
readonly _tag: "GetAllUsers"
}
Request<any, any, any> ? never : function (type parameter) PP]: function (type parameter) A in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>A[function (type parameter) PP] }
) => interface Request<out A, out E = never, out R = never>A Request<A, E, R> is a request from a data source for a value of type A
that may fail with an E and have requirements of type R.
Example (Defining typed requests)
import type { Request } from "effect"
// Define a request that fetches a user by ID
interface GetUser extends Request.Request<string, Error> {
readonly _tag: "GetUser"
readonly id: number
}
// Define a request that fetches all users
interface GetAllUsers extends Request.Request<ReadonlyArray<string>, Error> {
readonly _tag: "GetAllUsers"
}
Request<function (type parameter) Success in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>Success, function (type parameter) Error in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>Error, function (type parameter) Context in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>Context> & type Readonly<T> = {
readonly [P in keyof T]: T[P]
}
Make all properties in T readonly
Readonly<function (type parameter) A in <A extends Record<string, any>, Success, Error = never, Context = never>(args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P]; }): Request<Success, Error, Context> & Readonly<A>A> = (function() {
function function (local function) Class(this: any, args: any): voidClass(this: anythis: any, args: anyargs: any) {
if (args: anyargs) {
var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.assign<any, any>(target: any, source: any): any (+3 overloads)Copy the values of all of the enumerable own properties from one or more source objects to a
target object. Returns the target object.
assign(this, args: anyargs)
}
}
function (local function) Class(this: any, args: any): voidClass.Class.prototype: Request<any, any, any>prototype = const RequestPrototype: Request<
any,
any,
any
>
Prototype used by Effect's request constructors.
Details
This low-level value provides the structural request marker for values
created by Request.of, Request.tagged, Request.Class, and
Request.TaggedClass. Most users should use those constructors instead of
interacting with the prototype directly.
RequestPrototype
return function (local function) Class(this: any, args: any): voidClass as any
})()Referenced by 1 symbols