Class Result

Result with static functions

Since

v2.0.0

Index

Properties

asyncFlow flow

Methods

all asyncAll from match safeAsyncCall safeCall wrapAsyncFn wrapFn

Properties

`Static` `Readonly`asyncFlow

asyncFlow: {
    <A extends Res>(v: A | Promise<A>): Promise<A>;
    <A extends Res, B extends Res>(
        v: A | Promise<A>,
        f0: Fn<A, B>,
    ): Promise<Out<[A, B]>>;
    <A extends Res, B extends Res, C extends Res>(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
    ): Promise<Out<[A, B, C]>>;
    <A extends Res, B extends Res, C extends Res, D extends Res>(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
    ): Promise<Out<[A, B, C, D]>>;
    <A extends Res, B extends Res, C extends Res, D extends Res, E extends Res>(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
    ): Promise<Out<[A, B, C, D, E]>>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
    >(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
    ): Promise<Out<[A, B, C, D, E, F]>>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
    >(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
    ): Promise<Out<[A, B, C, D, E, F, G]>>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
    >(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
    ): Promise<Out<[A, B, C, D, E, F, G, H]>>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
        I extends Res,
    >(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
        f7: Fn<H, I>,
    ): Promise<Out<[A, B, C, D, E, F, G, H, I]>>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
        I extends Res,
        J extends Res,
    >(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
        f7: Fn<H, I>,
        f8: Fn<I, J>,
    ): Promise<Out<[A, B, C, D, E, F, G, H, I, J]>>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
        I extends Res,
        J extends Res,
        K extends Res,
    >(
        v: A | Promise<A>,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
        f7: Fn<H, I>,
        f8: Fn<I, J>,
        f9: Fn<J, K>,
    ): Promise<Out<[A, B, C, D, E, F, G, H, I, J, K]>>;
} = resultAsyncFlow

Run a flow of async and sync callback results

Type declaration

- <A extends Res>(v: A | Promise<A>): Promise<A>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  Parameters
  - v: A | Promise<A>
    initial result
  Returns Promise<A>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res>(
  v: A | Promise<A>,
  f0: Fn<A, B>,
  ): Promise<Out<[A, B]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  Returns Promise<Out<[A, B]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res, C extends Res>(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
  ): Promise<Out<[A, B, C]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  Returns Promise<Out<[A, B, C]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res, C extends Res, D extends Res>(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
  ): Promise<Out<[A, B, C, D]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  Returns Promise<Out<[A, B, C, D]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res, C extends Res, D extends Res, E extends Res>(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
  ): Promise<Out<[A, B, C, D, E]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  Returns Promise<Out<[A, B, C, D, E]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
  >(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
  ): Promise<Out<[A, B, C, D, E, F]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  Returns Promise<Out<[A, B, C, D, E, F]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
  >(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
  ): Promise<Out<[A, B, C, D, E, F, G]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  Returns Promise<Out<[A, B, C, D, E, F, G]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
  >(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
  ): Promise<Out<[A, B, C, D, E, F, G, H]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  Returns Promise<Out<[A, B, C, D, E, F, G, H]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
      I extends Res,
  >(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
      f7: Fn<H, I>,
  ): Promise<Out<[A, B, C, D, E, F, G, H, I]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  - I extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  - f7: Fn<H, I>
  Returns Promise<Out<[A, B, C, D, E, F, G, H, I]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
      I extends Res,
      J extends Res,
  >(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
      f7: Fn<H, I>,
      f8: Fn<I, J>,
  ): Promise<Out<[A, B, C, D, E, F, G, H, I, J]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  - I extends Res
  - J extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  - f7: Fn<H, I>
  - f8: Fn<I, J>
  Returns Promise<Out<[A, B, C, D, E, F, G, H, I, J]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
      I extends Res,
      J extends Res,
      K extends Res,
  >(
      v: A | Promise<A>,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
      f7: Fn<H, I>,
      f8: Fn<I, J>,
      f9: Fn<J, K>,
  ): Promise<Out<[A, B, C, D, E, F, G, H, I, J, K]>>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  - I extends Res
  - J extends Res
  - K extends Res
  Parameters
  - v: A | Promise<A>
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  - f7: Fn<H, I>
  - f8: Fn<I, J>
  - f9: Fn<J, K>
  Returns Promise<Out<[A, B, C, D, E, F, G, H, I, J, K]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1

Template: A

type of the initial result

Param: v

initial result

Returns

as final result

Throws

if uncontrolled error from callback

Example

const res: Promise<IResult<string>> = resultAsyncFlow(
  Ok('hello'),
  (value) => Promise.resolve(Ok(`${value} world`)),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);

Since

v2.0.0

`Static` `Readonly`flow

flow: {
    <A extends Res>(v: A): A;
    <A extends Res, B extends Res>(v: A, f0: Fn<A, B>): Out<[A, B]>;
    <A extends Res, B extends Res, C extends Res>(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
    ): Out<[A, B, C]>;
    <A extends Res, B extends Res, C extends Res, D extends Res>(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
    ): Out<[A, B, C, D]>;
    <A extends Res, B extends Res, C extends Res, D extends Res, E extends Res>(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
    ): Out<[A, B, C, D, E]>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
    >(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
    ): Out<[A, B, C, D, E, F]>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
    >(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
    ): Out<[A, B, C, D, E, F, G]>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
    >(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
    ): Out<[A, B, C, D, E, F, G, H]>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
        I extends Res,
    >(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
        f7: Fn<H, I>,
    ): Out<[A, B, C, D, E, F, G, H, I]>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
        I extends Res,
        J extends Res,
    >(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
        f7: Fn<H, I>,
        f8: Fn<I, J>,
    ): Out<[A, B, C, D, E, F, G, H, I, J]>;
    <
        A extends Res,
        B extends Res,
        C extends Res,
        D extends Res,
        E extends Res,
        F extends Res,
        G extends Res,
        H extends Res,
        I extends Res,
        J extends Res,
        K extends Res,
    >(
        v: A,
        f0: Fn<A, B>,
        f1: Fn<B, C>,
        f2: Fn<C, D>,
        f3: Fn<D, E>,
        f4: Fn<E, F>,
        f5: Fn<F, G>,
        f6: Fn<G, H>,
        f7: Fn<H, I>,
        f8: Fn<I, J>,
        f9: Fn<J, K>,
    ): Out<[A, B, C, D, E, F, G, H, I, J, K]>;
} = resultFlow

Run a flow of callback results

Type declaration

- <A extends Res>(v: A): A
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  Parameters
  - v: A
    initial result
  Returns A
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res>(v: A, f0: Fn<A, B>): Out<[A, B]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  Returns Out<[A, B]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res, C extends Res>(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
  ): Out<[A, B, C]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  Returns Out<[A, B, C]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res, C extends Res, D extends Res>(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
  ): Out<[A, B, C, D]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  Returns Out<[A, B, C, D]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <A extends Res, B extends Res, C extends Res, D extends Res, E extends Res>(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
  ): Out<[A, B, C, D, E]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  Returns Out<[A, B, C, D, E]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
  >(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
  ): Out<[A, B, C, D, E, F]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  Returns Out<[A, B, C, D, E, F]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
  >(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
  ): Out<[A, B, C, D, E, F, G]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  Returns Out<[A, B, C, D, E, F, G]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
  >(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
  ): Out<[A, B, C, D, E, F, G, H]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  Returns Out<[A, B, C, D, E, F, G, H]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
      I extends Res,
  >(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
      f7: Fn<H, I>,
  ): Out<[A, B, C, D, E, F, G, H, I]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  - I extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  - f7: Fn<H, I>
  Returns Out<[A, B, C, D, E, F, G, H, I]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
      I extends Res,
      J extends Res,
  >(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
      f7: Fn<H, I>,
      f8: Fn<I, J>,
  ): Out<[A, B, C, D, E, F, G, H, I, J]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  - I extends Res
  - J extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  - f7: Fn<H, I>
  - f8: Fn<I, J>
  Returns Out<[A, B, C, D, E, F, G, H, I, J]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1
- <
      A extends Res,
      B extends Res,
      C extends Res,
      D extends Res,
      E extends Res,
      F extends Res,
      G extends Res,
      H extends Res,
      I extends Res,
      J extends Res,
      K extends Res,
  >(
      v: A,
      f0: Fn<A, B>,
      f1: Fn<B, C>,
      f2: Fn<C, D>,
      f3: Fn<D, E>,
      f4: Fn<E, F>,
      f5: Fn<F, G>,
      f6: Fn<G, H>,
      f7: Fn<H, I>,
      f8: Fn<I, J>,
      f9: Fn<J, K>,
  ): Out<[A, B, C, D, E, F, G, H, I, J, K]>
- Run a flow of results
  Type Parameters
  - A extends Res
    type of the initial result
  - B extends Res
  - C extends Res
  - D extends Res
  - E extends Res
  - F extends Res
  - G extends Res
  - H extends Res
  - I extends Res
  - J extends Res
  - K extends Res
  Parameters
  - v: A
    initial result
  - f0: Fn<A, B>
  - f1: Fn<B, C>
  - f2: Fn<C, D>
  - f3: Fn<D, E>
  - f4: Fn<E, F>
  - f5: Fn<F, G>
  - f6: Fn<G, H>
  - f7: Fn<H, I>
  - f8: Fn<I, J>
  - f9: Fn<J, K>
  Returns Out<[A, B, C, D, E, F, G, H, I, J, K]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);
```
  Since
  v1.2.1

Example

const res: IResult<string> = resultFlow(
  Ok('hello'),
  (value) => Ok(`${value} world`),
  (value) => Ok(value.length),
  (value) => Ok(value.toString()),
);

Template: A

type of the initial result

Param: v

initial result

Returns

as final result

Throws

if uncontrolled error from callback

Since

v2.0.0

Methods

`Static`all

all<T extends any[]>(
...args: AllArgs<T>,
): IResult<ExtractAllOkArray<T>, ExtractAllErrType<T[number]>>
Resolve all results to single IOk array result or IErr
Type Parameters
- T extends any[]
Parameters
- ...args: AllArgs<T>
  Array of IResult or Functions return IResult
Returns IResult<ExtractAllOkArray<T>, ExtractAllErrType<T[number]>>
- returns IOk or IErr
Example
```
const test1 = (): IResult<string, Error> => Ok('hello');
const test2 = (): IResult<number, Error> => Ok(10);
const output: IResult<[string, number], Error> = Result.all(test1, test2);
```
Since
v2.0.0
- Defined in src/result/Result.mts:114

`Static`asyncAll

asyncAll<T extends any[]>(
...args: AllAsyncArgs<T>,
): Promise<IResult<ExtractAllOkArray<T>, ExtractAllErrType<T[number]>>>
Resolve all possible async results to single IOk array result or IErr (like Promise.all but returns as result Result)
Type Parameters
- T extends any[]
Parameters
- ...args: AllAsyncArgs<T>
  Array of async IResult or Functions return async IResult
Returns Promise<IResult<ExtractAllOkArray<T>, ExtractAllErrType<T[number]>>>
- returns Promise of IOk or IErr
Example
```
const test1 = (): Promise<IResult<string, Error>> => Promise.resolve(Ok('hello'));
const test2 = (): Promise<IResult<number, Error>> => Promise.resolve(Ok(10));
const output: IResult<[string, number], Error> = await Result.all(test1, test2);
```
Since
v2.0.0
- Defined in src/result/Result.mts:136

`Static`from

from<OkType = unknown, ErrType = unknown>(
value: IOk<OkType> | IErr<ErrType> | IJsonOk<OkType> | IJsonErr<ErrType>,
): IResult<OkType, ErrType>
Build IResult from IResult or IJsonResult.
Type Parameters
- OkType = unknown
  return type
- ErrType = unknown
  error type
Parameters
- value: IOk<OkType> | IErr<ErrType> | IJsonOk<OkType> | IJsonErr<ErrType>
  any IResult or JsonResult as IResult
Returns IResult<OkType, ErrType>
IResult

Since
v2.0.0
- Defined in src/result/Result.mts:94

`Static`match

match<OkType, ErrType, OkOutput, ErrOutput>(
    result: IResult<OkType, ErrType>,
    solver: {
        Err: (err: ErrType) => ErrOutput;
        Ok: (value: OkType) => OkOutput;
    },
): OkOutput
| ErrOutput
function to match the value or error
Type Parameters
- OkType
  Ok type
- ErrType
  Err type
- OkOutput
  output type from Ok
- ErrOutput
  output type from Err
Parameters
- result: IResult<OkType, ErrType>
  result to match
- solver: { Err: (err: ErrType) => ErrOutput; Ok: (value: OkType) => OkOutput }
  solver callback
Returns OkOutput | ErrOutput
output
Example
```
Result.match(Ok<number>(2), {
	Ok: (value) => value * 2,
	Err: (err) => 0
}) // 4
Result.match(Err<number>(2), {
	Ok: (value) => value * 2,
	Err: (err) => 0
}) // 0
```
Since
v2.0.0
- Defined in src/result/Result.mts:224

`Static`safeAsyncCall

safeAsyncCall<OkType, ErrType>(
func: () => | IResultOrOkType<OkType, ErrType>
| Promise<IResultOrOkType<OkType, ErrType>>,
): Promise<IResult<OkType, ErrType>>
Async function to match the value or error with try catch
Type Parameters
- OkType
  Ok type
- ErrType
  Err type
Parameters
- func: () => | IResultOrOkType<OkType, ErrType>
  | Promise<IResultOrOkType<OkType, ErrType>>
  callback function
Returns Promise<IResult<OkType, ErrType>>
result
Example
```
const result = await Result.safeAsyncCall<unknown, SyntaxError>(() => JSON.parse('{ "hello": "world" }'));
```
Since
v2.0.1
- Defined in src/result/Result.mts:270

`Static`safeCall

safeCall<OkType, ErrType>(
func: () => IResultOrOkType<OkType, ErrType>,
): IResult<OkType, ErrType>
Function to match the value or error with try catch
Type Parameters
- OkType
  Ok type
- ErrType
  Err type
Parameters
- func: () => IResultOrOkType<OkType, ErrType>
  callback function
Returns IResult<OkType, ErrType>
result
Example
```
const result = Result.safeCall<unknown, SyntaxError>(() => JSON.parse('{ "hello": "world" }'));
```
Since
v2.0.1
- Defined in src/result/Result.mts:248

`Static`wrapAsyncFn

wrapAsyncFn<TArgs extends any[], OkType, ErrType>(
func: (...args: TArgs) => Promise<IResultOrOkType<OkType, ErrType>>,
): (...args: TArgs) => Promise<IResult<OkType, ErrType>>
build safe Result wrapper for async callback function
Type Parameters
- TArgs extends any[]
  function arguments
- OkType
  return type
- ErrType
  error type
Parameters
- func: (...args: TArgs) => Promise<IResultOrOkType<OkType, ErrType>>
  async Promise or callback function
Returns (...args: TArgs) => Promise<IResult<OkType, ErrType>>
wrapped function which returns Result Promise
Example
```
const writeFile = Result.wrapAsyncFn<Parameters<typeof fs.promises.writeFile>, void, Error>(fs.promises.writeFile);
const result: IResult<void, Error> = await writeFile('test.txt', 'hello world');
```
Since
v2.0.0
- Defined in src/result/Result.mts:191

`Static`wrapFn

wrapFn<TArgs extends any[], OkType, ErrType>(
func: (...args: TArgs) => IResultOrOkType<OkType, ErrType>,
): (...args: TArgs) => IResult<OkType, ErrType>
build safe Result wrapper for callback function
Type Parameters
- TArgs extends any[]
  function arguments
- OkType
  return type
- ErrType
  error type
Parameters
- func: (...args: TArgs) => IResultOrOkType<OkType, ErrType>
  callback function
Returns (...args: TArgs) => IResult<OkType, ErrType>
wrapped function which returns Result
Example
```
const hello = Result.wrapFn((value: string) => `${value} world`);
// hello: (value: string) => IResult<string, unknown>
// example of strict generics usage (to set correct error type)
const jsonParse = Result.wrapFn<Parameters<typeof JSON.parse>, ReturnType<typeof JSON.parse>, SyntaxError>(JSON.parse);
const res: IResult<any, SyntaxError> = jsonParse('{ "hello": "world" }');
```
Since
v2.0.0
- Defined in src/result/Result.mts:163

Class Result

Since

Index

Properties

Methods

Properties

Static ReadonlyasyncFlow

Type declaration

Type Parameters

Parameters

Returns Promise<A>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D, E]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D, E, F]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D, E, F, G]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D, E, F, G, H]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D, E, F, G, H, I]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D, E, F, G, H, I, J]>>

Throws

Example

Since

Type Parameters

Parameters

Returns Promise<Out<[A, B, C, D, E, F, G, H, I, J, K]>>

Throws

Example

Since

Template: A

Param: v

Returns

Throws

Example

Since

`Static` `Readonly`asyncFlow

`Static` `Readonly`flow