Class Result

Result with static functions

Since

v2.0.0

Index

Properties

asyncFlow asyncTupleFlow flow tupleFlow

Methods

all asArray asAsyncArray asyncAll asyncIterator from iterator 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`asyncTupleFlow

asyncTupleFlow: {
    <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<[A, 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<[A, B], C>,
        f2: Fn<[A, B, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, G], H>,
        f7: Fn<[A, B, C, D, E, F, G, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, G], H>,
        f7: Fn<[A, B, C, D, E, F, G, H], I>,
        f8: Fn<[A, B, C, D, E, F, G, H, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, G], H>,
        f7: Fn<[A, B, C, D, E, F, G, H], I>,
        f8: Fn<[A, B, C, D, E, F, G, H, I], J>,
        f9: Fn<[A, B, C, D, E, F, G, H, I, J], K>,
    ): Promise<Out<[A, B, C, D, E, F, G, H, I, J, K]>>;
} = resultAsyncTupleFlow

Run a flow of async and sync callback results

Type Declaration

- <A extends Res>(v: A | Promise<A>): Promise<A>
- Run a async 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <A extends Res, B extends Res>(
  v: A | Promise<A>,
  f0: Fn<[A], B>,
  ): Promise<Out<[A, B]>>
- Run a async 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <A extends Res, B extends Res, C extends Res>(
      v: A | Promise<A>,
      f0: Fn<[A], B>,
      f1: Fn<[A, B], C>,
  ): Promise<Out<[A, B, C]>>
- Run a async 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<[A, B], C>
  Returns Promise<Out<[A, B, C]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <A extends Res, B extends Res, C extends Res, D extends Res>(
      v: A | Promise<A>,
      f0: Fn<[A], B>,
      f1: Fn<[A, B], C>,
      f2: Fn<[A, B, C], D>,
  ): Promise<Out<[A, B, C, D]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  Returns Promise<Out<[A, B, C, D]>>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: Promise<IResult<string>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
  ): Promise<Out<[A, B, C, D, E]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
  ): Promise<Out<[A, B, C, D, E, F]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
  ): Promise<Out<[A, B, C, D, E, F, G]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, G], H>,
  ): Promise<Out<[A, B, C, D, E, F, G, H]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, G], H>,
      f7: Fn<[A, B, C, D, E, F, G, H], I>,
  ): Promise<Out<[A, B, C, D, E, F, G, H, I]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, G], H>
  - f7: Fn<[A, B, C, D, E, F, G, 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, G], H>,
      f7: Fn<[A, B, C, D, E, F, G, H], I>,
      f8: Fn<[A, B, C, D, E, F, G, H, I], J>,
  ): Promise<Out<[A, B, C, D, E, F, G, H, I, J]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, G], H>
  - f7: Fn<[A, B, C, D, E, F, G, H], I>
  - f8: Fn<[A, B, C, D, E, F, G, H, 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, G], H>,
      f7: Fn<[A, B, C, D, E, F, G, H], I>,
      f8: Fn<[A, B, C, D, E, F, G, H, I], J>,
      f9: Fn<[A, B, C, D, E, F, G, H, I, J], K>,
  ): Promise<Out<[A, B, C, D, E, F, G, H, I, J, K]>>
- Run a async 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, G], H>
  - f7: Fn<[A, B, C, D, E, F, G, H], I>
  - f8: Fn<[A, B, C, D, E, F, G, H, I], J>
  - f9: Fn<[A, B, C, D, E, F, G, H, I, 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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0

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>> = Result.asyncTupleFlow(
  Ok('hello'),
  (hello) => Promise.resolve(Ok(`${hello} world`)),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);

Since

v2.1.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

`Static` `Readonly`tupleFlow

tupleFlow: {
    <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<[A, 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<[A, B], C>,
        f2: Fn<[A, B, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, G], H>,
        f7: Fn<[A, B, C, D, E, F, G, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, G], H>,
        f7: Fn<[A, B, C, D, E, F, G, H], I>,
        f8: Fn<[A, B, C, D, E, F, G, H, 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<[A, B], C>,
        f2: Fn<[A, B, C], D>,
        f3: Fn<[A, B, C, D], E>,
        f4: Fn<[A, B, C, D, E], F>,
        f5: Fn<[A, B, C, D, E, F], G>,
        f6: Fn<[A, B, C, D, E, F, G], H>,
        f7: Fn<[A, B, C, D, E, F, G, H], I>,
        f8: Fn<[A, B, C, D, E, F, G, H, I], J>,
        f9: Fn<[A, B, C, D, E, F, G, H, I, J], K>,
    ): Out<[A, B, C, D, E, F, G, H, I, J, K]>;
} = resultTupleFlow

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> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <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> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <A extends Res, B extends Res, C extends Res>(
      v: A,
      f0: Fn<[A], B>,
      f1: Fn<[A, 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<[A, B], C>
  Returns Out<[A, B, C]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <A extends Res, B extends Res, C extends Res, D extends Res>(
      v: A,
      f0: Fn<[A], B>,
      f1: Fn<[A, B], C>,
      f2: Fn<[A, B, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  Returns Out<[A, B, C, D]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <A extends Res, B extends Res, C extends Res, D extends Res, E extends Res>(
      v: A,
      f0: Fn<[A], B>,
      f1: Fn<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  Returns Out<[A, B, C, D, E]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  Returns Out<[A, B, C, D, E, F]>
  as final result
  Throws
  if uncontrolled error from callback
  Example
```
const res: IResult<string> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, 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> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, 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> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, G], H>,
      f7: Fn<[A, B, C, D, E, F, G, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, G], H>
  - f7: Fn<[A, B, C, D, E, F, G, 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> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, G], H>,
      f7: Fn<[A, B, C, D, E, F, G, H], I>,
      f8: Fn<[A, B, C, D, E, F, G, H, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, G], H>
  - f7: Fn<[A, B, C, D, E, F, G, H], I>
  - f8: Fn<[A, B, C, D, E, F, G, H, 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> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0
- <
      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<[A, B], C>,
      f2: Fn<[A, B, C], D>,
      f3: Fn<[A, B, C, D], E>,
      f4: Fn<[A, B, C, D, E], F>,
      f5: Fn<[A, B, C, D, E, F], G>,
      f6: Fn<[A, B, C, D, E, F, G], H>,
      f7: Fn<[A, B, C, D, E, F, G, H], I>,
      f8: Fn<[A, B, C, D, E, F, G, H, I], J>,
      f9: Fn<[A, B, C, D, E, F, G, H, I, 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<[A, B], C>
  - f2: Fn<[A, B, C], D>
  - f3: Fn<[A, B, C, D], E>
  - f4: Fn<[A, B, C, D, E], F>
  - f5: Fn<[A, B, C, D, E, F], G>
  - f6: Fn<[A, B, C, D, E, F, G], H>
  - f7: Fn<[A, B, C, D, E, F, G, H], I>
  - f8: Fn<[A, B, C, D, E, F, G, H, I], J>
  - f9: Fn<[A, B, C, D, E, F, G, H, I, 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> = Result.tupleFlow(
  Ok('hello'),
  (hello) => Ok(`${hello} world`),
  (hello, helloWorld) => Ok(helloWorld.length),
  (hello, helloWorld, length) => Ok(`${helloWorld}:${length.toString()}`),
);
```
  Since
  v2.1.0

Example

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

Template: A

type of the initial result

Param: v

initial result

Returns

as final result

Throws

if uncontrolled error from callback

Since

v2.1.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:151

`Static`asArray

asArray<OkType, ErrType = unknown>(
iterable: Iterable<IResult<OkType, ErrType>>,
): IResult<OkType[], ErrType>
Resolve iterable of IResult to single IOk array result or IErr
Type Parameters
- OkType
  Ok type
- ErrType = unknown
  Err type
Parameters
- iterable: Iterable<IResult<OkType, ErrType>>
  Iterable of IResult
Returns IResult<OkType[], ErrType>
- returns IOk or IErr
Example
```
const iterable = [Ok('hello'), Ok('world')];
const output: IResult<string[], Error> = Result.asArray(iterable);
```
Since
v2.0.2
- Defined in src/result/Result.mts:230

`Static`asAsyncArray

asAsyncArray<OkType, ErrType = unknown>(
    iterable:
        | AsyncIterable<IResult<OkType, ErrType>, any, any>
        | Iterable<IResult<OkType, ErrType>, any, any>,
): Promise<IResult<OkType[], ErrType>>
Resolve async iterable or iterable of IResult to single IOk array result or IErr
Type Parameters
- OkType
  Ok type
- ErrType = unknown
  Err type
Parameters
- iterable:
  | AsyncIterable<IResult<OkType, ErrType>, any, any>
  | Iterable<IResult<OkType, ErrType>, any, any>
  AsyncIterable or Iterable of IResult
Returns Promise<IResult<OkType[], ErrType>>
- returns Promise of IOk or IErr
Example
```
const iterable = [Ok('hello'), Ok('world')];
const output: Promise<IResult<string[], Error>> = await Result.asAsyncArray(iterable);
```
Since
v2.0.2
- Defined in src/result/Result.mts:252

`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:173

`Static`asyncIterator

asyncIterator<T, Err = unknown>(
iterable: AsyncIterable<T, any, any> | Iterable<T, any, any>,
): AsyncIterable<IResult<T, Err>>
yields Ok from async iterable or Err from thrown error;
Type Parameters
- T
- Err = unknown
Parameters
- iterable: AsyncIterable<T, any, any> | Iterable<T, any, any>
Returns AsyncIterable<IResult<T, Err>>
Yields
Since
v2.0.2
- Defined in src/result/Result.mts:192

`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:131

`Static`iterator

iterator<T, Err = unknown>(iterable: Iterable<T>): Iterable<IResult<T, Err>>
yields Ok from iterable or Err from thrown error;
Type Parameters
- T
- Err = unknown
Parameters
- iterable: Iterable<T>
Returns Iterable<IResult<T, Err>>
Yields
Since
v2.0.2
- Defined in src/result/Result.mts:209

`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:339

`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:385

`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:363

`Static`wrapAsyncFn

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

`Static`wrapFn

wrapFn<
    ErrType = unknown,
    Fn extends (...args: any[]) => any = (...args: any[]) => any,
>(
    func: Fn,
): WrapFnReturn<Fn, ErrType>
build safe Result wrapper for callback function
Type Parameters
- ErrType = unknown
  error type
- Fn extends (...args: any[]) => any = (...args: any[]) => any
  function type
Parameters
- func: Fn
  callback function
Returns WrapFnReturn<Fn, 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<SyntaxError, typeof JSON.parse>(JSON.parse);
const res: IResult<any, SyntaxError> = jsonParse('{ "hello": "world" }');
```
Since
v2.2.0
- Defined in src/result/Result.mts:279

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`asyncTupleFlow