<T extends Iterable<Result.Result<any, any>>>(self: T): [
failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>,
successes: Array<Result.Result.Success<ReadonlyArray.Infer<T>>>
]Separates an iterable of Results into failure values and success values.
When to use
Use to split an iterable of Result values into failure and success arrays.
Details
Returns [failures, successes]. This is equivalent to
partition(identity).
Example (Separating Results)
import { Array, Result } from "effect"
const [failures, successes] = Array.separate([
Result.succeed(1), Result.fail("error"), Result.succeed(2)
])
console.log(failures) // ["error"]
console.log(successes) // [1, 2]export const const separate: <
T extends Iterable<Result.Result<any, any>>
>(
self: T
) => [
failures: Array<
Result.Result.Failure<ReadonlyArray.Infer<T>>
>,
successes: Array<
Result.Result.Success<ReadonlyArray.Infer<T>>
>
]
Separates an iterable of Results into failure values and success values.
When to use
Use to split an iterable of Result values into failure and success arrays.
Details
Returns [failures, successes]. This is equivalent to
partition(identity).
Example (Separating Results)
import { Array, Result } from "effect"
const [failures, successes] = Array.separate([
Result.succeed(1), Result.fail("error"), Result.succeed(2)
])
console.log(failures) // ["error"]
console.log(successes) // [1, 2]
separate: <function (type parameter) T in <T extends Iterable<Result.Result<any, any>>>(self: T): [failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>, successes: 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): [failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>, successes: Array<Result.Result.Success<ReadonlyArray.Infer<T>>>]T
) => [
Result.Result.Failure <
ReadonlyArray.Infer <
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): [failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>, successes: Array<Result.Result.Success<ReadonlyArray.Infer<T>>>]T>>>,
Result.Result.Success <
ReadonlyArray.Infer <
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): [failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>, successes: Array<Result.Result.Success<ReadonlyArray.Infer<T>>>]T>>>
] = const partition: {
<A, Pass, Fail>(
f: (
input: NoInfer<A>,
i: number
) => Result.Result<Pass, Fail>
): (
self: Iterable<A>
) => [
excluded: Array<Fail>,
satisfying: Array<Pass>
]
<A, Pass, Fail>(
self: Iterable<A>,
f: (
input: A,
i: number
) => Result.Result<Pass, Fail>
): [
excluded: Array<Fail>,
satisfying: Array<Pass>
]
}
const identity: <A>(a: A) => AReturns its input argument unchanged.
When to use
Use to return a value unchanged where a function is required.
Example (Returning the same value)
import { identity } from "effect"
import * as assert from "node:assert"
assert.deepStrictEqual(identity(5), 5)
identity)