<E>(input: Cause.Cause<E>): Result.Result<
Cause.Cause<ExcludeDone<E>>,
Cause.Cause<E>
>Keeps a Cause only when it contains no Cause.Done failures.
When to use
Use to select ordinary failure causes for handling while leaving Cause.Done
completion causes outside that handler.
Details
Returns a successful Result with the cause when every failure is non-done;
otherwise returns a failed Result with the original cause.
export const const filterNoDone: <E>(
input: Cause.Cause<E>
) => Result.Result<
Cause.Cause<ExcludeDone<E>>,
Cause.Cause<E>
>
Keeps a Cause only when it contains no Cause.Done failures.
When to use
Use to select ordinary failure causes for handling while leaving Cause.Done
completion causes outside that handler.
Details
Returns a successful Result with the cause when every failure is non-done;
otherwise returns a failed Result with the original cause.
filterNoDone: <function (type parameter) E in <E>(input: Cause.Cause<E>): Result.Result<Cause.Cause<ExcludeDone<E>>, Cause.Cause<E>>E>(
input: Cause.Cause<E>(parameter) input: {
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>(input: Cause.Cause<E>): Result.Result<Cause.Cause<ExcludeDone<E>>, Cause.Cause<E>>E>
) => import ResultResult.type Result<A, E = never> = Result.Success<A, E> | Result.Failure<A, E>A value that is either Success<A, E> or Failure<A, E>.
When to use
Use when both success and failure should remain available as data and
Option would lose failure information.
Details
- Use
succeed
/
fail
to construct
- Use
match
to fold both branches
- Use
isSuccess
/
isFailure
to narrow the type
E defaults to never, so Result<number> means a result that cannot fail.
Example (Creating and matching a Result)
import { Result } from "effect"
const success = Result.succeed(42)
const failure = Result.fail("something went wrong")
const message = Result.match(success, {
onSuccess: (value) => `Success: ${value}`,
onFailure: (error) => `Error: ${error}`
})
console.log(message)
// Output: "Success: 42"
Namespace containing type-level utilities for extracting the inner types
of a Result.
Example (Extracting inner types)
import type { Result } from "effect"
type R = Result.Result<number, string>
// number
type A = Result.Result.Success<R>
// string
type E = Result.Result.Failure<R>
Result<
import CauseCause.type Cause.Cause = /*unresolved*/ anyCause<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>(input: Cause.Cause<E>): Result.Result<Cause.Cause<ExcludeDone<E>>, Cause.Cause<E>>E>>,
import CauseCause.type Cause.Cause = /*unresolved*/ anyCause<function (type parameter) E in <E>(input: Cause.Cause<E>): Result.Result<Cause.Cause<ExcludeDone<E>>, Cause.Cause<E>>E>
> = import FilterFilter.fromPredicate((cause: Cause.Cause<unknown>(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<unknown>) =>
cause: Cause.Cause<unknown>(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;
}
failure: Cause.Reason<unknown>failure) => !const isDoneFailure: <E>(
failure: Cause.Reason<E>
) => failure is Cause.Fail<E & Cause.Done<any>>
Checks whether a Cause.Reason is a Fail reason whose error is a
Cause.Done signal.
When to use
Use when you need to identify done completion reasons while traversing
cause.reasons, before handling ordinary failures.
isDoneFailure(failure: Cause.Reason<unknown>failure))
) as any