@satoshibits/functional 1.1.0 → 1.1.2

package/dist/laws.test.mjs

@@ -0,0 +1,614 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { describe, expect, it } from "vitest";
+import { IO } from "./io.mjs";
+import { none, Option, some } from "./option.mjs";
+import { Reader } from "./reader.mjs";
+import { Result } from "./result.mjs";
+import { Task } from "./task.mjs";
+/**
+ * Algebraic law tests for functional types.
+ * These tests verify that our implementations satisfy the mathematical laws
+ * required for functors, monads, and applicatives.
+ */
+describe("Algebraic Laws", function () {
+    // generic identity function
+    var id = function (x) { return x; };
+    describe("Task Laws", function () {
+        describe("Functor Laws", function () {
+            it("identity: map(id) ≅ id", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var task, mapped, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            task = Task.of(42);
+                            mapped = Task.map(id)(task);
+                            return [4 /*yield*/, Task.run(task)];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(mapped)];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("composition: map(g∘f) ≅ map(g)∘map(f)", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var task, f, g, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            task = Task.of(10);
+                            f = function (n) { return n * 2; };
+                            g = function (n) { return n + 1; };
+                            return [4 /*yield*/, Task.run(Task.map(function (x) { return g(f(x)); })(task))];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(Task.map(g)(Task.map(f)(task)))];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        describe("Monad Laws", function () {
+            it("left identity: chain(f)(of(x)) ≅ f(x)", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var x, f, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            x = 42;
+                            f = function (n) { return Task.of(n * 2); };
+                            return [4 /*yield*/, Task.run(Task.chain(f)(Task.of(x)))];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(f(x))];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("right identity: chain(of)(m) ≅ m", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var task, chained, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            task = Task.of(42);
+                            chained = Task.chain(Task.of)(task);
+                            return [4 /*yield*/, Task.run(task)];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(chained)];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("associativity: chain(g)(chain(f)(m)) ≅ chain(x => chain(g)(f(x)))(m)", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var task, f, g, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            task = Task.of(10);
+                            f = function (n) { return Task.of(n * 2); };
+                            g = function (n) { return Task.of(n + 1); };
+                            return [4 /*yield*/, Task.run(Task.chain(g)(Task.chain(f)(task)))];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(Task.chain(function (x) { return Task.chain(g)(f(x)); })(task))];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        describe("Applicative Laws", function () {
+            it("identity: ap(of(id))(v) ≅ v", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var value, identity, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            value = Task.of(42);
+                            identity = Task.of(id);
+                            return [4 /*yield*/, Task.run(Task.ap(value)(identity))];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(value)];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("composition: ap(ap(ap(of(compose))(u))(v))(w) ≅ ap(u)(ap(v)(w))", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var compose, u, v, w, step1, step2, r1, innerAp, outerAp, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            compose = function (g) { return function (f) { return function (x) { return g(f(x)); }; }; };
+                            u = Task.of(function (n) { return n * 2; });
+                            v = Task.of(function (n) { return n + 10; });
+                            w = Task.of(5);
+                            step1 = Task.ap(u)(Task.of(compose));
+                            step2 = Task.ap(v)(step1);
+                            return [4 /*yield*/, Task.run(Task.ap(w)(step2))];
+                        case 1:
+                            r1 = _a.sent();
+                            innerAp = Task.ap(w)(v);
+                            outerAp = Task.ap(innerAp)(u);
+                            return [4 /*yield*/, Task.run(outerAp)];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("homomorphism: ap(of(x))(of(f)) ≅ of(f(x))", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var f, x, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            f = function (n) { return n * 2; };
+                            x = 42;
+                            return [4 /*yield*/, Task.run(Task.ap(Task.of(x))(Task.of(f)))];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(Task.of(f(x)))];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it("interchange: ap(of(y))(u) ≅ ap(u)(of(f => f(y)))", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var y, u, r1, r2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            y = 42;
+                            u = Task.of(function (n) { return n * 2; });
+                            return [4 /*yield*/, Task.run(Task.ap(Task.of(y))(u))];
+                        case 1:
+                            r1 = _a.sent();
+                            return [4 /*yield*/, Task.run(Task.ap(u)(Task.of(function (f) { return f(y); })))];
+                        case 2:
+                            r2 = _a.sent();
+                            expect(r1).toEqual(r2);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    describe("IO Laws", function () {
+        describe("Functor Laws", function () {
+            it("identity: map(id) ≅ id", function () {
+                var io = IO.of(42);
+                var mapped = IO.map(id)(io);
+                expect(IO.run(io)).toEqual(IO.run(mapped));
+            });
+            it("composition: map(g∘f) ≅ map(g)∘map(f)", function () {
+                var io = IO.of(10);
+                var f = function (n) { return n * 2; };
+                var g = function (n) { return n + 1; };
+                var r1 = IO.run(IO.map(function (x) { return g(f(x)); })(io));
+                var r2 = IO.run(IO.map(g)(IO.map(f)(io)));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Applicative Laws", function () {
+            it("identity: ap(of(id))(v) ≅ v", function () {
+                var value = IO.of(42);
+                var identity = IO.of(id);
+                var r1 = IO.run(IO.ap(value)(identity));
+                var r2 = IO.run(value);
+                expect(r1).toEqual(r2);
+            });
+            it("composition: ap(ap(ap(of(compose))(u))(v))(w) ≅ ap(u)(ap(v)(w))", function () {
+                var compose = function (g) { return function (f) { return function (x) { return g(f(x)); }; }; };
+                var u = IO.of(function (n) { return n * 2; });
+                var v = IO.of(function (n) { return n + 10; });
+                var w = IO.of(5);
+                // Left side: compose via lifted compose function
+                var step1 = IO.ap(u)(IO.of(compose));
+                var step2 = IO.ap(v)(step1);
+                var r1 = IO.run(IO.ap(w)(step2));
+                // Right side: direct composition
+                var innerAp = IO.ap(w)(v);
+                var outerAp = IO.ap(innerAp)(u);
+                var r2 = IO.run(outerAp);
+                expect(r1).toEqual(r2);
+            });
+            it("homomorphism: ap(of(x))(of(f)) ≅ of(f(x))", function () {
+                var f = function (n) { return n * 2; };
+                var x = 42;
+                var r1 = IO.run(IO.ap(IO.of(x))(IO.of(f)));
+                var r2 = IO.run(IO.of(f(x)));
+                expect(r1).toEqual(r2);
+            });
+            it("interchange: ap(of(y))(u) ≅ ap(u)(of(f => f(y)))", function () {
+                var y = 42;
+                var u = IO.of(function (n) { return n * 2; });
+                var r1 = IO.run(IO.ap(IO.of(y))(u));
+                var r2 = IO.run(IO.ap(u)(IO.of(function (f) { return f(y); })));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Monad Laws", function () {
+            it("left identity: chain(f)(of(x)) ≅ f(x)", function () {
+                var x = 42;
+                var f = function (n) { return IO.of(n * 2); };
+                var r1 = IO.run(IO.chain(f)(IO.of(x)));
+                var r2 = IO.run(f(x));
+                expect(r1).toEqual(r2);
+            });
+            it("right identity: chain(of)(m) ≅ m", function () {
+                var io = IO.of(42);
+                var chained = IO.chain(IO.of)(io);
+                expect(IO.run(io)).toEqual(IO.run(chained));
+            });
+            it("associativity: chain(g)(chain(f)(m)) ≅ chain(x => chain(g)(f(x)))(m)", function () {
+                var io = IO.of(10);
+                var f = function (n) { return IO.of(n * 2); };
+                var g = function (n) { return IO.of(n + 1); };
+                var r1 = IO.run(IO.chain(g)(IO.chain(f)(io)));
+                var r2 = IO.run(IO.chain(function (x) { return IO.chain(g)(f(x)); })(io));
+                expect(r1).toEqual(r2);
+            });
+        });
+    });
+    describe("Reader Laws", function () {
+        var testEnv = { multiplier: 2, offset: 10 };
+        describe("Functor Laws", function () {
+            it("identity: map(id) ≅ id", function () {
+                var reader = Reader.of(42);
+                var mapped = Reader.map(id)(reader);
+                expect(Reader.run(testEnv)(reader)).toEqual(Reader.run(testEnv)(mapped));
+            });
+            it("composition: map(g∘f) ≅ map(g)∘map(f)", function () {
+                var reader = Reader.asks(function (env) { return env.multiplier; });
+                var f = function (n) { return n * 2; };
+                var g = function (n) { return n + 1; };
+                var r1 = Reader.run(testEnv)(Reader.map(function (x) { return g(f(x)); })(reader));
+                var r2 = Reader.run(testEnv)(Reader.map(g)(Reader.map(f)(reader)));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Applicative Laws", function () {
+            it("identity: ap(of(id))(v) ≅ v", function () {
+                var value = Reader.of(42);
+                var identity = Reader.of(id);
+                var r1 = Reader.run(testEnv)(Reader.ap(value)(identity));
+                var r2 = Reader.run(testEnv)(value);
+                expect(r1).toEqual(r2);
+            });
+            it("composition: ap(ap(ap(of(compose))(u))(v))(w) ≅ ap(u)(ap(v)(w))", function () {
+                var compose = function (g) { return function (f) { return function (x) { return g(f(x)); }; }; };
+                var u = Reader.of(function (n) { return n * 2; });
+                var v = Reader.of(function (n) { return n + 10; });
+                var w = Reader.of(5);
+                // Left side: compose via lifted compose function
+                var composeReader = Reader.of(compose);
+                var applyU = Reader.ap(u)(composeReader);
+                var applyV = Reader.ap(v)(applyU);
+                var r1 = Reader.run(testEnv)(Reader.ap(w)(applyV));
+                // Right side: direct composition
+                var r2 = Reader.run(testEnv)(Reader.ap(Reader.ap(w)(v))(u));
+                expect(r1).toEqual(r2);
+            });
+            it("homomorphism: ap(of(x))(of(f)) ≅ of(f(x))", function () {
+                var f = function (n) { return n * 2; };
+                var x = 42;
+                var r1 = Reader.run(testEnv)(Reader.ap(Reader.of(x))(Reader.of(f)));
+                var r2 = Reader.run(testEnv)(Reader.of(f(x)));
+                expect(r1).toEqual(r2);
+            });
+            it("interchange: ap(of(y))(u) ≅ ap(u)(of(f => f(y)))", function () {
+                var y = 42;
+                var u = Reader.of(function (n) { return n * 2; });
+                var r1 = Reader.run(testEnv)(Reader.ap(Reader.of(y))(u));
+                var r2 = Reader.run(testEnv)(Reader.ap(u)(Reader.of(function (f) { return f(y); })));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Monad Laws", function () {
+            it("left identity: chain(f)(of(x)) ≅ f(x)", function () {
+                var x = 42;
+                var f = function (n) {
+                    return Reader.asks(function (env) { return n * env.multiplier; });
+                };
+                var r1 = Reader.run(testEnv)(Reader.chain(f)(Reader.of(x)));
+                var r2 = Reader.run(testEnv)(f(x));
+                expect(r1).toEqual(r2);
+            });
+            it("right identity: chain(of)(m) ≅ m", function () {
+                var reader = Reader.asks(function (env) { return env.offset; });
+                var chained = Reader.chain(Reader.of)(reader);
+                expect(Reader.run(testEnv)(reader)).toEqual(Reader.run(testEnv)(chained));
+            });
+            it("associativity: chain(g)(chain(f)(m)) ≅ chain(x => chain(g)(f(x)))(m)", function () {
+                var reader = Reader.of(10);
+                var f = function (n) {
+                    return Reader.asks(function (env) { return n * env.multiplier; });
+                };
+                var g = function (n) {
+                    return Reader.asks(function (env) { return n + env.offset; });
+                };
+                var r1 = Reader.run(testEnv)(Reader.chain(g)(Reader.chain(f)(reader)));
+                var r2 = Reader.run(testEnv)(Reader.chain(function (x) { return Reader.chain(g)(f(x)); })(reader));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Reader-specific Laws", function () {
+            it("ask law: run(env)(ask) ≅ env", function () {
+                var reader = Reader.ask();
+                expect(Reader.run(testEnv)(reader)).toEqual(testEnv);
+            });
+            it("asks law: run(env)(asks(f)) ≅ f(env)", function () {
+                var f = function (env) { return env.multiplier * env.offset; };
+                var reader = Reader.asks(f);
+                expect(Reader.run(testEnv)(reader)).toEqual(f(testEnv));
+            });
+            it("local law: run(env)(local(f)(r)) ≅ run(f(env))(r)", function () {
+                var outerEnv = { inner: testEnv };
+                var reader = Reader.asks(function (env) { return env.multiplier; });
+                var f = function (outer) { return outer.inner; };
+                var r1 = Reader.run(outerEnv)(Reader.local(f)(reader));
+                var r2 = Reader.run(f(outerEnv))(reader);
+                expect(r1).toEqual(r2);
+            });
+        });
+    });
+    describe("Result Laws", function () {
+        describe("Functor Laws", function () {
+            it("identity: map(id) ≅ id", function () {
+                var ok = Result.ok(42);
+                var err = Result.err("error");
+                expect(Result.map(id)(ok)).toEqual(ok);
+                expect(Result.map(id)(err)).toEqual(err);
+            });
+            it("composition: map(g∘f) ≅ map(g)∘map(f)", function () {
+                var result = Result.ok(10);
+                var f = function (n) { return n * 2; };
+                var g = function (n) { return n + 1; };
+                var r1 = Result.map(function (x) { return g(f(x)); })(result);
+                var r2 = Result.map(g)(Result.map(f)(result));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Applicative Laws", function () {
+            it("identity: ap(of(id))(v) ≅ v", function () {
+                var value = Result.ok(42);
+                var identity = Result.ok(id);
+                var r1 = Result.ap(value)(identity);
+                var r2 = value;
+                expect(r1).toEqual(r2);
+            });
+            it("composition: ap(ap(ap(of(compose))(u))(v))(w) ≅ ap(u)(ap(v)(w))", function () {
+                var compose = function (g) { return function (f) { return function (x) { return g(f(x)); }; }; };
+                var u = Result.ok(function (n) { return n * 2; });
+                var v = Result.ok(function (n) { return n + 10; });
+                var w = Result.ok(5);
+                // Left side: compose via lifted compose function
+                var step1 = Result.ap(u)(Result.ok(compose));
+                var step2 = Result.ap(v)(step1);
+                var r1 = Result.ap(w)(step2);
+                // Right side: direct composition
+                var innerAp = Result.ap(w)(v);
+                var outerAp = Result.ap(innerAp)(u);
+                var r2 = outerAp;
+                expect(r1).toEqual(r2);
+            });
+            it("homomorphism: ap(of(x))(of(f)) ≅ of(f(x))", function () {
+                var f = function (n) { return n * 2; };
+                var x = 42;
+                var r1 = Result.ap(Result.ok(x))(Result.ok(f));
+                var r2 = Result.ok(f(x));
+                expect(r1).toEqual(r2);
+            });
+            it("interchange: ap(of(y))(u) ≅ ap(u)(of(f => f(y)))", function () {
+                var y = 42;
+                var u = Result.ok(function (n) { return n * 2; });
+                var r1 = Result.ap(Result.ok(y))(u);
+                var r2 = Result.ap(u)(Result.ok(function (f) { return f(y); }));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Monad Laws", function () {
+            it("left identity: chain(f)(of(x)) ≅ f(x)", function () {
+                var x = 42;
+                var f = function (n) {
+                    return n > 0 ? Result.ok(n * 2) : Result.err("negative");
+                };
+                var r1 = Result.flatMap(f)(Result.ok(x));
+                var r2 = f(x);
+                expect(r1).toEqual(r2);
+            });
+            it("right identity: chain(of)(m) ≅ m", function () {
+                var result = Result.ok(42);
+                var chained = Result.flatMap(Result.ok)(result);
+                expect(result).toEqual(chained);
+            });
+            it("associativity: chain(g)(chain(f)(m)) ≅ chain(x => chain(g)(f(x)))(m)", function () {
+                var result = Result.ok(10);
+                var f = function (n) { return Result.ok(n * 2); };
+                var g = function (n) { return Result.ok(n + 1); };
+                var r1 = Result.flatMap(g)(Result.flatMap(f)(result));
+                var r2 = Result.flatMap(function (x) { return Result.flatMap(g)(f(x)); })(result);
+                expect(r1).toEqual(r2);
+            });
+        });
+    });
+    describe("Option Laws", function () {
+        describe("Functor Laws", function () {
+            it("identity: map(id) ≅ id", function () {
+                var someVal = some(42);
+                var noneVal = none();
+                expect(Option.map(id)(someVal)).toEqual(someVal);
+                expect(Option.map(id)(noneVal)).toEqual(noneVal);
+            });
+            it("composition: map(g∘f) ≅ map(g)∘map(f)", function () {
+                var option = some(10);
+                var f = function (n) { return n * 2; };
+                var g = function (n) { return n + 1; };
+                var r1 = Option.map(function (x) { return g(f(x)); })(option);
+                var r2 = Option.map(g)(Option.map(f)(option));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Applicative Laws", function () {
+            it("identity: ap(of(id))(v) ≅ v", function () {
+                var value = some(42);
+                var identity = some(id);
+                var r1 = Option.ap(value)(identity);
+                var r2 = value;
+                expect(r1).toEqual(r2);
+            });
+            it("composition: ap(ap(ap(of(compose))(u))(v))(w) ≅ ap(u)(ap(v)(w))", function () {
+                var compose = function (g) { return function (f) { return function (x) { return g(f(x)); }; }; };
+                var u = some(function (n) { return n * 2; });
+                var v = some(function (n) { return n + 10; });
+                var w = some(5);
+                // Left side: compose via lifted compose function
+                var step1 = Option.ap(u)(some(compose));
+                var step2 = Option.ap(v)(step1);
+                var r1 = Option.ap(w)(step2);
+                // Right side: direct composition
+                var innerAp = Option.ap(w)(v);
+                var outerAp = Option.ap(innerAp)(u);
+                var r2 = outerAp;
+                expect(r1).toEqual(r2);
+            });
+            it("homomorphism: ap(of(x))(of(f)) ≅ of(f(x))", function () {
+                var f = function (n) { return n * 2; };
+                var x = 42;
+                var r1 = Option.ap(some(x))(some(f));
+                var r2 = some(f(x));
+                expect(r1).toEqual(r2);
+            });
+            it("interchange: ap(of(y))(u) ≅ ap(u)(of(f => f(y)))", function () {
+                var y = 42;
+                var u = some(function (n) { return n * 2; });
+                var r1 = Option.ap(some(y))(u);
+                var r2 = Option.ap(u)(some(function (f) { return f(y); }));
+                expect(r1).toEqual(r2);
+            });
+        });
+        describe("Monad Laws", function () {
+            it("left identity: chain(f)(of(x)) ≅ f(x)", function () {
+                var x = 42;
+                var f = function (n) { return (n > 0 ? some(n * 2) : none()); };
+                var r1 = Option.flatMap(f)(some(x));
+                var r2 = f(x);
+                expect(r1).toEqual(r2);
+            });
+            it("right identity: chain(of)(m) ≅ m", function () {
+                var option = some(42);
+                var chained = Option.flatMap(some)(option);
+                expect(option).toEqual(chained);
+            });
+            it("associativity: chain(g)(chain(f)(m)) ≅ chain(x => chain(g)(f(x)))(m)", function () {
+                var option = some(10);
+                var f = function (n) { return some(n * 2); };
+                var g = function (n) { return some(n + 1); };
+                var r1 = Option.flatMap(g)(Option.flatMap(f)(option));
+                var r2 = Option.flatMap(function (x) { return Option.flatMap(g)(f(x)); })(option);
+                expect(r1).toEqual(r2);
+            });
+        });
+    });
+    describe("Cross-type Law Consistency", function () {
+        it("all types should handle identity consistently", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var value, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        value = 42;
+                        // all should preserve the value through identity
+                        _a = expect;
+                        return [4 /*yield*/, Task.run(Task.map(id)(Task.of(value)))];
+                    case 1:
+                        // all should preserve the value through identity
+                        _a.apply(void 0, [_b.sent()]).toBe(value);
+                        expect(IO.run(IO.map(id)(IO.of(value)))).toBe(value);
+                        expect(Reader.run({})(Reader.map(id)(Reader.of(value)))).toBe(value);
+                        expect(Result.map(id)(Result.ok(value))).toEqual(Result.ok(value));
+                        expect(Option.map(id)(some(value))).toEqual(some(value));
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("all types should handle composition consistently", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var f, g, compose, value, expected, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        f = function (n) { return n * 2; };
+                        g = function (n) { return n + 1; };
+                        compose = function (x) { return g(f(x)); };
+                        value = 10;
+                        expected = 21;
+                        // all should produce the same result
+                        _a = expect;
+                        return [4 /*yield*/, Task.run(Task.map(compose)(Task.of(value)))];
+                    case 1:
+                        // all should produce the same result
+                        _a.apply(void 0, [_b.sent()]).toBe(expected);
+                        expect(IO.run(IO.map(compose)(IO.of(value)))).toBe(expected);
+                        expect(Reader.run({})(Reader.map(compose)(Reader.of(value)))).toBe(expected);
+                        expect(Result.map(compose)(Result.ok(value))).toEqual(Result.ok(expected));
+                        expect(Option.map(compose)(some(value))).toEqual(some(expected));
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+//# sourceMappingURL=laws.test.mjs.map