Class Result<T, E>

Wraps the evaluation of an operation, which could either succeed with (or without) a result or fail with (or without) an error.

This class is always an immutable data structure.

See

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/

Type Parameters

Hierarchy

Result

Index

Constructors

`Private` constructor

new Result<T, E>(result: undefined | T, error: undefined | E, isSuccess: boolean): Result<T, E>
Type Parameters
- T
- E
Parameters
- result: undefined | T
- error: undefined | E
- isSuccess: boolean
Returns Result<T, E>
- Defined in src/error.ts:40

Properties

`Optional` `Readonly` error

error?: E

`Readonly` isFailure

isFailure: boolean

True if the Result represents a failure.

Will always be opposite to isSuccess.

See

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/is-failure.html

`Readonly` isSuccess

isSuccess: boolean

True if the Result represents success.

Will always be opposite to isFailure.

See

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/is-failure.html

`Optional` `Readonly` result

result?: T

Methods

errorOrUndefined

errorOrUndefined(): undefined | E
Returns the Result's error if the failed, or undefined if it succeeded.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/exception-or-null.html

Returns undefined | E
- Defined in src/error.ts:73

fold

fold<R>(args: {
onFailure: ((error: E) => R);
onSuccess: ((value: T) => R);
}): R
Map's the current Result using onSuccess or onFailure. Returns the result of the evaluation.

The function passed on onSuccess is used is used to map the current Result if it represents a success. If so, the current value is used as the value parameter.

The function passed on onFailure is used is used to map the current Result if it represents a failure. If so, the current error is used as the error parameter.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/fold.html
Type Parameters
- R
Parameters
- args: {
  onFailure: ((error: E) => R);
  onSuccess: ((value: T) => R);
  }
  - onFailure: ((error: E) => R)
    - (error: E): R
      
      Parameters
      
      error: E
      
      Returns R
  - onSuccess: ((value: T) => R)
    - (value: T): R
      
      Parameters
      
      value: T
      
      Returns R
Returns R
- Defined in src/error.ts:127

getOrDefault

getOrDefault<R>(defaultValue: R): T | R
Returns the Result's value if it succeeded, or the passed value if it failed.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/get-or-default.html
Type Parameters
- R
Parameters
- defaultValue: R
  
  The value to return in case the Result represents a failure.
Returns T | R
- Defined in src/error.ts:92

getOrElse

getOrElse<R>(onFailure: ((e: E) => R)): T | R
Returns the Result's value if it succeeded. If the result represents a failure, evaluates onFailure with the occurred error as parameter and returns the result of the evaluation.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/get-or-else.html
Type Parameters
- R
Parameters
- onFailure: ((e: E) => R)
  - - (e: E): R
    - Parameters
      
      e: E
      
      Returns R
Returns T | R
- Defined in src/error.ts:103

getOrThrow

getOrThrow(): T
Returns the Result's value if it succeeded, or throw the Result's error if it failed.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/get-or-throw.html

Returns T
- Defined in src/error.ts:112

getOrUndefined

getOrUndefined(): undefined | T
Returns the Result's value if it succeeded, or undefined if it failed.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/get-or-null.html

Returns undefined | T
- Defined in src/error.ts:82

map

map<R>(transform: ((value: T) => R)): Result<T, E> | Result<R, E>
Transforms the value of the Result if it represents a success. If not, returns the current result.

The function on transform is used to transform the value in case the result represents success. If so, the value argument of this callback function will be the current value of the Result. This operation does not mutate the current Result, instead returns a new one with the return of value wrapped.

If the current Result represents an error, the current result is returned unchanged.

If the evaluation of the transform function fails, the error will be left uncatched.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/map.html
Type Parameters
- R
Parameters
- transform: ((value: T) => R)
  
  The callback to be used to transform the current result.
  - - (value: T): R
    - Parameters
      
      value: T
      
      Returns R
Returns Result<T, E> | Result<R, E>
- Defined in src/error.ts:146

mapCatching

mapCatching<R>(transform: ((value: T) => R)): Result<T, E> | Result<R, E>
Transforms the value of the Result if it represents a failure. If not, returns the current result.

The function on transform is used to transform the value in case the result represents success. If so, the value argument of this callback function will be the current value of the Result. This operation does not mutate the current Result, instead returns a new one with the return of value wrapped.

If the current result represents an error, the current result is returned unchanged.

If the evaluation of the transform function fails, the Result returned will be a failure with the exception as it's wrapped error.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/map-catching.html
Type Parameters
- R
Parameters
- transform: ((value: T) => R)
  
  The callback to be used to transform the current result.
  - - (value: T): R
    - Parameters
      
      value: T
      
      Returns R
Returns Result<T, E> | Result<R, E>
- Defined in src/error.ts:183

mapError

mapError<RE>(transform: ((error: E) => RE)): Result<T, E> | Result<T, RE>
Transforms the error of the Result if it represents a failure. If not, returns the current result.

The function on transform is used to transform the value in case the result represents success. If so, the error argument of this callback function will be the current error of the Result. This operation does not mutate the current Result, instead returns a new one with the return of value wrapped as error.

If the current Result represents a success, the current result is returned unchanged.

If the evaluation of the transform function fails, the error will be left uncatched.
Type Parameters
- RE
Parameters
- transform: ((error: E) => RE)
  
  The callback to be used to transform the current error.
  - - (error: E): RE
    - Parameters
      
      error: E
      
      Returns RE
Returns Result<T, E> | Result<T, RE>
- Defined in src/error.ts:164

onFailure

onFailure(action: ((error: E) => void)): Result<T, E>
Executes the callback in the action parameter if the current result represents a failure. Always returns the current error unchanged, regardless of the result of the action callback.

The error parameter of the callback action is the error that the current Result is wrapping.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/on-failure.html
Parameters
- action: ((error: E) => void)
  
  The callback to be executed case the current Result represents a failure.
  - - (error: E): void
    - Parameters
      
      error: E
      
      Returns void
Returns Result<T, E>
- Defined in src/error.ts:197

onSuccess

onSuccess(action: ((value: T) => void)): Result<T, E>
Executes the callback in the action parameter if the current result represents a succeeded. Always returns the current error unchanged, regardless of the result of the action callback.

The value parameter of the callback action is the value that the current Result is wrapping.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/on-success.html
Parameters
- action: ((value: T) => void)
  
  The callback to be executed case the current Result represents a succeeded operation.
  - - (value: T): void
    - Parameters
      
      value: T
      
      Returns void
Returns Result<T, E>
- Defined in src/error.ts:210

recover

recover<R, NE>(transform: ((error: E) => R)): Result<T, E> | Result<R, NE>
Executes the callback transform if the current Result represents a failure and returns it result. Returns the current unchanged Result if it represents a success.

The error parameter of the transform callback is the error that the current Result is wrapping.

This function does not catches any errors thrown in the transform callback.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/recover.html
Type Parameters
- R
- NE = E
Parameters
- transform: ((error: E) => R)
  - - (error: E): R
    - Parameters
      
      error: E
      
      Returns R
Returns Result<T, E> | Result<R, NE>
- Defined in src/error.ts:225

recoverCatching

recoverCatching<R, NE>(transform: ((e: E) => R)): Result<T, E> | Result<R, NE>
Executes the callback transform if the current Result represents a failure and returns it result. Returns the current unchanged Result if it represents a success.

The error parameter of the transform callback is the error that the current Result is wrapping.

This function catches any errors thrown in the transform callback, and if there are any, the returned Results will be a failure with the error that was thrown wrapped in it.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/recover-catching.html
Type Parameters
- R
- NE = E
Parameters
- transform: ((e: E) => R)
  - - (e: E): R
    - Parameters
      
      e: E
      
      Returns R
Returns Result<T, E> | Result<R, NE>
- Defined in src/error.ts:239

`Static` failure

failure<E, T>(error: E): Result<T, E>
Creates a failed Result with the given error.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/failure.html
Type Parameters
- E
- T = never
Parameters
- error: E
  
  The error to use in the Result.
Returns Result<T, E>
- Defined in src/error.ts:54

`Static` success

success<T, E>(value: T): Result<T, E>
Creates a succeeded Result with the given value.

See
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/failure.html
Type Parameters
- T
- E = never
Parameters
- value: T
  
  The value to use in the Result.
Returns Result<T, E>
- Defined in src/error.ts:64

Class Result<T, E>

See

Type Parameters

T

E

Hierarchy

Index

Constructors

Properties

Methods

Constructors

Private constructor

Type Parameters

T

E

Parameters

result: undefined | T

error: undefined | E

isSuccess: boolean

Returns Result<T, E>

Properties

Optional Readonly error

Readonly isFailure

See

Readonly isSuccess

See

Optional Readonly result

Methods

errorOrUndefined

See

Returns undefined | E

fold

See

Type Parameters

R

Parameters

args: { onFailure: ((error: E) => R); onSuccess: ((value: T) => R); }

onFailure: ((error: E) => R)

Parameters

error: E

Returns R

onSuccess: ((value: T) => R)

Parameters

value: T

Returns R

Returns R

getOrDefault

See

Type Parameters

R

Parameters

defaultValue: R

Returns T | R

getOrElse

See

Type Parameters

R

Parameters

onFailure: ((e: E) => R)

Parameters

e: E

Returns R

Returns T | R

getOrThrow

See

Returns T

getOrUndefined

See

Returns undefined | T

map

See

Type Parameters

R

Parameters

transform: ((value: T) => R)

Parameters

value: T

Returns R

Returns Result<T, E> | Result<R, E>

mapCatching

`Private` constructor

`Optional` `Readonly` error

`Readonly` isFailure

`Readonly` isSuccess

`Optional` `Readonly` result

args: {
onFailure: ((error: E) => R);
onSuccess: ((value: T) => R);
}

`Static` failure

`Static` success