byethrow
  • English

      • 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

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

      Failure Case (input is a Failure)

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

      Failure Case (function returns a Failure)

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

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

      Call Signature

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

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