byethrow

    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>>

    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>>

    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>>