- Press n or j to go to the next uncovered block, b, p or k for the previous block. -
- -- Press n or j to go to the next uncovered block, b, p or k for the previous block. -
- -- Press n or j to go to the next uncovered block, b, p or k for the previous block. -
- -| 1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22 -23 -24 -25 -26 -27 -28 -29 -30 -31 -32 -33 -34 -35 -36 -37 -38 -39 -40 -41 -42 -43 -44 -45 -46 -47 -48 -49 -50 -51 -52 -53 -54 -55 -56 -57 -58 -59 -60 -61 -62 -63 -64 -65 -66 -67 -68 -69 -70 -71 -72 -73 -74 -75 -76 -77 -78 -79 -80 -81 -82 -83 -84 -85 -86 -87 -88 | 1x - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -1x - - -10x - - - - -10x -10x -10x - - -10x -10x -10x -17x -14x -14x -10x -10x -10x - | import { AsyncResult, isFailure, Result, Success } from "./result";
-
-/**
- * Type for a function that takes an input of type `In` and returns an `AsyncResult` of type `Out` and `E`.
- * @template In - The input type.
- * @template Out - The output type.
- * @template E - The error type.
- */
-type PipeFn<In, Out, E> = (arg: In) => AsyncResult<Out, E>;
-
-/**
- * Type to extract the return type of the last function in a tuple of functions.
- * @template T - The tuple of functions.
- * @template K - The index of the function in the tuple.
- */
-type LastReturnType<T extends any[], K> = K extends keyof T
- ? T[K] extends PipeFn<any, infer S, any>
- ? S
- : never
- : never;
-
-/**
- * Type to extract the error type from a tuple of functions.
- * @template T - The tuple of functions.
- */
-type ExtractError<T extends any[]> = T[number] extends PipeFn<any, any, infer E>
- ? E
- : never;
-
-/**
- * Type for a pipeline of functions, ensuring correct type inference for each function in the tuple.
- * @template T - The tuple of functions.
- * @template E - The error type.
- */
-type Pipeline<T extends any[], E> = {
- [K in keyof T]: K extends "0"
- ? T[K] extends PipeFn<infer R, infer S, E>
- ? PipeFn<R, S, E>
- : never
- : T[K] extends PipeFn<infer R, infer S, E>
- ? PipeFn<LastReturnType<T, K>, S, E>
- : never;
-};
-
-/**
- * The `pipe` function composes multiple functions, handling both synchronous and asynchronous processes.
- * @template T - The tuple of functions.
- * @template ExtractError<T> - The error type extracted from the tuple of functions.
- * @param {...Pipeline<T, ExtractError<T>>} fns - The functions to compose.
- * @returns {Function} A function that takes the input of the first function and returns a `Promise` resolving to a `Result` of the last function's output type and the error type.
- *
- * @example
- * const pipeline = pipe(
- * async (input: string) => success(parseInt(input)),
- * async (num: number) => success(num + 1),
- * async (num: number) => success(num.toString())
- * );
- *
- * pipeline("42").then(result =>
- * match({
- * onSuccess: val => console.log("Success:", val),
- * onFailure: err => console.log("Error:", err)
- * })(result)
- * );
- */
-export const pipe = <
- T extends [PipeFn<any, any, any>, ...PipeFn<any, any, any>[]]
->(
- ...fns: Pipeline<T, ExtractError<T>>
-): ((
- arg: Parameters<T[0]>[0]
-) => Promise<
- Result<LastReturnType<T, keyof T & (keyof T)[]["length"]>, ExtractError<T>>
->) => {
- return async (
- arg: Parameters<T[0]>[0]
- ): Promise<
- Result<LastReturnType<T, keyof T & (keyof T)[]["length"]>, ExtractError<T>>
- > => {
- let result: Result<any, ExtractError<T>> = await fns[0](arg);
- for (const fn of fns.slice(1)) {
- if (isFailure(result)) break;
- result = await fn((result as Success<any>).value);
- }
- return result;
- };
-};
- |
- Press n or j to go to the next uncovered block, b, p or k for the previous block. -
- -| 1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22 -23 -24 -25 -26 -27 -28 -29 -30 -31 -32 -33 -34 -35 -36 -37 -38 -39 -40 -41 -42 -43 -44 -45 -46 -47 -48 -49 -50 -51 -52 -53 -54 -55 -56 -57 -58 -59 -60 -61 -62 -63 -64 -65 -66 -67 -68 -69 -70 -71 -72 -73 -74 -75 -76 -77 -78 -79 -80 -81 -82 -83 -84 -85 -86 -87 -88 -89 -90 -91 -92 -93 -94 -95 -96 -97 -98 -99 -100 -101 -102 -103 -104 -105 -106 -107 -108 -109 -110 -111 -112 -113 -114 -115 -116 -117 -118 -119 -120 -121 -122 -123 -124 -125 -126 | - - - -1x -1x -1x - - - - -1x -1x - - - - - -1x -1x -1x - - - - -1x -1x - - - - - - - - - - - - - - - - - - - - - - -1x -18x - - - - - - - - -1x -21x - - - - - - - -1x - - - - - - - -1x - - - - - - - -1x - - - - - - - - - - - - -1x -1x -14x -14x -14x - - - -14x -14x - - - - - - - - -1x -4x -4x -4x -4x -2x -2x -2x -2x -4x - | /**
- * Represents a successful result.
- * @template T - The type of the value.
- */
-export class Success<T> {
- readonly isSuccess = true;
- readonly isFailure = false;
- /**
- * Creates an instance of Success.
- * @param {T} value - The value of the successful result.
- */
- constructor(public readonly value: T) {}
-}
-
-/**
- * Represents a failed result.
- * @template E - The type of the error.
- */
-export class Failure<E> {
- readonly isSuccess = false;
- readonly isFailure = true;
- /**
- * Creates an instance of Failure.
- * @param {E} error - The error of the failed result.
- */
- constructor(public readonly error: E) {}
-}
-
-/**
- * Type alias for a result which can be either a Success or a Failure.
- * @template T - The type of the value in case of success.
- * @template E - The type of the error in case of failure.
- */
-export type Result<T, E> = Success<T> | Failure<E>;
-
-/**
- * Type alias for an asynchronous result.
- * @template T - The type of the value in case of success.
- * @template E - The type of the error in case of failure.
- */
-export type AsyncResult<T, E> = Result<T, E> | Promise<Result<T, E>>;
-
-/**
- * Checks if the given result is a Success.
- * @template T - The type of the value in case of success.
- * @template E - The type of the error in case of failure.
- * @param {Result<T, E>} result - The result to check.
- * @returns {result is Success<T>} - True if the result is a Success, otherwise false.
- */
-export const isSuccess = <T, E>(result: Result<T, E>): result is Success<T> =>
- result.isSuccess;
-
-/**
- * Checks if the given result is a Failure.
- * @template T - The type of the value in case of success.
- * @template E - The type of the error in case of failure.
- * @param {Result<T, E>} result - The result to check.
- * @returns {result is Failure<E>} - True if the result is a Failure, otherwise false.
- */
-export const isFailure = <T, E>(result: Result<T, E>): result is Failure<E> =>
- result.isFailure;
-
-/**
- * Creates a success result.
- * @template T - The type of the value.
- * @param {T} value - The value of the success result.
- * @returns {Result<T, never>} - The success result.
- */
-export const success = <T>(value: T): Result<T, never> => new Success(value);
-
-/**
- * Creates a failure result.
- * @template E - The type of the error.
- * @param {E} error - The error of the failure result.
- * @returns {Result<never, E>} - The failure result.
- */
-export const failure = <E>(error: E): Result<never, E> => new Failure(error);
-
-/**
- * Wraps a value in a success result.
- * @template T - The type of the value.
- * @param {T} value - The value to wrap.
- * @returns {Result<T, never>} - The success result.
- */
-export const of = <T>(value: T): Result<T, never> => success(value);
-
-/**
- * Matches a result to a function based on whether it is a success or a failure.
- * @template T - The type of the value in case of success.
- * @template E - The type of the error in case of failure.
- * @template RS - The return type of the success handler.
- * @template RF - The return type of the failure handler.
- * @param {Object} handlers - An object containing the success and failure handlers.
- * @param {(value: T) => RS | Promise<RS>} handlers.onSuccess - The success handler.
- * @param {(error: E) => RF | Promise<RF>} handlers.onFailure - The failure handler.
- * @returns {(result: Result<T, E>) => Promise<RS | RF>} - A function that takes a result and returns a promise that resolves to the result of the appropriate handler.
- */
-export const match =
- <T, E, RS, RF>({
- onSuccess,
- onFailure,
- }: {
- onSuccess: (value: T) => RS | Promise<RS>;
- onFailure: (error: E) => RF | Promise<RF>;
- }) =>
- async (result: Result<T, E>): Promise<RS | RF> =>
- isSuccess(result) ? onSuccess(result.value) : onFailure(result.error);
-
-/**
- * Converts a promise to a result.
- * @template T - The type of the value in case of success.
- * @template E - The type of the error in case of failure.
- * @param {Promise<T>} promise - The promise to convert.
- * @returns {Promise<Result<T, E>>} - A promise that resolves to a result.
- */
-export const fromPromise = async <T, E extends Error = Error>(
- promise: Promise<T>
-): Promise<Result<T, E>> => {
- try {
- const value = await promise;
- return success(value);
- } catch (error) {
- return failure(error as E);
- }
-};
- |
- Press n or j to go to the next uncovered block, b, p or k for the previous block. -
- -| File | -- | Statements | -- | Branches | -- | Functions | -- | Lines | -- |
|---|---|---|---|---|---|---|---|---|---|
| index.ts | -
-
- |
- 0% | -0/2 | -0% | -0/1 | -0% | -0/1 | -0% | -0/2 | -
- Press n or j to go to the next uncovered block, b, p or k for the previous block. -
- -| 1 -2 -3 | - - | export * from "../lib/pipe"; -export * from "../lib/result"; - |