purity-seal 0.0.0

package/README.md

@@ -0,0 +1,173 @@
+Purity Seal enforces dependency rules between files:
+
+1. Classify files `filepath -> classification`, usually by file extension. *Classifiers are composable.*
+2. Define a `partial order` that expresses dependency rules between file classifications. Partial orders may not contain cycles.
+3. Create a checker from the classifier and partial order. Checkers input a `(dependent, dependency)` string pair, and output an `opinion`. *Checkers are composable.*
+4. Run the checker against a dependency graph, typically using a build system plugin.
+
+# Examples
+- Dog food! Purity Seal [validates itself](https://github.com/muniworth/purity-seal/blob/main/Build.ts).
+- [Enforce Onion Architecture](#enforce-onion-architecture)
+- [Separate Business Logic from Library](#separate-business-logic-from-library)
+- [Isolate Runtime Platforms](#isolate-runtime-platforms)
+- [Multiple Classifiers](#multiple-classifiers)
+- [Alternative Checkers](#alternative-checkers)
+- [Lua](#lua)
+
+### Enforce Onion Architecture
+```mermaid
+graph BT;
+	http.ts --> pure.ts
+	state.ts --> pure.ts
+	http.state.ts --> state.ts
+	http.state.ts --> http.ts
+```
+```ts
+const classify = PS.Classify.Extensions(["pure", "state", "http"])
+const po = PS.PartialOrder.Make([
+	[["http.state", "state.http"], ["state", "http"], "pure"],
+])
+const check = PS.Pipe(
+	PS.Checker.Build(classify)(po),
+	PS.Plugin.Esbuild,
+)
+```
+
+### Separate Business Logic from Library
+```mermaid
+graph LR;
+	domain.ts --> pure.ts
+	math.ts --> domain.ts
+```
+```ts
+const classify = PS.Classify.Extensions(["pure", "math", "domain"])
+const po = PS.PartialOrder.Make([
+	["math", "domain", "pure"],
+])
+const check = PS.Pipe(
+	PS.Checker.Build(classify)(po),
+	PS.Plugin.Esbuild,
+)
+```
+
+### Isolate Runtime Platforms
+```mermaid
+graph BT;
+	Fetch.http.ts --> pure.ts
+	dom.ts --> pure.ts
+	worker.ts --> pure.ts
+	Assert.test.ts --> pure.ts
+
+	subgraph Builds
+		browser.ts
+		thread.ts
+		test.ts
+	end
+
+	browser.ts --> dom.ts
+	browser.ts --> Fetch.http.ts
+	thread.ts --> Fetch.http.ts
+	thread.ts --> worker.ts
+	test.ts --> pure.ts
+	test.ts --> Assert.test.ts
+```
+```ts
+const classify = PS.Classify.Extensions([
+	"pure", "http", "dom", "worker", "test", "browser", "thread",
+])
+const po = PS.PartialOrder.Make([
+	["browser", ["http", "dom"], "pure"],
+	["thread", ["http", "worker"], "pure"],
+	["test", "pure"],
+])
+const check = PS.Pipe(
+	PS.Checker.Build(classify)(po),
+	PS.Plugin.Esbuild,
+)
+```
+
+### Multiple Classifiers
+Third party code may follow different conventions.
+```mermaid
+graph BT;
+	pure.ts --> Stats
+	http.ts --> pure.ts
+	http.ts --> HTTP
+	http.ts --> Framework.cache
+	dom.http --> http.ts
+	dom.http ---> Framework
+```
+```ts
+const libStats = PS.Classify.SetWhen(
+	filepath => filepath.startsWith("node_modules/Stats"),
+	_filepath => "pure",
+)
+const libHttp = PS.Classify.SetWhen(
+	filepath => filepath === "node_modules/HTTP/index.ts",
+	_filepath => "http",
+)
+const libGlob = PS.Classify.SetWhen(
+	filepath => filepath.startsWith("node_modules/framework"),
+	filepath => filepath.includes("cache") ? "http" : "dom.http",
+)
+const classify = PS.Pipe(
+	PS.Classify.Extensions(["pure", "http", "dom"]),
+	PS.Classify.Catch(libStats),
+	PS.Classify.Catch(libHttp),
+	PS.Classify.Catch(libGlob),
+)
+const po = PS.PartialOrder.Make([
+	["dom.http", ["dom", "http"], "pure"],
+])
+const check = PS.Pipe(
+	PS.Checker.Build(classify)(po),
+	PS.Plugin.Esbuild,
+)
+```
+
+### Alternative Checkers
+A checker does not have to form an opinion for a given node in the dependency graph. Instead, you can chain multiple checkers in a pipeline, which terminates when a checker forms an opinion.
+```ts
+const whitelist = new Set(["Source/Legacy/Foo.ts"])
+const allowWhitelist = PS.Checker.AsksWhen(
+	([x, y]) => whitelist.has(x) || whitelist.has(y),
+	PS.Checker.Allow(),
+)
+const classify = PS.Pipe(
+	PS.Classify.Extensions(["pure", "http"]),
+)
+const po = PS.PartialOrder.Make([
+	["http", "pure"],
+])
+const check = PS.Pipe(
+	PS.Checker.Build(classify)(po),
+	PS.Checker.Then(allowWhitelist),
+	PS.Plugin.Esbuild,
+)
+```
+
+### Lua
+```mermaid
+graph BT;
+	Player.game.lua --> pure.lua
+	test.lua --> pure.lua
+```
+The lua tooling ecosystem is less advanced than TypeScript, so Purity Seal bundles [luaparse](https://github.com/fstirlitz/luaparse) to help extract a dependency graph.
+```ts
+const classify = PS.Classify.Extensions([
+	"pure", "game", "test",
+])
+const po = PS.PartialOrder.Make([
+	["game", "pure"],// Game engine
+	["test", "pure"],// CLI
+])
+const check = PS.Checker.Build(classify)(po)
+const deps = await PS.Plugin.Lua.BuildDeps(
+	// Arg 1: list of entry point modules
+	// resolveModule: maps modules (including entries) to raw filepath.
+	["Main.game.lua", "test.lua"],
+	{ luaVersion: "5.1", resolveModule: x => "source/" +  x },
+)
+// { deny: Deps[], warn: string[] }
+const out = PS.Checker.Validate(check, deps)
+```

package/dist/Build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Checker/Checker.pure.d.ts

@@ -0,0 +1,59 @@
+import { Classify } from "../Classify/pure.ts";
+import { Reader, Result } from "../Lib/pure.ts";
+import { Opinion } from "./Opinion/pure.ts";
+import { PartialOrder } from "../Partial_Order/pure.ts";
+export * from "./Opinion/pure.ts";
+/** Reader environment: Dependent, Dependency */
+export type Deps = readonly [string, string];
+export type Checker<A> = Reader<Deps, Opinion<A>>;
+export declare const Pure: <A>(val: A) => Checker<A>;
+export declare const Allow: <A = never>() => Checker<A>;
+export declare const Deny: <A = never>() => Checker<A>;
+export declare const Warn: <A = never>(x: string) => Checker<A>;
+export declare const Bind_: <A, B>(m: Checker<A>, f: (t: A) => Checker<B>) => (d: Deps) => import("./Opinion/Opinion.pure.ts").Opinion<B>;
+export declare const Bind: {
+    <A, B>(m: Checker<A>, f: (t: A) => Checker<B>): Checker<B>;
+    <A, B>(f: (t: A) => Checker<B>): (m: Checker<A>) => Checker<B>;
+};
+export declare const Map_: <A, B>(m: Checker<A>, f: (t: A) => B) => (d: Deps) => import("./Opinion/Opinion.pure.ts").Opinion<B>;
+export declare const Map: {
+    <A, B>(m: Checker<A>, f: (t: A) => B): Checker<B>;
+    <A, B>(f: (t: A) => B): (m: Checker<A>) => Checker<B>;
+};
+export declare const Asks: <A>(f: (d: Deps) => A) => Checker<A>;
+export declare const Ask: Checker<Deps>;
+export declare const Then_: <A, B>(m1: Checker<A>, m2: Checker<B>) => Checker<B>;
+export declare const Then: {
+    <A, B>(m1: Checker<A>, m2: Checker<B>): Checker<B>;
+    <A, B>(m2: Checker<B>): (m1: Checker<A>) => Checker<B>;
+};
+export declare const When_: (b: boolean, m: Checker<void>) => Checker<void>;
+export declare const When: {
+    (b: boolean, m: Checker<void>): Checker<void>;
+    (m: Checker<void>): (b: boolean) => Checker<void>;
+};
+export declare const AsksWhen_: (p: (d: Deps) => boolean, m: Checker<void>) => Checker<void>;
+export declare const AsksWhen: {
+    (p: (d: Deps) => boolean, m: Checker<void>): Checker<void>;
+    (m: Checker<void>): (p: (d: Deps) => boolean) => Checker<void>;
+};
+export declare const IfM_: <A>(mp: Checker<boolean>, m1: Checker<A>, m2: Checker<A>) => Checker<A>;
+export declare const IfM: {
+    <A>(mp: Checker<boolean>, m1: Checker<A>, m2: Checker<A>): Checker<A>;
+    <A>(m1: Checker<A>, m2: Checker<A>): (mp: Checker<boolean>) => Checker<A>;
+};
+/** Create a Checker that first classifies paths to file extensions,
+ * then compares the resulting classes in the partial order generated by
+ * relations `orderRules`. More specifically, for each file with class `X`
+ * importing a file of class `Y`, we must have `X < Y` in the partial order.
+ *
+ * If either the dependent or dependency file don't match any rule in
+ * `classRules`, then the returned checker behaves as `Pure(undefined)` (i.e.,
+ * it has "no opinion" on whether the file should be allowed or rejected).
+ */
+export declare const Build: <T extends string>(classify: Classify<Classify.GlobExtension<T>>) => (partialOrder: Result<PartialOrder<Classify.GlobExtension<T>>, string>) => Checker<void>;
+type CheckerResult = {
+    deny: Deps[];
+    warn: string[];
+};
+export declare const Validate: (check: Checker<void>, deps: Deps[]) => CheckerResult;

package/dist/Checker/Opinion/Opinion.pure.d.ts

@@ -0,0 +1,25 @@
+import type { Deps } from "../Checker.pure.ts";
+/** Pure is the monad success case for checker pipelines
+  * to continue running, i.e. Pure = Undecided.
+  *
+  * All other states are failure cases,
+  * i.e. they terminate checking with a decision.
+*/
+export type Opinion<A> = {
+    _tag: "Pure";
+    Value: A;
+} | {
+    _tag: "Allow";
+} | {
+    _tag: "Deny";
+    Deps: Deps;
+} | {
+    _tag: "Warn";
+    Message: string;
+};
+export declare const Pure: <A>(a: A) => Opinion<A>;
+export declare const Allow: () => Opinion<never>;
+export declare const Deny: (d: Deps) => Opinion<never>;
+export declare const Warn: (x: string) => Opinion<never>;
+export declare const Map: <A, B>(m: Opinion<A>, f: (a: A) => B) => Opinion<B>;
+export declare const Bind: <A, B>(m: Opinion<A>, f: (t: A) => Opinion<B>) => Opinion<B>;

package/dist/Checker/Opinion/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Opinion as m } from "./Opinion.pure.ts";
+export * as Opinion from "./Opinion.pure.ts";
+export type Opinion<A> = m<A>;

package/dist/Checker/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Checker as checker } from "./Checker.pure.ts";
+export * as Checker from "./Checker.pure.ts";
+export type Checker<A> = checker<A>;

package/dist/Checker/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Classify/Classify.pure.d.ts

@@ -0,0 +1,42 @@
+import { Option, Reader } from "../Lib/pure.ts";
+type ext = string;
+export type GlobExtension<T extends string> = T | `${T}.${T}`;
+export type Classify<A> = Reader<ext, Option<A>>;
+export declare const Pure: <A>(a: A) => Classify<A>;
+export declare const None: <A = never>() => Classify<A>;
+export declare const Map_: <A, B>(m: Classify<A>, f: (a: A) => B) => import("../Lib/Reader/Reader.pure.ts").Reader<string, import("../Lib/Option/Option.pure.ts").Option<B>>;
+export declare const Map: {
+    <A, B>(m: Classify<A>, f: (a: A) => B): Classify<B>;
+    <A, B>(f: (a: A) => B): ((m: Classify<A>) => Classify<B>);
+};
+export declare const Bind_: <A, B>(m: Classify<A>, f: (t: A) => Classify<B>) => (ext: ext) => import("../Lib/Option/Option.pure.ts").Option<B>;
+export declare const Bind: {
+    <A, B>(m: Classify<A>, f: (t: A) => Classify<B>): Classify<B>;
+    <A, B>(f: (t: A) => Classify<B>): (m: Classify<A>) => Classify<B>;
+};
+export declare const BindOption_: <A, B>(m: Classify<A>, f: (a: A) => Option<B>) => Classify<B>;
+export declare const BindOption: {
+    <A, B>(m: Classify<A>, f: (a: A) => Option<B>): Classify<B>;
+    <A, B>(f: (a: A) => Option<B>): ((m: Classify<A>) => Classify<B>);
+};
+/** Fusion of Ask (Id) and Map. */
+export declare const Asks: <A>(f: (ext: ext) => A) => (ext: ext) => import("../Lib/Option/Option.pure.ts").Option<A>;
+export declare const Catch_: <A, B>(m1: Classify<A>, m2: Classify<B>) => Classify<A | B>;
+/** Recover if a classifier fails to match an extension. */
+export declare const Catch: {
+    <A, B>(m1: Classify<A>, m2: Classify<B>): Classify<A | B>;
+    <A, B>(m2: Classify<B>): (m1: Classify<A>) => Classify<A | B>;
+};
+export declare const AsksWhen_: <A extends string>(p: (ext: ext) => boolean, m: Classify<A>) => Classify<A>;
+/** Use a classifier if the filepath satisfies a predicate. */
+export declare const AsksWhen: {
+    <A extends string>(p: (ext: ext) => boolean, m: Classify<A>): Classify<A>;
+    <A extends string>(m: Classify<A>): (p: (ext: ext) => boolean) => Classify<A>;
+};
+export declare const SetWhen_: <A extends string>(p: (ext: ext) => boolean, f: (ext: ext) => A) => Classify<A>;
+/** Set the file classification if the filepath satisfies a predicate. */
+export declare const SetWhen: {
+    <A extends string>(p: (ext: ext) => boolean, f: (ext: ext) => A): Classify<A>;
+    <A extends string>(f: (ext: ext) => A): (p: (ext: ext) => boolean) => Classify<A>;
+};
+export {};

package/dist/Classify/Classify.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Classify/File.nodejs.d.ts

@@ -0,0 +1,3 @@
+import type { Classify } from "./pure.ts";
+/** Create list of filename -> extension matchers. Order does not matter. */
+export declare const Extensions: <A extends string>(extIter: Iterable<A>) => Classify<Classify.GlobExtension<A>>;

package/dist/Classify/File.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Classify/barrel.nodejs.d.ts

@@ -0,0 +1,2 @@
+export * from "./Classify.pure.ts";
+export * from "./File.nodejs.ts";

package/dist/Classify/nodejs.d.ts

@@ -0,0 +1,3 @@
+import type { Classify as m } from "./Classify.pure.ts";
+export * as Classify from "./barrel.nodejs.ts";
+export type Classify<A> = m<A>;

package/dist/Classify/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Classify as m } from "./Classify.pure.ts";
+export * as Classify from "./Classify.pure.ts";
+export type Classify<A> = m<A>;

package/dist/Classify/test.d.ts

@@ -0,0 +1,2 @@
+import "./Classify.test.ts";
+import "./File.test.ts";

package/dist/Examples/AlternativeCheckers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Examples/IsolateRuntimes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Examples/Lua.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Examples/MultipleClassifiers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Examples/OnionDiamond.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Examples/StrictOrdering.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Examples/test.d.ts

@@ -0,0 +1,6 @@
+import "./AlternativeCheckers.test.ts";
+import "./IsolateRuntimes.test.ts";
+import "./Lua.test.ts";
+import "./MultipleClassifiers.test.ts";
+import "./OnionDiamond.test.ts";
+import "./StrictOrdering.test.ts";

package/dist/Lib/Array/Array.pure.d.ts

@@ -0,0 +1,36 @@
+import { Option } from "../Option/pure.ts";
+export type Array<A> = globalThis.ReadonlyArray<A>;
+export type ArrayMut<A> = globalThis.Array<A>;
+export type NonEmpty<A> = readonly [A, ...A[]];
+export type NonEmptyMut<A> = [A, ...A[]];
+export type Infer<S extends Array<any>> = S extends Array<infer A> ? A : never;
+export type AndEmpty1<Zs extends Array<unknown>, R> = Zs extends NonEmpty<unknown> ? NonEmptyMut<R> : R[];
+export type AndEmpty2<Ys extends Array<unknown>, Zs extends Array<unknown>, R> = Zs extends NonEmptyMut<unknown> ? (Ys extends NonEmptyMut<unknown> ? NonEmptyMut<R> : R[]) : R[];
+export declare const IsNonEmpty: {
+    <A>(xs: Array<A>): xs is NonEmpty<A>;
+    <A>(xs: A[]): xs is NonEmptyMut<A>;
+};
+export declare const Bind_: <A extends Array<any>, B>(f: (a: Infer<A>, i: number) => B[]) => (xs: A) => B[];
+export declare const Bind: {
+    <A extends Array<any>, B>(xs: A, f: (a: Infer<A>, i: number) => NonEmptyMut<B>): AndEmpty1<A, B>;
+    <A extends Array<any>, B>(xs: A, f: (a: Infer<A>, i: number) => B[]): B[];
+    <A extends Array<any>, B>(f: (a: Infer<A>, i: number) => NonEmptyMut<B>): (xs: A) => AndEmpty1<A, B>;
+    <A extends Array<any>, B>(f: (a: Infer<A>, i: number) => B[]): (xs: A) => B[];
+};
+export declare const Choose_: <A, B>(xs: Array<A>, chooser: (x: A, i: number) => Option<B>) => B[];
+export declare const Choose: {
+    <A, B>(xs: Array<A>, chooser: (x: A, i: number) => Option<B>): B[];
+    <A, B>(chooser: (x: A, i: number) => Option<B>): (xs: Array<A>) => B[];
+};
+export declare const Filter_: <A>(xs: Array<A>, pred: (a: A, i: number) => boolean) => A[];
+export declare const Filter: {
+    <A, B extends A>(xs: Array<A>, refine: (a: A, i: number) => a is B): B[];
+    <A, B extends A>(refine: (a: A, i: number) => a is B): (xs: Array<A>) => B[];
+    <A>(xs: Array<A>, pred: (a: A, i: number) => boolean): A[];
+    <A>(pred: (a: NoInfer<A>, i: number) => boolean): (xs: Array<A>) => A[];
+};
+export declare const Map_: <A extends Array<any>, B>(xs: A, f: (a: Infer<A>, i: number) => B) => AndEmpty1<A, B>;
+export declare const Map: {
+    <A extends Array<any>, B>(f: (a: Infer<A>, i: number) => B): (xs: A) => AndEmpty1<A, B>;
+    <A extends Array<any>, B>(xs: A, f: (a: Infer<A>, i: number) => B): AndEmpty1<A, B>;
+};

package/dist/Lib/Array/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Array as m } from "./Array.pure.ts";
+export * as Array from "./Array.pure.ts";
+export type Array<A> = m<A>;

package/dist/Lib/Function/Curry.pure.d.ts

@@ -0,0 +1,8 @@
+/**
+* Transforms a function parameterization into two call modes:
+* 1. Unchanged.
+* 2. Partial application, with parameters rotated at the pivot point.
+*
+* Requires explicit type overloads to reflect runtime behavior. Inspired by 'dual' in Effect-TS.
+*/
+export declare const CurryRev: <Original extends (...args: Array<any>) => any, Curried extends (...args: Array<any>) => any>(body: Original) => Curried;

package/dist/Lib/Function/Flow.pure.d.ts

@@ -0,0 +1,9 @@
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never>(ab: (...a: A) => B): (...a: A) => B;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never, E = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never, E = never, F = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never, E = never, F = never, G = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): (...a: A) => H;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (...a: A) => I;
+export declare function Flow<A extends ReadonlyArray<unknown>, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (...a: A) => J;

package/dist/Lib/Function/Pipe.pure.d.ts

@@ -0,0 +1,20 @@
+export declare function Pipe<A>(a: A): A;
+export declare function Pipe<A, B = never>(a: A, ab: (a: A) => B): B;
+export declare function Pipe<A, B = never, C = never>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export declare function Pipe<A, B = never, C = never, D = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+export declare function Pipe<A, B = never, C = never, D = never, E = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): L;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): M;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N): N;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O): O;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P): P;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q): Q;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R): R;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S): S;
+export declare function Pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T): T;

package/dist/Lib/Function/pure.d.ts

@@ -0,0 +1,3 @@
+export { CurryRev } from "./Curry.pure.ts";
+export { Flow } from "./Flow.pure.ts";
+export { Pipe } from "./Pipe.pure.ts";

package/dist/Lib/Option/Option.pure.d.ts

@@ -0,0 +1,89 @@
+export type Some<A> = {
+    readonly _tag: "Some";
+    readonly value: A;
+};
+export type None<A = never> = {
+    readonly _tag: "None";
+};
+export type Option<A> = Some<A> | None<A>;
+/** Lifts a value to an Option. */
+export declare const Some: <A>(value: A) => Option<A>;
+/** Returns 'None' for a given type. */
+export declare const None: <A = never>() => Option<A>;
+/** Converts a nullable value into an Option */
+export declare const OfNullable: <A>(value: A | null | undefined) => Option<NonNullable<A>>;
+export declare const Some_Filter_: <A>(a: A, pred: (a: A) => boolean) => Option<A>;
+export declare const Some_Filter: {
+    <A>(a: A, pred: (a: A) => boolean): Option<A>;
+    <A>(pred: (a: A) => boolean): (a: A) => Option<A>;
+};
+/** Returns `true` if it is a `Some` */
+export declare const IsSome: <A>(opt: Option<A>) => opt is Some<A>;
+/** Returns `true` if it is a `None` */
+export declare const IsNone: <A>(opt: Option<A>) => opt is None<A>;
+/** Combines all Options in a tuple if they are `Some`
+ *
+ * @example All([Some(1), Some("a")]) = Some([1, "a"])
+ *
+ * @example All([Some(1), None(), None()]) = None() */
+export declare const All: <const Os extends readonly Option<unknown>[]>(os: readonly Option<unknown>[] & Os) => Option<{ [K in keyof Os]: Os[K] extends Option<infer A> ? A : never; }>;
+export declare const Bind_: <A, B>(opt: Option<A>, f: (a: A) => Option<B>) => Option<B>;
+export declare const Bind: {
+    <A, B>(opt: Option<A>, f: (a: A) => Option<B>): Option<B>;
+    <A, B>(f: (a: A) => Option<B>): (opt: Option<A>) => Option<B>;
+};
+export declare const Map_: <A, B>(opt: Option<A>, f: (a: A) => B) => Option<B>;
+export declare const Map: {
+    <A, B>(opt: Option<A>, f: (a: A) => B): Option<B>;
+    <A, B>(f: (a: A) => B): (opt: Option<A>) => Option<B>;
+};
+export declare const Catch_: <A, B>(opt: Option<A>, f: () => Option<B>) => Option<A | B>;
+export declare const Catch: {
+    <A, B>(opt: Option<A>, f: () => Option<B>): Option<A | B>;
+    <A, B>(f: () => Option<B>): (opt: Option<A>) => Option<A | B>;
+};
+/** Gets the value of a `Some`, or returns some fallback value */
+export declare const Default_: <A, B = A>(opt: Option<A>, fallback: B) => A | B;
+/** Gets the value of a `Some`, or returns some fallback value */
+export declare const Default: {
+    <A, B = A>(opt: Option<A>, fallback: B): A | B;
+    <B>(fallback: B): <A = B>(opt: Option<A>) => A | B;
+};
+/** Gets the value of a `Some`, or returns some fallback function */
+export declare const DefaultLazy_: <A, B = A>(opt: Option<A>, fallback: () => B) => A | B;
+/** Gets the value of a `Some`, or returns some fallback function */
+export declare const DefaultLazy: {
+    <A, B = A>(opt: Option<A>, fallback: () => B): A | B;
+    <B>(fallback: () => B): <A = B>(opt: Option<A>) => A | B;
+};
+export declare const Elim_: <A, B, C>(opt: Option<A>, fallback: B, f: (x: A) => C) => B | C;
+/** Applies a function to an option and then returns either the value or a fallback */
+export declare const Elim: {
+    <A, B, C>(opt: Option<A>, fallback: B, f: (x: A) => C): B | C;
+    <A, B, C>(fallback: B, f: (x: A) => C): (opt: Option<A>) => B | C;
+};
+export declare const ElimLazy_: <A, B, C>(opt: Option<A>, fallback: () => B, f: (x: A) => C) => B | C;
+/** Applies a function to an option and then returns either the value or a lazy fallback */
+export declare const ElimLazy: {
+    <A, B, C>(opt: Option<A>, fallback: () => B, f: (x: A) => C): B | C;
+    <A, B, C>(fallback: () => B, f: (x: A) => C): (opt: Option<A>) => B | C;
+};
+export declare const Match_: <A, M1, M2>(opt: Option<A>, handlers: {
+    onSome: (value: A) => M1;
+    onNone: () => M2;
+}) => M1 | M2;
+/** Performs different actions dependant on the Option being `Some` or `None` */
+export declare const Match: {
+    <A, M>(opt: Option<A>, handlers: {
+        onSome: (value: A) => M;
+        onNone: () => M;
+    }): M;
+    <A, M1, M2>(opt: Option<A>, handlers: {
+        onSome: (value: A) => M1;
+        onNone: () => M2;
+    }): M1 | M2;
+    <A, M1, M2>(handlers: {
+        onSome: (value: A) => M1;
+        onNone: () => M2;
+    }): (opt: Option<A>) => M1 | M2;
+};

package/dist/Lib/Option/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Option as m } from "./Option.pure.ts";
+export * as Option from "./Option.pure.ts";
+export type Option<A> = m<A>;

package/dist/Lib/Reader/Reader.pure.d.ts

@@ -0,0 +1,14 @@
+export type Reader<Env, A> = (env: Env) => A;
+export declare const Pure: <Env = void, A = unknown>(a: A) => Reader<Env, A>;
+export declare const Map_: <Env, A, B>(m: Reader<Env, A>, f: (a: A) => B) => Reader<Env, B>;
+export declare const Map: {
+    <Env, A, B>(m: Reader<Env, A>, f: (a: A) => B): Reader<Env, B>;
+    <Env, A, B>(f: (a: A) => B): ((m: Reader<Env, A>) => Reader<Env, B>);
+};
+export declare const Bind_: <Env, A, B>(m: Reader<Env, A>, f: (a: A) => Reader<Env, B>) => Reader<Env, B>;
+export declare const Bind: {
+    <Env, A, B>(m: Reader<Env, A>, f: (a: A) => Reader<Env, B>): Reader<Env, B>;
+    <Env, A, B>(f: (a: A) => Reader<Env, B>): ((m: Reader<Env, A>) => Reader<Env, B>);
+};
+/** Fusion of Ask (Id) and Map. */
+export declare const Asks: <Env, A>(f: (env: Env) => A) => Reader<Env, A>;

package/dist/Lib/Reader/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Reader as reader } from "./Reader.pure.ts";
+export * as Reader from "./Reader.pure.ts";
+export type Reader<Env, A> = reader<Env, A>;

package/dist/Lib/Result/Result.pure.d.ts

@@ -0,0 +1,24 @@
+export type Ok<A, E = never> = {
+    readonly _tag: "Ok";
+    readonly value: A;
+};
+export type Error<A = never, E = unknown> = {
+    readonly _tag: "Error";
+    readonly error: E;
+};
+export type Result<A, E> = Ok<A, E> | Error<A, E>;
+/** Lifts a value to a Result of type `Ok` */
+export declare const Ok: <A, E = never>(value: A) => Result<A, E>;
+/**  Lifts a value to a Result of type `Error` */
+export declare const Error: <E, A = never>(reason: E) => Result<A, E>;
+/** Returns `true` if it is an `Ok` */
+export declare const IsOk: <A, E>(res: Result<A, E>) => res is Ok<A, E>;
+/** Returns `true` if it is an `Error` */
+export declare const IsError: <A, E>(res: Result<A, E>) => res is Error<A, E>;
+export declare const Map_: <A, E, B>(res: Result<A, E>, f: (a: A) => B) => Result<B, E>;
+/** Applies some function to modify the `Ok` case */
+export declare const Map: {
+    <A, E, B>(res: Result<A, E>, f: (a: A) => B): Result<B, E>;
+    <A, B>(f: (a: A) => B): <E>(res: Result<A, E>) => Result<B, E>;
+};
+export declare const GetOrThrow: <A, E>(res: Result<A, E>) => A;

package/dist/Lib/Result/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Result as m } from "./Result.pure.ts";
+export * as Result from "./Result.pure.ts";
+export type Result<A, E> = m<A, E>;

package/dist/Lib/Set/Set.pure.d.ts

@@ -0,0 +1,11 @@
+import type { Comparable, WidenComparable } from "../Util.pure.d.ts";
+export type Set<A> = globalThis.ReadonlySet<A>;
+export type SetMut<A> = globalThis.Set<A>;
+export declare const Empty: <T>() => ReadonlySet<T>;
+export declare const Empty_Mut: <T>() => SetMut<T>;
+export declare const Singleton: <T>(x: T) => SetMut<T>;
+export declare const FromIterable: <T>(xs: Iterable<T>) => SetMut<T>;
+export declare const ToArray: <T>(set: ReadonlySet<T>) => T[];
+export declare const ToMutable: <T>(set: ReadonlySet<T>) => SetMut<T>;
+/** @alias Contains, Includes, Member */
+export declare const Has: <A extends Comparable>(xs: Set<A>, y: A | WidenComparable<A>) => y is A;

package/dist/Lib/Set/pure.d.ts

@@ -0,0 +1,3 @@
+import type { Set as m } from "./Set.pure.ts";
+export * as Set from "./Set.pure.ts";
+export type Set<A> = m<A>;