byethrow
  • English

      • Function: orThrough()

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

      If the original result is a Success, it is returned immediately without running the function. If the original result is a Failure, the function is executed with the error value. If the function returns a Success, the original failure is returned. If the function returns a Failure, that new failure is returned.

      Useful for running error recovery or fallback logic while preserving the original error 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, never>
      result       = 
      import Result
      Result      .
      const pipe: <Result.Result<5, never>, Result.Result<5, never>>(a: Result.Result<5, never>, ab: (a: Result.Result<5, never>) => Result.Result<5, never>) => Result.Result<5, never> (+25 overloads)
      pipe      (      
  
      import Result
      Result      .
      const succeed: <5>(value: 5) => Result.Result<5, never> (+1 overload)
      succeed      (5),      
  
      import Result
      Result      .
      const orThrough: <Result.Result<5, never>, Result.Result<null, never>>(fn: (a: never) => Result.Result<null, never>) => (result: Result.Result<5, never>) => Result.Result<5, never> (+1 overload)
      orThrough      ((
      error: never
      error      ) => {      
    return 
      import Result
      Result      .
      const succeed: <null>(value: null) => Result.Result<null, never> (+1 overload)
      succeed      (null);      
  }),
);
// { type: 'Success', value: 5 }

      Failure Case (function returns a Success)

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

const 
      const result: Result.Result<never, "error">
      result       = 
      import Result
      Result      .
      const pipe: <Result.Result<never, "error">, Result.Result<never, "error">>(a: Result.Result<never, "error">, ab: (a: Result.Result<never, "error">) => Result.Result<never, "error">) => Result.Result<never, "error"> (+25 overloads)
      pipe      (      
  
      import Result
      Result      .
      const fail: <"error">(error: "error") => Result.Result<never, "error"> (+1 overload)
      fail      ('error'),      
  
      import Result
      Result      .
      const orThrough: <Result.Result<never, "error">, Result.Result<null, never>>(fn: (a: "error") => Result.Result<null, never>) => (result: Result.Result<never, "error">) => Result.Result<never, "error"> (+1 overload)
      orThrough      ((
      error: "error"
      error      ) => {      
    
      var console: Console
      console      .
      Console.log(...data: any[]): void
      The console.log() static method outputs a message to the console.
      

      MDN Reference
      log      ('Logging error:', 
      error: "error"
      error      );      
    return 
      import Result
      Result      .
      const succeed: <null>(value: null) => Result.Result<null, never> (+1 overload)
      succeed      (null);      
  }),
);
// { type: 'Failure', error: 'error' }

      Failure Case (function returns a Failure)

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

const 
      const result: Result.Result<never, "original error" | "new error">
      result       = 
      import Result
      Result      .
      const pipe: <Result.Result<never, "original error">, Result.Result<never, "original error" | "new error">>(a: Result.Result<never, "original error">, ab: (a: Result.Result<never, "original error">) => Result.Result<never, "original error" | "new error">) => Result.Result<never, "original error" | "new error"> (+25 overloads)
      pipe      (      
  
      import Result
      Result      .
      const fail: <"original error">(error: "original error") => Result.Result<never, "original error"> (+1 overload)
      fail      ('original error'),      
  
      import Result
      Result      .
      const orThrough: <Result.Result<never, "original error">, Result.Result<never, "new error">>(fn: (a: "original error") => Result.Result<never, "new error">) => (result: Result.Result<never, "original error">) => Result.Result<never, "original error" | "new error"> (+1 overload)
      orThrough      ((
      error: "original error"
      error      ) => {      
    return 
      import Result
      Result      .
      const fail: <"new error">(error: "new error") => Result.Result<never, "new error"> (+1 overload)
      fail      ('new error');      
  }),
);
// { type: 'Failure', error: 'new error' }

      See

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

      Call Signature

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

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