<E>(cause: Cause.Cause<E>): Exit.Exit<
Cause.Done.Extract<E>,
ExcludeDone<E>
>Converts a Cause into an Exit, treating Cause.Done as successful
completion.
When to use
Use to produce an Exit for finalizing a low-level pull workflow when a
Cause.Done signal should be treated as success and any remaining cause
should fail.
Details
If the cause contains a done value, that leftover becomes the successful value. Otherwise the non-done cause becomes the failure cause.
export const const doneExitFromCause: <E>(
cause: Cause.Cause<E>
) => Exit.Exit<
Cause.Done.Extract<E>,
ExcludeDone<E>
>
Converts a Cause into an Exit, treating Cause.Done as successful
completion.
When to use
Use to produce an Exit for finalizing a low-level pull workflow when a
Cause.Done signal should be treated as success and any remaining cause
should fail.
Details
If the cause contains a done value, that leftover becomes the successful
value. Otherwise the non-done cause becomes the failure cause.
doneExitFromCause = <function (type parameter) E in <E>(cause: Cause.Cause<E>): Exit.Exit<Cause.Done.Extract<E>, ExcludeDone<E>>E>(cause: Cause.Cause<E>(parameter) cause: {
reasons: ReadonlyArray<Reason<E>>;
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;
}
import CauseCause.type Cause.Cause = /*unresolved*/ anyCause<function (type parameter) E in <E>(cause: Cause.Cause<E>): Exit.Exit<Cause.Done.Extract<E>, ExcludeDone<E>>E>): import ExitExit.type Exit.Exit = /*unresolved*/ anyExit<import CauseCause.declareDone.type Cause.Done.Extract = /*unresolved*/ anyExtract<function (type parameter) E in <E>(cause: Cause.Cause<E>): Exit.Exit<Cause.Done.Extract<E>, ExcludeDone<E>>E>, type ExcludeDone<E> =
E extends Cause.Done<any> ? never : E
Excludes Cause.Done completion signals from an error type union.
When to use
Use to describe the ordinary error type that remains after Cause.Done
completion signals have been handled or filtered out of an error union.
ExcludeDone<function (type parameter) E in <E>(cause: Cause.Cause<E>): Exit.Exit<Cause.Done.Extract<E>, ExcludeDone<E>>E>> => {
const const halt: Result.Result<
Cause.Done.Only<E>,
Cause.Cause<Exclude<E, Cause.Done<any>>>
>
const filterDone: <E>(
input: Cause.Cause<E>
) => Result.Result<
Cause.Done.Only<E>,
Cause.Cause<ExcludeDone<E>>
>
Finds a Cause.Done failure in a Cause.
When to use
Use to separate Cause.Done completion from ordinary causes while preserving
the typed done value.
Details
Returns a successful Result with the Cause.Done value when one is
present, otherwise returns a failed Result containing the non-done cause.
filterDone(cause: Cause.Cause<E>(parameter) cause: {
reasons: ReadonlyArray<Reason<E>>;
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;
}
import ResultResult.const isFailure: <A, E>(
self: Result<A, E>
) => self is Failure<A, E>
Checks whether a Result is a Failure.
When to use
Use to narrow a known Result to the Failure variant.
Details
- Acts as a TypeScript type guard, narrowing to
Failure<A, E>
- After narrowing, you can access
.failure to read the error value
Example (Narrowing to failure)
import { Result } from "effect"
const result = Result.fail("oops")
if (Result.isFailure(result)) {
console.log(result.failure)
// Output: "oops"
}
isFailure(const halt: Result.Result<
Cause.Done.Only<E>,
Cause.Cause<Exclude<E, Cause.Done<any>>>
>
import ExitExit.succeed(const halt: Result.Success<
Cause.Done.Only<E>,
Cause.Cause<Exclude<E, Cause.Done<any>>>
>
const halt: {
_tag: "Success";
_op: "Success";
success: A;
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;
}
Success<Cause.Done.Only<E>, Cause.Cause<Exclude<E, Cause.Done<any>>>>.success: Cause.Done.Only<E>success.value as any) : import ExitExit.failCause(const halt: Result.Failure<
Cause.Done.Only<E>,
Cause.Cause<Exclude<E, Cause.Done<any>>>
>
const halt: {
_tag: "Failure";
_op: "Failure";
failure: E;
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;
}
Failure<Cause.Done.Only<E>, Cause.Cause<Exclude<E, Cause.Done<any>>>>.failure: Cause.Cause<Exclude<E, Cause.Done<any>>>(property) Failure<Cause.Done.Only<E>, Cause.Cause<Exclude<E, Cause.Done<any>>>>.failure: {
reasons: ReadonlyArray<Reason<E>>;
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;
}