@nlozgachev/pipekit 0.1.6

package/script/src/Core/Result.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = void 0;
+var Result;
+(function (Result) {
+    /**
+     * Wraps a value in a successful Result (Ok).
+     *
+     * @example
+     * ```ts
+     * Result.of(42); // Ok(42)
+     * ```
+     */
+    Result.of = (value) => Result.toOk(value);
+    /**
+     * Creates a failed Result with the given error.
+     */
+    Result.toErr = (error) => ({ kind: "Error", error });
+    /**
+     * Creates a successful Result with the given value.
+     */
+    Result.toOk = (value) => ({ kind: "Ok", value });
+    /**
+     * Type guard that checks if an Result is Ok.
+     */
+    Result.isOk = (data) => data.kind === "Ok";
+    /**
+     * Type guard that checks if an Result is Err.
+     */
+    Result.isErr = (data) => data.kind === "Error";
+    /**
+     * Creates an Result from a function that may throw.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const parseJson = (s: string): Result<string, unknown> =>
+     *   Result.tryCatch(
+     *     () => JSON.parse(s),
+     *     (e) => `Parse error: ${e}`
+     *   );
+     * ```
+     */
+    Result.tryCatch = (f, onError) => {
+        try {
+            return Result.toOk(f());
+        }
+        catch (e) {
+            return Result.toErr(onError(e));
+        }
+    };
+    /**
+     * Transforms the success value inside an Result.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.of(5), Result.map(n => n * 2)); // Ok(10)
+     * pipe(Result.toErr("error"), Result.map(n => n * 2)); // Err("error")
+     * ```
+     */
+    Result.map = (f) => (data) => Result.isOk(data) ? Result.toOk(f(data.value)) : data;
+    /**
+     * Transforms the error value inside an Result.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.toErr("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * ```
+     */
+    Result.mapError = (f) => (data) => Result.isErr(data) ? Result.toErr(f(data.error)) : data;
+    /**
+     * Chains Result computations. If the first is Ok, passes the value to f.
+     * If the first is Err, propagates the error.
+     *
+     * @example
+     * ```ts
+     * const validatePositive = (n: number): Result<string, number> =>
+     *   n > 0 ? Result.of(n) : Result.toErr("Must be positive");
+     *
+     * pipe(Result.of(5), Result.chain(validatePositive)); // Ok(5)
+     * pipe(Result.of(-1), Result.chain(validatePositive)); // Err("Must be positive")
+     * ```
+     */
+    Result.chain = (f) => (data) => Result.isOk(data) ? f(data.value) : data;
+    /**
+     * Extracts the value from an Result by providing handlers for both cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.of(5),
+     *   Result.fold(
+     *     e => `Error: ${e}`,
+     *     n => `Value: ${n}`
+     *   )
+     * ); // "Value: 5"
+     * ```
+     */
+    Result.fold = (onErr, onOk) => (data) => Result.isOk(data) ? onOk(data.value) : onErr(data.error);
+    /**
+     * Pattern matches on a Result, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   result,
+     *   Result.match({
+     *     ok: value => `Got ${value}`,
+     *     err: error => `Failed: ${error}`
+     *   })
+     * );
+     * ```
+     */
+    Result.match = (cases) => (data) => Result.isOk(data) ? cases.ok(data.value) : cases.err(data.error);
+    /**
+     * Returns the success value or a default value if the Result is an error.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.of(5), Result.getOrElse(0)); // 5
+     * pipe(Result.toErr("error"), Result.getOrElse(0)); // 0
+     * ```
+     */
+    Result.getOrElse = (defaultValue) => (data) => Result.isOk(data) ? data.value : defaultValue;
+    /**
+     * Executes a side effect on the success value without changing the Result.
+     * Useful for logging or debugging.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.of(5),
+     *   Result.tap(n => console.log("Value:", n)),
+     *   Result.map(n => n * 2)
+     * );
+     * ```
+     */
+    Result.tap = (f) => (data) => {
+        if (Result.isOk(data))
+            f(data.value);
+        return data;
+    };
+    /**
+     * Recovers from an error by providing a fallback Result.
+     */
+    Result.recover = (fallback) => (data) => Result.isOk(data) ? data : fallback();
+    /**
+     * Recovers from an error unless it matches the blocked error.
+     */
+    Result.recoverUnless = (blockedErr, fallback) => (data) => Result.isErr(data) && data.error !== blockedErr ? fallback() : data;
+    /**
+     * Converts a Result to an Option.
+     * Ok becomes Some, Err becomes None (the error is discarded).
+     *
+     * @example
+     * ```ts
+     * Result.toOption(Result.toOk(42)); // Some(42)
+     * Result.toOption(Result.toErr("oops")); // None
+     * ```
+     */
+    Result.toOption = (data) => Result.isOk(data) ? { kind: "Some", value: data.value } : { kind: "None" };
+    /**
+     * Applies a function wrapped in an Result to a value wrapped in an Result.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Result.of(add),
+     *   Result.ap(Result.of(5)),
+     *   Result.ap(Result.of(3))
+     * ); // Ok(8)
+     * ```
+     */
+    Result.ap = (arg) => (data) => Result.isOk(data) && Result.isOk(arg) ? Result.toOk(data.value(arg.value)) : Result.isErr(data) ? data : arg;
+})(Result || (exports.Result = Result = {}));

package/script/src/Core/Task.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+var Task;
+(function (Task) {
+    /**
+     * Wraps a value in a Task that immediately resolves to that value.
+     *
+     * @example
+     * ```ts
+     * const task = Task.of(42);
+     * task().then(console.log); // 42
+     * ```
+     */
+    Task.of = (value) => () => Promise.resolve(value);
+    /**
+     * Creates a Task that will reject with the given error.
+     */
+    Task.fail = (error) => () => Promise.reject(error);
+    /**
+     * Creates a Task from a function that returns a Promise.
+     * Alias for directly creating a Task.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = Task.from(() => fetch('/user').then(r => r.json()));
+     * ```
+     */
+    Task.from = (f) => f;
+    /**
+     * Transforms the value inside a Task.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.of(5),
+     *   Task.map(n => n * 2)
+     * )(); // Promise<10>
+     * ```
+     */
+    Task.map = (f) => (data) => () => data().then(f);
+    /**
+     * Chains Task computations. If the first succeeds, passes the value to f.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = (id: string): Task<User> => () => fetch(`/users/${id}`).then(r => r.json());
+     * const fetchPosts = (user: User): Task<Post[]> => () => fetch(`/posts?userId=${user.id}`).then(r => r.json());
+     *
+     * pipe(
+     *   fetchUser("123"),
+     *   Task.chain(fetchPosts)
+     * )(); // Promise<Post[]>
+     * ```
+     */
+    Task.chain = (f) => (data) => () => data().then((a) => f(a)());
+    /**
+     * Applies a function wrapped in a Task to a value wrapped in a Task.
+     * Both Tasks run in parallel.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Task.of(add),
+     *   Task.ap(Task.of(5)),
+     *   Task.ap(Task.of(3))
+     * )(); // Promise<8>
+     * ```
+     */
+    Task.ap = (arg) => (data) => () => Promise.all([data(), arg()]).then(([f, a]) => f(a));
+    /**
+     * Executes a side effect on the value without changing the Task.
+     * Useful for logging or debugging.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchData,
+     *   Task.tap(data => console.log("Fetched:", data)),
+     *   Task.map(transform)
+     * );
+     * ```
+     */
+    Task.tap = (f) => (data) => () => data().then((a) => {
+        f(a);
+        return a;
+    });
+    /**
+     * Runs multiple Tasks in parallel and collects their results.
+     *
+     * @example
+     * ```ts
+     * Task.all([fetchUser, fetchPosts, fetchComments])();
+     * // Promise<[User, Post[], Comment[]]>
+     * ```
+     */
+    Task.all = (tasks) => () => Promise.all(tasks.map((t) => t()));
+    /**
+     * Delays the execution of a Task by the specified milliseconds.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.of(42),
+     *   Task.delay(1000)
+     * )(); // Resolves after 1 second
+     * ```
+     */
+    Task.delay = (ms) => (data) => () => new Promise((resolve, reject) => setTimeout(() => data().then(resolve, reject), ms));
+})(Task || (exports.Task = Task = {}));

package/script/src/Core/TaskResult.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskResult = void 0;
+const Result_js_1 = require("./Result.js");
+const Task_js_1 = require("./Task.js");
+var TaskResult;
+(function (TaskResult) {
+    /**
+     * Wraps a value in a successful TaskResult.
+     */
+    TaskResult.of = (value) => Task_js_1.Task.of(Result_js_1.Result.toOk(value));
+    /**
+     * Creates a failed TaskResult with the given error.
+     */
+    TaskResult.fail = (error) => Task_js_1.Task.of(Result_js_1.Result.toErr(error));
+    /**
+     * Creates a TaskResult from a function that may throw.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const parseJson = (s: string): TaskResult<string, unknown> =>
+     *   TaskResult.tryCatch(
+     *     async () => JSON.parse(s),
+     *     (e) => `Parse error: ${e}`
+     *   );
+     * ```
+     */
+    TaskResult.tryCatch = (f, onError) => () => f()
+        .then(Result_js_1.Result.toOk)
+        .catch((e) => Result_js_1.Result.toErr(onError(e)));
+    /**
+     * Transforms the success value inside a TaskResult.
+     */
+    TaskResult.map = (f) => (data) => Task_js_1.Task.map(Result_js_1.Result.map(f))(data);
+    /**
+     * Transforms the error value inside a TaskResult.
+     */
+    TaskResult.mapError = (f) => (data) => Task_js_1.Task.map(Result_js_1.Result.mapError(f))(data);
+    /**
+     * Chains TaskResult computations. If the first succeeds, passes the value to f.
+     * If the first fails, propagates the error.
+     */
+    TaskResult.chain = (f) => (data) => Task_js_1.Task.chain((result) => Result_js_1.Result.isOk(result) ? f(result.value) : Task_js_1.Task.of(Result_js_1.Result.toErr(result.error)))(data);
+    /**
+     * Extracts the value from a TaskResult by providing handlers for both cases.
+     */
+    TaskResult.fold = (onErr, onOk) => (data) => Task_js_1.Task.map(Result_js_1.Result.fold(onErr, onOk))(data);
+    /**
+     * Pattern matches on a TaskResult, returning a Task of the result.
+     */
+    TaskResult.match = (cases) => (data) => Task_js_1.Task.map(Result_js_1.Result.match(cases))(data);
+    /**
+     * Recovers from an error by providing a fallback TaskResult.
+     */
+    TaskResult.recover = (fallback) => (data) => Task_js_1.Task.chain((result) => Result_js_1.Result.isErr(result) ? fallback(result.error) : Task_js_1.Task.of(result))(data);
+    /**
+     * Returns the success value or a default value if the TaskResult is an error.
+     */
+    TaskResult.getOrElse = (defaultValue) => (data) => Task_js_1.Task.map(Result_js_1.Result.getOrElse(defaultValue))(data);
+    /**
+     * Executes a side effect on the success value without changing the TaskResult.
+     * Useful for logging or debugging.
+     */
+    TaskResult.tap = (f) => (data) => Task_js_1.Task.map(Result_js_1.Result.tap(f))(data);
+})(TaskResult || (exports.TaskResult = TaskResult = {}));

package/script/src/Core/Validation.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validation = void 0;
+const NonEmptyList_js_1 = require("../Types/NonEmptyList.js");
+var Validation;
+(function (Validation) {
+    /**
+     * Wraps a value in a valid Validation.
+     *
+     * @example
+     * ```ts
+     * Validation.of(42); // Valid(42)
+     * ```
+     */
+    Validation.of = (value) => ({
+        kind: "Valid",
+        value,
+    });
+    /**
+     * Creates a valid Validation with the given value.
+     */
+    Validation.toValid = (value) => ({ kind: "Valid", value });
+    /**
+     * Type guard that checks if a Validation is valid.
+     */
+    Validation.isValid = (data) => data.kind === "Valid";
+    /**
+     * Creates an invalid Validation with the given errors.
+     *
+     * @example
+     * ```ts
+     * Validation.toInvalid(["Email is invalid", "Password too short"]);
+     * ```
+     */
+    Validation.toInvalid = (errors) => ({
+        kind: "Invalid",
+        errors,
+    });
+    /**
+     * Type guard that checks if a Validation is invalid.
+     */
+    Validation.isInvalid = (data) => data.kind === "Invalid";
+    /**
+     * Creates an invalid Validation from a single error.
+     *
+     * @example
+     * ```ts
+     * Validation.fail("Invalid input");
+     * ```
+     */
+    Validation.fail = (error) => Validation.toInvalid([error]);
+    /**
+     * Transforms the success value inside a Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.of(5), Validation.map(n => n * 2)); // Valid(10)
+     * pipe(Validation.fail("oops"), Validation.map(n => n * 2)); // Invalid(["oops"])
+     * ```
+     */
+    Validation.map = (f) => (data) => Validation.isValid(data) ? Validation.of(f(data.value)) : data;
+    /**
+     * Chains Validation computations. If the first is Valid, passes the value to f.
+     * If the first is Invalid, propagates the errors.
+     *
+     * Note: chain short-circuits on first error. Use `ap` to accumulate errors.
+     *
+     * @example
+     * ```ts
+     * const validatePositive = (n: number): Validation<string, number> =>
+     *   n > 0 ? Validation.of(n) : Validation.fail("Must be positive");
+     *
+     * pipe(Validation.of(5), Validation.chain(validatePositive)); // Valid(5)
+     * pipe(Validation.of(-1), Validation.chain(validatePositive)); // Invalid(["Must be positive"])
+     * ```
+     */
+    Validation.chain = (f) => (data) => Validation.isValid(data) ? f(data.value) : data;
+    /**
+     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
+     * Accumulates errors from both sides.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Validation.of(add),
+     *   Validation.ap(Validation.of(5)),
+     *   Validation.ap(Validation.of(3))
+     * ); // Valid(8)
+     *
+     * pipe(
+     *   Validation.of(add),
+     *   Validation.ap(Validation.fail<string, number>("bad a")),
+     *   Validation.ap(Validation.fail<string, number>("bad b"))
+     * ); // Invalid(["bad a", "bad b"])
+     * ```
+     */
+    Validation.ap = (arg) => (data) => {
+        if (Validation.isValid(data) && Validation.isValid(arg))
+            return Validation.of(data.value(arg.value));
+        const errors = [
+            ...(Validation.isInvalid(data) ? data.errors : []),
+            ...(Validation.isInvalid(arg) ? arg.errors : []),
+        ];
+        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.toInvalid(errors) : Validation.of(data);
+    };
+    /**
+     * Extracts the value from a Validation by providing handlers for both cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.of(42),
+     *   Validation.fold(
+     *     errors => `Errors: ${errors.join(", ")}`,
+     *     value => `Value: ${value}`
+     *   )
+     * );
+     * ```
+     */
+    Validation.fold = (onInvalid, onValid) => (data) => Validation.isValid(data) ? onValid(data.value) : onInvalid(data.errors);
+    /**
+     * Pattern matches on a Validation, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validation,
+     *   Validation.match({
+     *     valid: value => `Got ${value}`,
+     *     invalid: errors => `Failed: ${errors.join(", ")}`
+     *   })
+     * );
+     * ```
+     */
+    Validation.match = (cases) => (data) => Validation.isValid(data) ? cases.valid(data.value) : cases.invalid(data.errors);
+    /**
+     * Returns the success value or a default value if the Validation is invalid.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.of(5), Validation.getOrElse(0)); // 5
+     * pipe(Validation.fail("oops"), Validation.getOrElse(0)); // 0
+     * ```
+     */
+    Validation.getOrElse = (defaultValue) => (data) => Validation.isValid(data) ? data.value : defaultValue;
+    /**
+     * Executes a side effect on the success value without changing the Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.of(5),
+     *   Validation.tap(n => console.log("Value:", n)),
+     *   Validation.map(n => n * 2)
+     * );
+     * ```
+     */
+    Validation.tap = (f) => (data) => {
+        if (Validation.isValid(data))
+            f(data.value);
+        return data;
+    };
+    /**
+     * Recovers from an Invalid state by providing a fallback Validation.
+     */
+    Validation.recover = (fallback) => (data) => Validation.isValid(data) ? data : fallback();
+    /**
+     * Recovers from an Invalid state unless the errors contain any of the blocked errors.
+     */
+    Validation.recoverUnless = (blockedErrors, fallback) => (data) => Validation.isInvalid(data) &&
+        !data.errors.some((err) => blockedErrors.includes(err))
+        ? fallback()
+        : data;
+    /**
+     * Combines two Validation instances, accumulating errors from both.
+     * If both are Valid, returns the second valid value.
+     * If either is Invalid, combines their errors into a single Invalid.
+     *
+     * @example
+     * ```ts
+     * Validation.combine(
+     *   Validation.fail("Error 1"),
+     *   Validation.fail("Error 2")
+     * ); // Invalid(["Error 1", "Error 2"])
+     *
+     * Validation.combine(
+     *   Validation.of("a"),
+     *   Validation.of("b")
+     * ); // Valid("b")
+     * ```
+     */
+    Validation.combine = (first, second) => {
+        if (Validation.isValid(first) && Validation.isValid(second)) {
+            return second;
+        }
+        const errors = [
+            ...(Validation.isInvalid(first) ? first.errors : []),
+            ...(Validation.isInvalid(second) ? second.errors : []),
+        ];
+        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.toInvalid(errors) : second;
+    };
+    /**
+     * Combines multiple Validation instances, accumulating all errors.
+     * If all are Valid, returns the last valid value.
+     * Returns undefined for an empty array.
+     *
+     * @example
+     * ```ts
+     * Validation.combineAll([
+     *   validateName(name),
+     *   validateEmail(email),
+     *   validateAge(age)
+     * ]);
+     * ```
+     */
+    Validation.combineAll = (data) => data.length === 0 ? undefined : data.reduce((acc, v) => Validation.combine(acc, v));
+})(Validation || (exports.Validation = Validation = {}));

package/script/src/Core/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Arr.js"), exports);
+__exportStar(require("./Option.js"), exports);
+__exportStar(require("./Rec.js"), exports);
+__exportStar(require("./RemoteData.js"), exports);
+__exportStar(require("./Result.js"), exports);
+__exportStar(require("./Task.js"), exports);
+__exportStar(require("./TaskResult.js"), exports);
+__exportStar(require("./Validation.js"), exports);

package/script/src/Types/NonEmptyList.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNonEmptyList = void 0;
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ * ```ts
+ * const items: string[] = getItems();
+ *
+ * if (isNonEmptyList(items)) {
+ *   // TypeScript knows items has at least one element
+ *   const first = items[0]; // string, not string | undefined
+ * }
+ * ```
+ */
+const isNonEmptyList = (list) => list.length > 0;
+exports.isNonEmptyList = isNonEmptyList;

package/script/src/Types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./NonEmptyList.js"), exports);

package/types/mod.d.ts

@@ -0,0 +1,4 @@
+export * from "./src/Composition/index.js";
+export * from "./src/Core/index.js";
+export * from "./src/Composition/index.js";
+//# sourceMappingURL=mod.d.ts.map

package/types/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC"}

package/types/src/Composition/compose.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Composes functions from right to left, returning a new function.
+ * This is the traditional mathematical function composition: (f . g)(x) = f(g(x))
+ *
+ * Unlike `flow` which reads left-to-right, `compose` reads right-to-left,
+ * matching how nested function calls would be written.
+ *
+ * @example
+ * ```ts
+ * const addOne = (n: number) => n + 1;
+ * const double = (n: number) => n * 2;
+ *
+ * // compose: right-to-left (double first, then addOne)
+ * const composed = compose(addOne, double);
+ * composed(5); // 11 (5 * 2 + 1)
+ *
+ * // flow: left-to-right (addOne first, then double)
+ * const flowed = flow(addOne, double);
+ * flowed(5); // 12 ((5 + 1) * 2)
+ * ```
+ *
+ * @see {@link flow} for left-to-right composition
+ */
+export declare function compose<A, B>(ab: (a: A) => B): (a: A) => B;
+export declare function compose<A, B, C>(bc: (b: B) => C, ab: (a: A) => B): (a: A) => C;
+export declare function compose<A, B, C, D>(cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => D;
+export declare function compose<A, B, C, D, E>(de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => E;
+export declare function compose<A, B, C, D, E, F>(ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => F;
+export declare function compose<A, B, C, D, E, F, G>(fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => G;
+export declare function compose<A, B, C, D, E, F, G, H>(gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => H;
+export declare function compose<A, B, C, D, E, F, G, H, I>(hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => I;
+export declare function compose<A, B, C, D, E, F, G, H, I, J>(ij: (i: I) => J, hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => J;
+//# sourceMappingURL=compose.d.ts.map

package/types/src/Composition/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/src/Composition/compose.ts"],"names":[],"mappings":"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,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AACf,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAClD,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EACf,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC"}