byethrow

    Function: sequence()

    Processes multiple Result or ResultAsync values into a single result. If all results are Success, returns a Success containing all values. If any result is a Failure, immediately stops processing and returns a Failure with that single error.

    Unlike collect, which processes all results and collects all errors, sequence stops at the first error and returns only that error.

    Type Param

    The input type (object or array of Results).

    Examples

    import { 
    import Result
    Result     } from '@praha/byethrow';    

const 
    const result: Result.Result<{
    name: "Alice";
    age: 20;
}, never>
    result     = 
    import Result
    Result    .
    const sequence: <{
    name: Result.Result<"Alice", never>;
    age: Result.Result<20, never>;
}>(x: {
    name: Result.Result<"Alice", never>;
    age: Result.Result<20, never>;
}) => Result.Result<{
    name: "Alice";
    age: 20;
}, never> (+4 overloads)
    sequence    ({    
  
    name: Result.Result<"Alice", never>
    name    : 
    import Result
    Result    .
    const succeed: <"Alice">(value: "Alice") => Result.Result<"Alice", never> (+1 overload)
    succeed    ('Alice'),    
  
    age: Result.Result<20, never>
    age    : 
    import Result
    Result    .
    const succeed: <20>(value: 20) => Result.Result<20, never> (+1 overload)
    succeed    (20),    
});
// { type: 'Success', value: { name: 'Alice', age: 20 } }
    import { 
    import Result
    Result     } from '@praha/byethrow';    

const 
    const result: Result.Result<{
    name: "Alice";
    age: never;
}, "Invalid age">
    result     = 
    import Result
    Result    .
    const sequence: <{
    name: Result.Result<"Alice", never>;
    age: Result.Result<never, "Invalid age">;
}>(x: {
    name: Result.Result<"Alice", never>;
    age: Result.Result<never, "Invalid age">;
}) => Result.Result<{
    name: "Alice";
    age: never;
}, "Invalid age"> (+4 overloads)
    sequence    ({    
  
    name: Result.Result<"Alice", never>
    name    : 
    import Result
    Result    .
    const succeed: <"Alice">(value: "Alice") => Result.Result<"Alice", never> (+1 overload)
    succeed    ('Alice'),    
  
    age: Result.Result<never, "Invalid age">
    age    : 
    import Result
    Result    .
    const fail: <"Invalid age">(error: "Invalid age") => Result.Result<never, "Invalid age"> (+1 overload)
    fail    ('Invalid age'),    
});
// { type: 'Failure', error: 'Invalid age' }
    import { 
    import Result
    Result     } from '@praha/byethrow';    

const 
    const result: Result.Result<[1, 2], never>
    result     = 
    import Result
    Result    .
    const sequence: <[Result.Result<1, never>, Result.Result<2, never>]>(x: [Result.Result<1, never>, Result.Result<2, never>]) => Result.Result<[1, 2], never> (+4 overloads)
    sequence    ([    
  
    import Result
    Result    .
    const succeed: <1>(value: 1) => Result.Result<1, never> (+1 overload)
    succeed    (1),    
  
    import Result
    Result    .
    const succeed: <2>(value: 2) => Result.Result<2, never> (+1 overload)
    succeed    (2),    
]);
// { type: 'Success', value: [1, 2, 3] }
    import { 
    import Result
    Result     } from '@praha/byethrow';    

const 
    const result: Result.Result<[1, never], "error1">
    result     = 
    import Result
    Result    .
    const sequence: <[Result.Result<1, never>, Result.Result<never, "error1">]>(x: [Result.Result<1, never>, Result.Result<never, "error1">]) => Result.Result<[1, never], "error1"> (+4 overloads)
    sequence    ([    
  
    import Result
    Result    .
    const succeed: <1>(value: 1) => Result.Result<1, never> (+1 overload)
    succeed    (1),    
  
    import Result
    Result    .
    const fail: <"error1">(error: "error1") => Result.Result<never, "error1"> (+1 overload)
    fail    ('error1'),    
]);
// { type: 'Failure', error: 'error1' }
    import { 
    import Result
    Result     } from '@praha/byethrow';    

const 
    const result: Result.Result<[number, number, number], "Invalid number: 1" | "Invalid number: 2" | "Invalid number: 3">
    result     = 
    import Result
    Result    .
    const sequence: <["1", "2", "3"], (value: "1" | "2" | "3") => Result.Failure<"Invalid number: 1" | "Invalid number: 2" | "Invalid number: 3"> | Result.Success<number>>(x: ["1", "2", "3"], fn: (value: "1" | "2" | "3") => Result.Failure<"Invalid number: 1" | "Invalid number: 2" | "Invalid number: 3"> | Result.Success<number>) => Result.Result<[number, number, number], "Invalid number: 1" | "Invalid number: 2" | "Invalid number: 3"> (+4 overloads)
    sequence    (['1', '2', '3'], (
    value: "1" | "2" | "3"
    value    ) => {    
  const 
    const number: number
    number     = 
    var Number: NumberConstructor
(value?: any) => number
    An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers.
    Number    (
    value: "1" | "2" | "3"
    value    );    
  return 
    var Number: NumberConstructor
    An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers.
    Number    .
    NumberConstructor.isNaN(number: unknown): boolean
    Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
to a number. Only values of the type number, that are also NaN, result in true.
    @paramnumber  A numeric value.
    isNaN    (
    const number: number
    number    )    
    ? 
    import Result
    Result    .
    const fail: <"Invalid number: 1" | "Invalid number: 2" | "Invalid number: 3">(error: "Invalid number: 1" | "Invalid number: 2" | "Invalid number: 3") => Result.Result<never, "Invalid number: 1" | "Invalid number: 2" | "Invalid number: 3"> (+1 overload)
    fail    (`Invalid number: ${
    value: "1" | "2" | "3"
    value    }`)    
    : 
    import Result
    Result    .
    const succeed: <number>(value: number) => Result.Result<number, never> (+1 overload)
    succeed    (
    const number: number
    number    );    
});
// { type: 'Success', value: [1, 2, 3] }
    import { 
    import Result
    Result     } from '@praha/byethrow';    

const 
    const result: Result.Result<[number, number, number], "Invalid number: 1" | "Invalid number: invalid" | "Invalid number: 3">
    result     = 
    import Result
    Result    .
    const sequence: <["1", "invalid", "3"], (value: "1" | "invalid" | "3") => Result.Failure<"Invalid number: 1" | "Invalid number: invalid" | "Invalid number: 3"> | Result.Success<number>>(x: ["1", "invalid", "3"], fn: (value: "1" | "invalid" | "3") => Result.Failure<"Invalid number: 1" | "Invalid number: invalid" | "Invalid number: 3"> | Result.Success<number>) => Result.Result<[number, number, number], "Invalid number: 1" | "Invalid number: invalid" | "Invalid number: 3"> (+4 overloads)
    sequence    (['1', 'invalid', '3'], (
    value: "1" | "invalid" | "3"
    value    ) => {    
  const 
    const number: number
    number     = 
    var Number: NumberConstructor
(value?: any) => number
    An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers.
    Number    (
    value: "1" | "invalid" | "3"
    value    );    
  return 
    var Number: NumberConstructor
    An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers.
    Number    .
    NumberConstructor.isNaN(number: unknown): boolean
    Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
to a number. Only values of the type number, that are also NaN, result in true.
    @paramnumber  A numeric value.
    isNaN    (
    const number: number
    number    )    
    ? 
    import Result
    Result    .
    const fail: <"Invalid number: 1" | "Invalid number: invalid" | "Invalid number: 3">(error: "Invalid number: 1" | "Invalid number: invalid" | "Invalid number: 3") => Result.Result<never, "Invalid number: 1" | "Invalid number: invalid" | "Invalid number: 3"> (+1 overload)
    fail    (`Invalid number: ${
    value: "1" | "invalid" | "3"
    value    }`)    
    : 
    import Result
    Result    .
    const succeed: <number>(value: number) => Result.Result<number, never> (+1 overload)
    succeed    (
    const number: number
    number    );    
});
// { type: 'Failure', error: 'Invalid number: invalid' }

    Call Signature

    sequence<X>(x): ResultFor<X[keyof X], { [K in string | number | symbol]: InferSuccess<X[K]> }, InferFailure<X[keyof X]>>

    Type Parameters

    X

    X extends Record<string, ResultMaybeAsync<any, any>>

    Parameters

    x

    X

    Returns

    ResultFor<X[keyof X], { [K in string | number | symbol]: InferSuccess<X[K]> }, InferFailure<X[keyof X]>>

    Call Signature

    sequence<X>(x): ResultFor<X[number], { [K in string | number | symbol]: InferSuccess<X[K<K>]> }, InferFailure<X[number]>>

    Type Parameters

    X

    X extends ResultMaybeAsync<any, any>[]

    Parameters

    x

    X

    Returns

    ResultFor<X[number], { [K in string | number | symbol]: InferSuccess<X[K<K>]> }, InferFailure<X[number]>>

    Call Signature

    sequence<X>(x): ResultFor<X[number], { [K in string | number | symbol]: InferSuccess<X[K<K>]> }, InferFailure<X[number]>>

    Type Parameters

    X

    X extends readonly ResultMaybeAsync<any, any>[]

    Parameters

    x

    X

    Returns

    ResultFor<X[number], { [K in string | number | symbol]: InferSuccess<X[K<K>]> }, InferFailure<X[number]>>

    Call Signature

    sequence<X, Fn>(x, fn): ResultFor<ReturnType<Fn>, { [K in string | number | symbol]: InferSuccess<Fn> }, InferFailure<Fn>>

    Type Parameters

    X

    X extends unknown[]

    Fn

    Fn extends (value) => ResultMaybeAsync<any, any>

    Parameters

    x

    X

    fn

    Fn

    Returns

    ResultFor<ReturnType<Fn>, { [K in string | number | symbol]: InferSuccess<Fn> }, InferFailure<Fn>>

    Call Signature

    sequence<X, Fn>(x, fn): ResultFor<ReturnType<Fn>, { [K in string | number | symbol]: InferSuccess<Fn> }, InferFailure<Fn>>

    Type Parameters

    X

    X extends readonly unknown[]

    Fn

    Fn extends (value) => ResultMaybeAsync<any, any>

    Parameters

    x

    X

    fn

    Fn

    Returns

    ResultFor<ReturnType<Fn>, { [K in string | number | symbol]: InferSuccess<Fn> }, InferFailure<Fn>>