<T extends Iterable<Result.Result<any, any>>>(self: T): Array<
Result.Result.Success<ReadonlyArray.Infer<T>>
>Extracts all success values from an iterable of Results, discarding
failures.
When to use
Use when you can drop the failure channel and only need the success payloads, not the original result wrappers.
Example (Extracting successes)
import { Array, Result } from "effect"
console.log(Array.getSuccesses([Result.succeed(1), Result.fail("err"), Result.succeed(2)]))
// [1, 2]export const const getSuccesses: <
T extends Iterable<Result.Result<any, any>>
>(
self: T
) => Array<
Result.Result.Success<ReadonlyArray.Infer<T>>
>
Extracts all success values from an iterable of Results, discarding
failures.
When to use
Use when you can drop the failure channel and only need the success
payloads, not the original result wrappers.
Example (Extracting successes)
import { Array, Result } from "effect"
console.log(Array.getSuccesses([Result.succeed(1), Result.fail("err"), Result.succeed(2)]))
// [1, 2]
getSuccesses = <function (type parameter) T in <T extends Iterable<Result.Result<any, any>>>(self: T): Array<Result.Result.Success<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.Success<ReadonlyArray.Infer<T>>>T
): interface Array<T>Array<import ResultResult.Result.type Result<A, E = never>.Success<T extends Result.Result<any, any>> = [T] extends [Result.Result<infer _A, infer _E>] ? _A : neverExtracts the success type A from Result<A, E>.
Success<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.Success<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 isSuccess: <A, E>(
self: Result<A, E>
) => self is Success<A, E>
Checks whether a Result is a Success.
When to use
Use to narrow a known Result to the Success variant.
Details
- Acts as a TypeScript type guard, narrowing to
Success<A, E>
- After narrowing, you can access
.success to read the value
Example (Narrowing to success)
import { Result } from "effect"
const result = Result.succeed(42)
if (Result.isSuccess(result)) {
console.log(result.success)
// Output: 42
}
isSuccess(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.Success<any, any>const a: {
_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<any, any>.success: anysuccess)
}
}
return const out: any[]out
}