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 pageFunction: andThen()Next pageFunction: assertFailure()

    #Function: andThrough()

    Runs an additional computation using the success value of a Result or ResultAsync, but returns the original result if the additional computation is successful.

    If either the original result or the side effect result is a Failure, that failure is returned. Useful for running validations or side effects without altering the main result on success.

    #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<5, "Must be > 0">
    result
    =
    import Result
    Result
    .
    const pipe: <Result.Result<5, never>, Result.Result<5, "Must be > 0">>(a: Result.Result<5, never>, ab: (a: Result.Result<5, never>) => Result.Result<5, "Must be > 0">) => Result.Result<5, "Must be > 0"> (+25 overloads)
    pipe
    (
    import Result
    Result
    .
    const succeed: <5>(value: 5) => Result.Result<5, never> (+1 overload)
    succeed
    (5),
    import Result
    Result
    .
    const andThrough: <Result.Result<5, never>, Result.Success<null> | Result.Failure<"Must be > 0">>(fn: (a: 5) => Result.Success<null> | Result.Failure<"Must be > 0">) => (result: Result.Result<5, never>) => Result.Result<5, "Must be > 0"> (+1 overload)
    andThrough
    ((
    x: 5
    x
    ) => {
    return
    x: 5
    x
    > 0 ?
    import Result
    Result
    .
    const succeed: <null>(value: null) => Result.Result<null, never> (+1 overload)
    succeed
    (null) :
    import Result
    Result
    .
    const fail: <"Must be > 0">(error: "Must be > 0") => Result.Result<never, "Must be > 0"> (+1 overload)
    fail
    ('Must be > 0');
    }), ); // { type: 'Success', value: 5 }
    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.Result<never, "error" | "Must be > 0">
    result
    =
    import Result
    Result
    .
    const pipe: <Result.Result<never, "error">, Result.Result<never, "error" | "Must be > 0">>(a: Result.Result<never, "error">, ab: (a: Result.Result<never, "error">) => Result.Result<never, "error" | "Must be > 0">) => Result.Result<never, "error" | "Must be > 0"> (+25 overloads)
    pipe
    (
    import Result
    Result
    .
    const fail: <"error">(error: "error") => Result.Result<never, "error"> (+1 overload)
    fail
    ('error'),
    import Result
    Result
    .
    const andThrough: <Result.Result<never, "error">, Result.Success<null> | Result.Failure<"Must be > 0">>(fn: (a: never) => Result.Success<null> | Result.Failure<"Must be > 0">) => (result: Result.Result<never, "error">) => Result.Result<never, "error" | "Must be > 0"> (+1 overload)
    andThrough
    ((
    x: never
    x
    ) => {
    return
    x: never
    x
    > 0 ?
    import Result
    Result
    .
    const succeed: <null>(value: null) => Result.Result<null, never> (+1 overload)
    succeed
    (null) :
    import Result
    Result
    .
    const fail: <"Must be > 0">(error: "Must be > 0") => Result.Result<never, "Must be > 0"> (+1 overload)
    fail
    ('Must be > 0');
    }), ); // { type: 'Failure', error: 'error' }
    import { 
    import Result
    Result
    } from '@praha/byethrow';
    const
    const result: Result.Result<-10, "Must be > 0">
    result
    =
    import Result
    Result
    .
    const pipe: <Result.Result<-10, never>, Result.Result<-10, "Must be > 0">>(a: Result.Result<-10, never>, ab: (a: Result.Result<-10, never>) => Result.Result<-10, "Must be > 0">) => Result.Result<-10, "Must be > 0"> (+25 overloads)
    pipe
    (
    import Result
    Result
    .
    const succeed: <-10>(value: -10) => Result.Result<-10, never> (+1 overload)
    succeed
    (-10),
    import Result
    Result
    .
    const andThrough: <Result.Result<-10, never>, Result.Success<null> | Result.Failure<"Must be > 0">>(fn: (a: -10) => Result.Success<null> | Result.Failure<"Must be > 0">) => (result: Result.Result<-10, never>) => Result.Result<-10, "Must be > 0"> (+1 overload)
    andThrough
    ((
    x: -10
    x
    ) => {
    return
    x: -10
    x
    > 0 ?
    import Result
    Result
    .
    const succeed: <null>(value: null) => Result.Result<null, never> (+1 overload)
    succeed
    (null) :
    import Result
    Result
    .
    const fail: <"Must be > 0">(error: "Must be > 0") => Result.Result<never, "Must be > 0"> (+1 overload)
    fail
    ('Must be > 0');
    }), ); // { type: 'Failure', error: 'Must be > 0' }

    #See

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

    #Call Signature

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

    Defined in: functions/and-through.ts:63

    #Type Parameters

    #R1

    R1 extends ResultMaybeAsync<any, any>

    #R2

    R2 extends ResultMaybeAsync<any, any>

    #Parameters

    #fn

    (a) => R2

    #Returns

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

    #Parameters

    #result

    R1

    #Returns

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

    #Call Signature

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

    Defined in: functions/and-through.ts:64

    #Type Parameters

    #F

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

    #Parameters

    #fn

    F

    #Returns

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

    #Type Parameters

    #R1

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

    #Parameters

    #result

    R1

    #Returns

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