<T extends Iterable<Result.Result<any, any>>>(self: T): Array<
Result.Result.Failure<ReadonlyArray.Infer<T>>
>Extracts all failure values from an iterable of Results, discarding
successes.
When to use
Use when you can drop the success channel and only need the failure payloads, not the original result wrappers.
Example (Extracting failures)
import { Array, Result } from "effect"
console.log(Array.getFailures([Result.succeed(1), Result.fail("err"), Result.succeed(2)]))
// ["err"]export const const getFailures: <
T extends Iterable<Result.Result<any, any>>
>(
self: T
) => Array<
Result.Result.Failure<ReadonlyArray.Infer<T>>
>
Extracts all failure values from an iterable of Results, discarding
successes.
When to use
Use when you can drop the success channel and only need the failure
payloads, not the original result wrappers.
Example (Extracting failures)
import { Array, Result } from "effect"
console.log(Array.getFailures([Result.succeed(1), Result.fail("err"), Result.succeed(2)]))
// ["err"]
getFailures = <function (type parameter) T in <T extends Iterable<Result.Result<any, any>>>(self: T): Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>T extends interface Iterable<T, TReturn = any, TNext = any>Iterable<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<any, any>>>(
self: T extends Iterable<Result.Result<any, any>>self: function (type parameter) T in <T extends Iterable<Result.Result<any, any>>>(self: T): Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>T
): interface Array<T>Array<import ResultResult.Result.type Result<A, E = never>.Failure<T extends Result.Result<any, any>> = [T] extends [Result.Result<infer _A, infer _E>] ? _E : neverExtracts the failure type E from Result<A, E>.
Failure<ReadonlyArray.type ReadonlyArray.Infer<S extends Iterable<any>> = S extends readonly (infer A)[] ? A : S extends Iterable<infer A> ? A : neverInfers the element type of an iterable.
Example (Inferring an element type)
import type { Array } from "effect"
type StringArrayType = Array.ReadonlyArray.Infer<ReadonlyArray<string>>
// StringArrayType is string
Infer<function (type parameter) T in <T extends Iterable<Result.Result<any, any>>>(self: T): Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>T>>> => {
const const out: any[]out: interface Array<T>Array<any> = []
for (const const a: Result.Result<any, any>a of self: T extends Iterable<Result.Result<any, any>>self) {
if (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 a: Result.Result<any, any>a)) {
const out: any[]out.Array<any>.push(...items: any[]): numberAppends new elements to the end of an array, and returns the new length of the array.
push(const a: Result.Failure<any, any>const a: {
_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<any, any>.failure: anyfailure)
}
}
return const out: any[]out
}