byethrow
  • English

      • 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

      R1

      The input Result or ResultAsync.

      Type Param

      R2

      The result type returned by fn.

      Examples

      Success Case

      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 }

      Failure Case (input is a Failure)

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

      Failure Case (function returns a Failure)

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

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