logo
byethrow
  • Guide
  • Examples
  • API Reference
    @praha/byethrow
    Modules
    Result
    Types
    Type Alias: Failure<E>
    Type Alias: InferFailure<T>
    Type Alias: InferSuccess<T>
    Type Alias: Result<T, E>
    Type Alias: ResultAsync<T, E>
    Type Alias: ResultFor<R, T, E>
    Type Alias: ResultMaybeAsync<T, E>
    Type Alias: Success<T>
    Functions
    Function: andThen()
    Function: andThrough()
    Function: assertFailure()
    Function: assertSuccess()
    Function: bind()
    Function: collect()
    Function: do()
    Function: fail()
    Function: inspect()
    Function: inspectError()
    Function: isFailure()
    Function: isResult()
    Function: isSuccess()
    Function: map()
    Function: mapError()
    Function: orElse()
    Function: parse()
    Function: pipe()
    Function: sequence()
    Function: succeed()
    Function: try()
    Function: unwrap()
    Function: unwrapError()
    📝 Edit this page

    Last Updated:

    Previous pageType Alias: Success<T>Next pageFunction: andThrough()

    #Function: andThen()

    Chains the next computation using the success value of a Result or ResultAsync. If the original result is a Failure, it is returned unchanged. Otherwise, the provided function is called, and its result is returned as-is.

    #Type Param

    The input Result or ResultAsync.

    #Type Param

    The result type returned by fn.

    #Examples

    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.Result<number, never>
    result
    =
    import Result
    Result
    .
    const pipe: <Result.Result<3, never>, Result.Result<number, never>>(a: Result.Result<3, never>, ab: (a: Result.Result<3, never>) => Result.Result<number, never>) => Result.Result<number, never> (+25 overloads)
    pipe
    (
    import Result
    Result
    .
    const succeed: <3>(value: 3) => Result.Result<3, never> (+1 overload)
    succeed
    (3),
    import Result
    Result
    .
    const andThen: <Result.Result<3, never>, Result.Result<number, never>>(fn: (a: 3) => Result.Result<number, never>) => (result: Result.Result<3, never>) => Result.Result<number, never> (+1 overload)
    andThen
    ((
    x: 3
    x
    ) =>
    import Result
    Result
    .
    const succeed: <number>(value: number) => Result.Result<number, never> (+1 overload)
    succeed
    (
    x: 3
    x
    * 2)),
    ); // { type: 'Success', value: 6 }
    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.Result<number, "error">
    result
    =
    import Result
    Result
    .
    const pipe: <Result.Result<never, "error">, Result.Result<number, "error">>(a: Result.Result<never, "error">, ab: (a: Result.Result<never, "error">) => Result.Result<number, "error">) => Result.Result<number, "error"> (+25 overloads)
    pipe
    (
    import Result
    Result
    .
    const fail: <"error">(error: "error") => Result.Result<never, "error"> (+1 overload)
    fail
    ('error'),
    import Result
    Result
    .
    const andThen: <Result.Result<never, "error">, Result.Result<number, never>>(fn: (a: never) => Result.Result<number, never>) => (result: Result.Result<never, "error">) => Result.Result<number, "error"> (+1 overload)
    andThen
    ((
    x: never
    x
    ) =>
    import Result
    Result
    .
    const succeed: <number>(value: number) => Result.Result<number, never> (+1 overload)
    succeed
    (
    x: never
    x
    * 2)),
    ); // result: { type: 'Failure', error: 'error' }
    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.Result<never, string>
    result
    =
    import Result
    Result
    .
    const pipe: <Result.Result<3, never>, Result.Result<never, string>>(a: Result.Result<3, never>, ab: (a: Result.Result<3, never>) => Result.Result<never, string>) => Result.Result<never, string> (+25 overloads)
    pipe
    (
    import Result
    Result
    .
    const succeed: <3>(value: 3) => Result.Result<3, never> (+1 overload)
    succeed
    (3),
    import Result
    Result
    .
    const andThen: <Result.Result<3, never>, Result.Result<never, string>>(fn: (a: 3) => Result.Result<never, string>) => (result: Result.Result<3, never>) => Result.Result<never, string> (+1 overload)
    andThen
    ((
    x: 3
    x
    ) =>
    import Result
    Result
    .
    const fail: <string>(error: string) => Result.Result<never, string> (+1 overload)
    fail
    ('error: ' +
    x: 3
    x
    )),
    ); // result: { type: 'Failure', error: 'error: 3' }

    #See

    pipe - It is recommended to use this function with the pipe function for better readability and composability.

    #Call Signature

    andThen<R1, R2>(fn): (result) => ResultFor<R1 | R2, InferSuccess<R2>, InferFailure<R1> | InferFailure<R2>>

    Defined in: functions/and-then.ts:55

    #Type Parameters

    #R1

    R1 extends ResultMaybeAsync<any, any>

    #R2

    R2 extends ResultMaybeAsync<any, any>

    #Parameters

    #fn

    (a) => R2

    #Returns

    (result): ResultFor<R1 | R2, InferSuccess<R2>, InferFailure<R1> | InferFailure<R2>>

    #Parameters

    #result

    R1

    #Returns

    ResultFor<R1 | R2, InferSuccess<R2>, InferFailure<R1> | InferFailure<R2>>

    #Call Signature

    andThen<F>(fn): <R1>(result) => ResultFor<R1 | ReturnType<F>, InferSuccess<F>, InferFailure<R1> | InferFailure<F>>

    Defined in: functions/and-then.ts:56

    #Type Parameters

    #F

    F extends (a) => ResultMaybeAsync<any, any>

    #Parameters

    #fn

    F

    #Returns

    <R1>(result): ResultFor<R1 | ReturnType<F>, InferSuccess<F>, InferFailure<R1> | InferFailure<F>>

    #Type Parameters

    #R1

    R1 extends ResultMaybeAsync<Parameters<F>[0], any>

    #Parameters

    #result

    R1

    #Returns

    ResultFor<R1 | ReturnType<F>, InferSuccess<F>, InferFailure<R1> | InferFailure<F>>