@luolapeikko/result-option
    Preparing search index...

    Interface IResultBuild<IsOk, OkType, ErrType>

    Result builder interface

    v1.0.0

    interface IResultBuild<IsOk = true, OkType = unknown, ErrType = unknown> {
        isErr: IsOk extends false ? true : false;
        isOk: IsOk;
        and<CompareType>(
            value: IResult<CompareType>,
        ): IsOk extends true
            ? IResult<CompareType, unknown>
            : IResultBuild<IsOk, OkType, ErrType>;
        andThen<OutResult extends IResult<unknown, unknown>>(
            callbackFunc: (val: IsOk extends true ? OkType : never) => OutResult,
        ): IsOk extends true ? OutResult : IResultBuild<IsOk, OkType, ErrType>;
        andThenPromise<OutResult extends IResult<unknown, unknown>>(
            callbackFunc: (
                val: IsOk extends true ? OkType : never,
            ) => Promise<OutResult>,
        ): IsOk extends true
            ? Promise<OutResult>
            : IResultBuild<IsOk, OkType, ErrType>;
        clone(): IResultBuild<IsOk, OkType, ErrType>;
        eq(other: IResult): boolean;
        err(): IsOk extends false ? ErrType : undefined;
        inspect(fn: (value: OkType) => void): this;
        inspectErr(fn: (value: ErrType) => void): this;
        isErrAnd(
            callbackFunc: (value: ErrType) => boolean,
        ): IsOk extends false ? boolean : false;
        isOkAnd(
            callbackFunc: (value: OkType) => boolean,
        ): IsOk extends true ? boolean : false;
        iter(): IterableIterator<
            IsOk extends true ? IResultBuild<IsOk, OkType, ErrType> : INone,
            IsOk extends true ? IResultBuild<IsOk, OkType, ErrType> : INone,
        >;
        map<NewOkType>(
            fn: (value: OkType) => NewOkType,
        ): IsOk extends true ? IOk<NewOkType> : IResultBuild<IsOk, OkType, ErrType>;
        mapErr<NewErrType>(
            fn: (value: ErrType) => NewErrType,
        ): IsOk extends true
            ? IResultBuild<IsOk, OkType, ErrType>
            : IErr<NewErrType>;
        ok(): IsOk extends true ? OkType : undefined;
        or<CompareType>(
            value: IResult<CompareType>,
        ): IsOk extends true
            ? IResultBuild<IsOk, OkType, ErrType>
            : IResult<CompareType, unknown>;
        orElse<OutResult extends IResult<unknown, unknown>>(
            callbackFunc: (value: IsOk extends true ? never : ErrType) => OutResult,
        ): IsOk extends true ? IResultBuild<IsOk, OkType, ErrType> : OutResult;
        orElsePromise<OutResult extends IResult<unknown, unknown>>(
            callbackFunc: (
                value: IsOk extends true ? never : ErrType,
            ) => Promise<OutResult>,
        ): IsOk extends true
            ? IResultBuild<IsOk, OkType, ErrType>
            : Promise<OutResult>;
        toJSON(): IsOk extends true ? IJsonOk<OkType> : IJsonErr<ErrType>;
        toOption(): IsOk extends true ? ISome<OkType> : INone<never>;
        toString(): IsOk extends true ? `Ok(${string})` : `Err(${string})`;
        unwrap(): IsOk extends true ? OkType : never;
        unwrapOr<DefaultType>(
            defaultValue: DefaultType,
        ): IsOk extends true ? OkType : DefaultType;
        unwrapOrElse<DefaultType>(
            callbackFunc: () => DefaultType,
        ): IsOk extends true ? OkType : DefaultType;
        unwrapOrValueOf<ValueType>(
            BaseConstructor: ConstructorWithValueOf<ValueType>,
        ): IsOk extends true ? OkType : ValueType;
    }

    Type Parameters

    • IsOk = true
    • OkType = unknown
    • ErrType = unknown

    Implemented by

    Index

    Properties

    isErr: IsOk extends false ? true : false

    Check that result is an error

    true if result is an error

    Ok<number>(2).isErr // false
    Err<Error>(new Error('broken')).isErr // true
    isOk: IsOk

    Check that result is not an error

    true if result is not an error

    Ok<number>(2).isOk // true
    Err<Error>(new Error('broken')).isOk // false

    Methods

    • Method to combine two results, if the first result is true use the value to build a new result from Promise, otherwise return the error

      Type Parameters

      • OutResult extends IResult<unknown, unknown>

      Parameters

      • callbackFunc: (val: IsOk extends true ? OkType : never) => Promise<OutResult>

        callback to build a new result

      Returns IsOk extends true ? Promise<OutResult> : IResultBuild<IsOk, OkType, ErrType>

      • Result based on the self value and the value parameter
      await Ok<number>(2).andThen<IResult<number>>((val) => Promise.resolve(Ok(val + 1))) // Ok<number>(3)
      await Err<'broken'>('broken').andThen<IResult<number>>((val) => Promise.resolve(Ok(val + 1))) // Err<'broken'>('broken')
    • Method to compare two results

      Parameters

      • other: IResult

        other result to compare

      Returns boolean

      true if results are equal

      Ok<number>(2).eq(Ok<number>(2)) // true
      Ok<number>(2).eq(Ok<number>(3)) // false
      Err<number>(2).eq(Err<number>(2)) // true
    • Inspect the result value if Ok

      Parameters

      • fn: (value: OkType) => void

        function to inspect the value

      Returns this

      this result instance

      Ok<number>(2).inspect((value) => console.log('Value:', value)).unwrap() // logs 'Value: 2' and returns 2
      

      v1.0.8

    • Inspect the result value if Err

      Parameters

      • fn: (value: ErrType) => void

        function to inspect the error

      Returns this

      this result instance

      Err<Error>(new Error('broken')).inspectErr((err) => console.error('Error:', err)).unwrap() // logs 'Error: Error('broken')' and throws
      

      v1.0.8

    • Returns true if the result is Err and callback function returns true for the value inside of Err.

      Parameters

      • callbackFunc: (value: ErrType) => boolean

      Returns IsOk extends false ? boolean : false

      true if the result is Err and the callback function returns true for the value inside of Err

      Err<Error>(new Error('broken')).isErrAnd((err) => err.message === 'broken') // true
      Err<Error>(new Error('broken')).isErrAnd((err) => err.message === 'not broken') // false
      Ok<number>(2).isErrAnd((err) => err.message === 'broken') // false

      v1.0.8

    • Returns true if the result is Ok and callback function returns true for the value inside of Ok.

      Parameters

      • callbackFunc: (value: OkType) => boolean

        function to check the value inside of Ok

      Returns IsOk extends true ? boolean : false

      true if the result is Ok and the callback function returns true for the value inside of Ok

      Ok<number>(2).isOkAnd((value) => value === 2) // true
      Ok<number>(2).isOkAnd((value) => value === 3) // false
      Err<Error>(new Error('broken')).isOkAnd((value) => value === 2) // false

      v1.0.8

    • Map the error value to a new value if Err

      Type Parameters

      • NewErrType

      Parameters

      Returns IsOk extends true ? IResultBuild<IsOk, OkType, ErrType> : IErr<NewErrType>

      new error result instance with mapped error

      const mapAsTypeErr = (err: Error): TypeError => new TypeError(`Mapped: ${err.message}`);
      Err<Error>(new Error('broken')).mapErr(mapAsTypeErr) // Err<TypeError>(new TypeError('Mapped: broken'))
      Ok<number>(2).mapErr(mapAsTypeErr); // Ok<number>(2)
      // error mapping and logging example
      const logErr = (err: Error) => console.error('Error:', err);
      Err<Error>(new Error('broken')).mapErr(mapAsTypeErr).inspectErr(logErr);

      v1.0.4

    • Method to combine two results, if the first result is false use the error to build a new result from Promise, otherwise return the first result

      Type Parameters

      • OutResult extends IResult<unknown, unknown>

      Parameters

      • callbackFunc: (value: IsOk extends true ? never : ErrType) => Promise<OutResult>

        callback to build a new result

      Returns IsOk extends true ? IResultBuild<IsOk, OkType, ErrType> : Promise<OutResult>

      • Result based on the self value and the value parameter
      await Ok<number>(2).orElsePromise<IResult<number>>((errValue) => Promise.resolve(Ok(errValue * 2))) // Ok<number>(2)
      await Err<number>(2).orElsePromise<IResult<number>>((errValue) => Promise.resolve(Ok(errValue * 2))) // Ok<number>(4)
    • Convert result to string

      Returns IsOk extends true ? `Ok(${string})` : `Err(${string})`

      string representation of the result

      Ok<number>(2).toString() // 'Ok(2)'
      Err<number>(2).toString() // 'Err(2)'
    • Method to unwrap the value or throw an error.

      Note: Error argument/callback was removed in favor of the .errMap((e) => new Error(e.message)).unwrap() method.

      Returns IsOk extends true ? OkType : never

      Ok<number>(2).unwrap() // 2
      Err<Error>(new Error('broken')).unwrap() // throws Error('broken')