logo
byethrow
Guide
Examples
API Reference
Guide
Examples
API Reference
logo
byethrow
@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: combine()
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: succeed()
Function: try()
Function: unwrap()
Function: unwrapError()

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