<
E,
Cases extends {
[K in Extract<E, { _tag: string }>["_tag"]]+?: (
error: Extract<E, { _tag: K }>
) => Effect<any, any, any>
} & (unknown extends E
? {}
: {
[K in Exclude<
keyof Cases,
Extract<E, { _tag: string }>["_tag"]
>]: never
}),
A2 = unassigned,
E2 = never,
R2 = never
>(
cases: Cases,
orElse?:
| ((e: Exclude<E, { _tag: keyof Cases }>) => Effect<A2, E2, R2>)
| undefined
): <A, R>(
self: Effect<A, E, R>
) => Effect<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned ? Exclude<E, { _tag: keyof Cases }> : never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, any, infer R>
? R
: never
}[keyof Cases]
>
<
R,
E,
A,
Cases extends {
[K in Extract<E, { _tag: string }>["_tag"]]+?: (
error: Extract<E, { _tag: K }>
) => Effect<any, any, any>
} & (unknown extends E
? {}
: {
[K in Exclude<
keyof Cases,
Extract<E, { _tag: string }>["_tag"]
>]: never
}),
A2 = unassigned,
E2 = never,
R2 = never
>(
self: Effect<A, E, R>,
cases: Cases,
orElse?:
| ((e: Exclude<E, { _tag: keyof Cases }>) => Effect<A2, E2, R2>)
| undefined
): Effect<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned ? Exclude<E, { _tag: keyof Cases }> : never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, any, infer R>
? R
: never
}[keyof Cases]
>Handles multiple errors in a single block of code using their _tag field.
When to use
Use when one recovery step should handle several tagged error types by
matching their readonly _tag fields.
Details
Pass a handler table whose keys are tags, plus an optional fallback for unmatched errors.
The error type must have a readonly _tag field to use catchTags. This
field is used to identify and match errors.
Example (Handling multiple tagged errors)
import { Data, Effect } from "effect"
// Define tagged error types
class ValidationError extends Data.TaggedError("ValidationError")<{
message: string
}> {}
class NetworkError extends Data.TaggedError("NetworkError")<{
statusCode: number
}> {}
// An effect that might fail with multiple error types
declare const program: Effect.Effect<string, ValidationError | NetworkError>
// Handle multiple error types at once
const handled = Effect.catchTags(program, {
ValidationError: (error) =>
Effect.succeed(`Validation failed: ${error.message}`),
NetworkError: (error) => Effect.succeed(`Network error: ${error.statusCode}`)
})error handling
Source effect/Effect.ts:279963 lines
export const const catchTags: {
<
E,
Cases extends {
[K in Extract<
E,
{
_tag: string
}
>["_tag"]]+?: (
error: Extract<
E,
{
_tag: K
}
>
) => Effect<any, any, any>
} & (unknown extends E
? {}
: {
[K in Exclude<
keyof Cases,
Extract<
E,
{
_tag: string
}
>["_tag"]
>]: never
}),
A2 = unassigned,
E2 = never,
R2 = never
>(
cases: Cases,
orElse?:
| ((
e: Exclude<E, { _tag: keyof Cases }>
) => Effect<A2, E2, R2>)
| undefined
): <A, R>(
self: Effect<A, E, R>
) => Effect<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned
? Exclude<E, { _tag: keyof Cases }>
: never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, any, infer R>
? R
: never
}[keyof Cases]
>
<
R,
E,
A,
Cases extends {
[K in Extract<
E,
{
_tag: string
}
>["_tag"]]+?: (
error: Extract<
E,
{
_tag: K
}
>
) => Effect<any, any, any>
} & (unknown extends E
? {}
: {
[K in Exclude<
keyof Cases,
Extract<
E,
{
_tag: string
}
>["_tag"]
>]: never
}),
A2 = unassigned,
E2 = never,
R2 = never
>(
self: Effect<A, E, R>,
cases: Cases,
orElse?:
| ((
e: Exclude<E, { _tag: keyof Cases }>
) => Effect<A2, E2, R2>)
| undefined
): Effect<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned
? Exclude<E, { _tag: keyof Cases }>
: never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect<any, any, infer R>
? R
: never
}[keyof Cases]
>
}
Handles multiple errors in a single block of code using their _tag field.
When to use
Use when one recovery step should handle several tagged error types by
matching their readonly _tag fields.
Details
Pass a handler table whose keys are tags, plus an optional fallback for
unmatched errors.
The error type must have a readonly _tag field to use catchTags. This
field is used to identify and match errors.
Example (Handling multiple tagged errors)
import { Data, Effect } from "effect"
// Define tagged error types
class ValidationError extends Data.TaggedError("ValidationError")<{
message: string
}> {}
class NetworkError extends Data.TaggedError("NetworkError")<{
statusCode: number
}> {}
// An effect that might fail with multiple error types
declare const program: Effect.Effect<string, ValidationError | NetworkError>
// Handle multiple error types at once
const handled = Effect.catchTags(program, {
ValidationError: (error) =>
Effect.succeed(`Validation failed: ${error.message}`),
NetworkError: (error) => Effect.succeed(`Network error: ${error.statusCode}`)
})
catchTags: {
<
function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: string_tag: string }>["_tag"]]+?: ((error: Extract<
E,
{
_tag: K
}
>
type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: K extends Extract<E, { _tag: string; }>["_tag"]_tag: function (type parameter) KK }>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<any, any, any>) }
& (unknown extends function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: string_tag: string }>["_tag"]>]: never }),
function (type parameter) A2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
cases: Cases extends { [K in Extract<E, { _tag: string; }>["_tag"]]+?: ((error: Extract<E, { _tag: K; }>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string; }>["_tag"]>]: never; })cases: function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
orElse: | ((
e: Exclude<E, { _tag: keyof Cases }>
) => Effect<A2, E2, R2>)
| undefined
e: Exclude<
E,
{
_tag: keyof Cases
}
>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) A in <A, R>(self: Effect<A, E, R>): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R in <A, R>(self: Effect<A, E, R>): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
self: Effect<A, E, R>(parameter) self: {
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; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, R>(self: Effect<A, E, R>): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R in <A, R>(self: Effect<A, E, R>): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<
| function (type parameter) A in <A, R>(self: Effect<A, E, R>): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) A2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK] extends (...args: any[]args: interface Array<T>Array<any>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<infer function (type parameter) AA, any, any> ? function (type parameter) AA : never
}[keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) A2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK] extends (...args: any[]args: interface Array<T>Array<any>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<any, infer function (type parameter) EE, any> ? function (type parameter) EE : never
}[keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R in <A, R>(self: Effect<A, E, R>): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R2 in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK] extends (...args: any[]args: interface Array<T>Array<any>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<any, any, infer function (type parameter) RR> ? function (type parameter) RR : never
}[keyof function (type parameter) Cases in <E, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) A in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: string_tag: string }>["_tag"]]+?: ((error: Extract<
E,
{
_tag: K
}
>
type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: K extends Extract<E, { _tag: string; }>["_tag"]_tag: function (type parameter) KK }>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<any, any, any>) }
& (unknown extends function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: string_tag: string }>["_tag"]>]: never }),
function (type parameter) A2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
self: Effect<A, E, R>(parameter) self: {
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; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
cases: Cases extends { [K in Extract<E, { _tag: string; }>["_tag"]]+?: ((error: Extract<E, { _tag: K; }>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string; }>["_tag"]>]: never; })cases: function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
orElse: | ((
e: Exclude<E, { _tag: keyof Cases }>
) => Effect<A2, E2, R2>)
| undefined
e: Exclude<
E,
{
_tag: keyof Cases
}
>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<
| function (type parameter) A in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) A2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK] extends (...args: any[]args: interface Array<T>Array<any>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<infer function (type parameter) AA, any, any> ? function (type parameter) AA : never
}[keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) E2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) A2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK] extends (...args: any[]args: interface Array<T>Array<any>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<any, infer function (type parameter) EE, any> ? function (type parameter) EE : never
}[keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) R2 in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
function (type parameter) KK] extends (...args: any[]args: interface Array<T>Array<any>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<any, any, infer function (type parameter) RR> ? function (type parameter) RR : never
}[keyof function (type parameter) Cases in <R, E, A, Cases extends { [K in Extract<E, {
_tag: string;
}>["_tag"]]+?: ((error: Extract<E, {
_tag: K;
}>) => Effect<any, any, any>); } & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, {
_tag: string;
}>["_tag"]>]: never; }), A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never; }[keyof Cases]>
import internalinternal.const catchTags: {
<
E,
Cases extends E extends { _tag: string }
? {
[K in E["_tag"]]+?: (
error: Extract<
E,
{
_tag: K
}
>
) => Effect.Effect<any, any, any>
}
: {},
A2 = unassigned,
E2 = never,
R2 = never
>(
cases: Cases,
orElse?:
| ((
e: Exclude<E, { _tag: keyof Cases }>
) => Effect.Effect<A2, E2, R2>)
| undefined
): <A, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect.Effect<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned
? Exclude<E, { _tag: keyof Cases }>
: never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect.Effect<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect.Effect<any, any, infer R>
? R
: never
}[keyof Cases]
>
<
R,
E,
A,
Cases extends E extends { _tag: string }
? {
[K in E["_tag"]]+?: (
error: Extract<
E,
{
_tag: K
}
>
) => Effect.Effect<any, any, any>
}
: {},
A2 = unassigned,
E2 = never,
R2 = never
>(
self: Effect.Effect<A, E, R>,
cases: Cases,
orElse?:
| ((
e: Exclude<E, { _tag: keyof Cases }>
) => Effect.Effect<A2, E2, R2>)
| undefined
): Effect.Effect<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect.Effect<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned
? Exclude<E, { _tag: keyof Cases }>
: never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect.Effect<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Effect.Effect<any, any, infer R>
? R
: never
}[keyof Cases]
>
}