Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Result<ValueT, ErrorT>

Type Parameters

  • ValueT

  • ErrorT

Hierarchy

Index

Constructors

  • new Result<ValueT, ErrorT>(_success: boolean, _value: ValueT | ErrorT): Result<ValueT, ErrorT>

Properties

_success: boolean
_value: ValueT | ErrorT

Methods

  • amap<B>(mapping: Result<((value: ValueT) => B), ErrorT>): Result<B, ErrorT>
  • catch<NewErrorT>(mapping: ((value: ErrorT) => ValueT)): Result<ValueT, NewErrorT>
  • If Err this runs the mapping from ErrorT => ValueT, otherwise it returns a new Result containing ValueT

    Type Parameters

    • NewErrorT

    Parameters

    • mapping: ((value: ErrorT) => ValueT)
        • (value: ErrorT): ValueT
        • Parameters

          • value: ErrorT

          Returns ValueT

    Returns Result<ValueT, NewErrorT>

  • catchThen<NewErrorT>(mapping: ((value: ErrorT) => Result<ValueT, NewErrorT>)): Result<ValueT, NewErrorT>
  • If Err this runs the mapping from ErrorT => Result<ValueT, NewErrorT>, otherwise it returns a new Result containing ValueT

    Type Parameters

    • NewErrorT

    Parameters

    • mapping: ((value: ErrorT) => Result<ValueT, NewErrorT>)
        • (value: ErrorT): Result<ValueT, NewErrorT>
        • Parameters

          • value: ErrorT

          Returns Result<ValueT, NewErrorT>

    Returns Result<ValueT, NewErrorT>

  • map<B>(mapping: ((value: ValueT) => B)): Result<B, ErrorT>
  • If Ok, this uses the mapping function to transform Value to a new Value, and returns Result<New Value, ErrorT> otherwise it propagates the ErrorT.

    Type Parameters

    • B

    Parameters

    • mapping: ((value: ValueT) => B)
        • (value: ValueT): B
        • Parameters

          • value: ValueT

          Returns B

    Returns Result<B, ErrorT>

  • or<B>(defaultValue: B): ValueT | B
  • Returns the ValueT if Ok, otherwise it returns defaultValue

    Type Parameters

    • B

    Parameters

    • defaultValue: B

    Returns ValueT | B

  • pure<B>(value: B): Result<B, ValueT>
  • then<B>(mapping: ((value: ValueT) => Result<B, ErrorT>)): Result<B, ErrorT>
  • If Ok, the mapping of ValueT to a Result is run, otherwise the Error is propagated. If you want to just transform ValueT to a new Value, use .map

    Type Parameters

    • B

    Parameters

    • mapping: ((value: ValueT) => Result<B, ErrorT>)
        • (value: ValueT): Result<B, ErrorT>
        • Parameters

          • value: ValueT

          Returns Result<B, ErrorT>

    Returns Result<B, ErrorT>

  • unwrap(): ValueT
  • Returns the ValueT if Ok, otherwise it throws ErrorT. This is the nuclear option, .or(default) should be preferred.

    Returns ValueT

  • liftToApplicative<A, B, C, App>(fn: ((value: A) => ((value: B) => C))): ((a: CallHKT<App, A>) => ((b: CallHKT<App, B>) => CallHKT<App, C>))
  • wrap<FnT, ErrorT>(fn: FnT): ((...args: Parameters<FnT>) => Result<ReturnType<FnT>, ErrorT>)
  • Used to wrap a potential error throwing function into a safe Result wrapped function. Usage looks like:

    const safeJsonParse = Result.wrap<typeof JSON.parse, SyntaxError>(JSON.parse)
    

    Type Parameters

    • FnT extends ((...args: any[]) => any)

    • ErrorT

    Parameters

    • fn: FnT

    Returns ((...args: Parameters<FnT>) => Result<ReturnType<FnT>, ErrorT>)

      • (...args: Parameters<FnT>): Result<ReturnType<FnT>, ErrorT>
      • Parameters

        • Rest ...args: Parameters<FnT>

        Returns Result<ReturnType<FnT>, ErrorT>

Generated using TypeDoc