@satoshibits/functional 1.1.2 → 1.1.3

package/dist/task.test.mjs

@@ -1,1006 +0,0 @@
-"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 { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { Result } from "./result.mjs";
-import { Task } from "./task.mjs";
-describe("Task", function () {
-    describe("laziness", function () {
-        it("should not execute until run", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var effect, task, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        effect = vi.fn(function () { return Promise.resolve(42); });
-                        task = Task.fromPromise(effect);
-                        expect(effect).not.toHaveBeenCalled();
-                        return [4 /*yield*/, Task.run(task)];
-                    case 1:
-                        result = _a.sent();
-                        expect(effect).toHaveBeenCalledTimes(1);
-                        expect(result).toBe(42);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should execute each time run is called", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var effect, task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        effect = vi.fn(function () { return Promise.resolve("test"); });
-                        task = Task.fromPromise(effect);
-                        return [4 /*yield*/, Task.run(task)];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, Task.run(task)];
-                    case 2:
-                        _a.sent();
-                        expect(effect).toHaveBeenCalledTimes(2);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("of", function () {
-        it("should create a task that resolves with the value", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = Task.of(42);
-                        return [4 /*yield*/, expect(Task.run(task)).resolves.toBe(42)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should work with complex values", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var value, task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        value = { a: 1, b: "test" };
-                        task = Task.of(value);
-                        return [4 /*yield*/, expect(Task.run(task)).resolves.toEqual(value)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("fromPromise", function () {
-        it("should create a Task from a Promise-returning function", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var promiseFn, task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promiseFn = function () { return Promise.resolve(42); };
-                        task = Task.fromPromise(promiseFn);
-                        return [4 /*yield*/, expect(Task.run(task)).resolves.toBe(42)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle rejected Promises", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var promiseFn, task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promiseFn = function () { return Promise.reject(new Error("test error")); };
-                        task = Task.fromPromise(promiseFn);
-                        return [4 /*yield*/, expect(Task.run(task)).rejects.toThrow("test error")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should be lazy - not execute until run", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var effect, task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        effect = vi.fn(function () { return Promise.resolve("lazy"); });
-                        task = Task.fromPromise(effect);
-                        expect(effect).not.toHaveBeenCalled();
-                        return [4 /*yield*/, Task.run(task)];
-                    case 1:
-                        _a.sent();
-                        expect(effect).toHaveBeenCalledTimes(1);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle async functions", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var asyncFn, task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        asyncFn = function () { return __awaiter(void 0, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
-                                    case 1:
-                                        _a.sent();
-                                        return [2 /*return*/, "async result"];
-                                }
-                            });
-                        }); };
-                        task = Task.fromPromise(asyncFn);
-                        return [4 /*yield*/, expect(Task.run(task)).resolves.toBe("async result")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("run", function () {
-        beforeEach(function () {
-            vi.useFakeTimers();
-        });
-        afterEach(function () {
-            vi.useRealTimers();
-        });
-        it("should execute a Task and return a Promise", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = Task.of(100);
-                        result = Task.run(task);
-                        expect(result).toBeInstanceOf(Promise);
-                        return [4 /*yield*/, expect(result).resolves.toBe(100)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle Tasks that reject", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = function () { return Promise.reject(new Error("run error")); };
-                        result = Task.run(task);
-                        expect(result).toBeInstanceOf(Promise);
-                        return [4 /*yield*/, expect(result).rejects.toThrow("run error")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should execute complex Task chains", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = Task.chain(function (n) {
-                            return Task.chain(function (doubled) {
-                                return Task.of(doubled + 1);
-                            })(Task.of(n * 2));
-                        })(Task.of(5));
-                        return [4 /*yield*/, expect(Task.run(task)).resolves.toBe(11)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should work with Task.delay", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, promise, onDone, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = Task.chain(function () { return Task.of("done"); })(Task.delay(20));
-                        promise = Task.run(task);
-                        onDone = vi.fn();
-                        promise.then(onDone);
-                        // at 19ms, should still be pending
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(19)];
-                    case 1:
-                        // at 19ms, should still be pending
-                        _a.sent();
-                        expect(onDone).not.toHaveBeenCalled();
-                        // at 20ms, should resolve
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(1)];
-                    case 2:
-                        // at 20ms, should resolve
-                        _a.sent();
-                        return [4 /*yield*/, promise];
-                    case 3:
-                        result = _a.sent();
-                        expect(result).toBe("done");
-                        expect(onDone).toHaveBeenCalledWith("done");
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("map", function () {
-        it("should transform the resolved value", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, mapped;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = Task.of(10);
-                        mapped = Task.map(function (n) { return n * 2; })(task);
-                        return [4 /*yield*/, expect(Task.run(mapped)).resolves.toBe(20)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should not execute the original task until run", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var effect, task, mapped;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        effect = vi.fn(function () { return Promise.resolve(5); });
-                        task = Task.fromPromise(effect);
-                        mapped = Task.map(function (n) { return n + 1; })(task);
-                        expect(effect).not.toHaveBeenCalled();
-                        return [4 /*yield*/, Task.run(mapped)];
-                    case 1:
-                        _a.sent();
-                        expect(effect).toHaveBeenCalledTimes(1);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, mapped;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = Task.fromPromise(function () { return Promise.reject(new Error("fail")); });
-                        mapped = Task.map(function (n) { return n * 2; })(task);
-                        return [4 /*yield*/, expect(Task.run(mapped)).rejects.toThrow("fail")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("chain / flatMap", function () {
-        it("should sequence async operations", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task1, task2, chained;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task1 = Task.of(5);
-                        task2 = function (n) { return Task.of(n * 2); };
-                        chained = Task.chain(task2)(task1);
-                        return [4 /*yield*/, expect(Task.run(chained)).resolves.toBe(10)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("flatMap should be an alias for chain", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task1, task2, chained;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task1 = Task.of(5);
-                        task2 = function (n) { return Task.of(n * 2); };
-                        chained = Task.flatMap(task2)(task1);
-                        return [4 /*yield*/, expect(Task.run(chained)).resolves.toBe(10)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should maintain laziness through the chain", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var effect1, effect2, task1, chained;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        effect1 = vi.fn(function () { return Promise.resolve(1); });
-                        effect2 = vi.fn(function (n) { return Promise.resolve(n + 1); });
-                        task1 = Task.fromPromise(effect1);
-                        chained = Task.chain(function (n) {
-                            return Task.fromPromise(function () { return effect2(n); });
-                        })(task1);
-                        expect(effect1).not.toHaveBeenCalled();
-                        expect(effect2).not.toHaveBeenCalled();
-                        return [4 /*yield*/, Task.run(chained)];
-                    case 1:
-                        _a.sent();
-                        expect(effect1).toHaveBeenCalledTimes(1);
-                        expect(effect2).toHaveBeenCalledTimes(1);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection from first task", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task1, task2, chained;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task1 = Task.fromPromise(function () { return Promise.reject(new Error("first")); });
-                        task2 = function (n) { return Task.of(n * 2); };
-                        chained = Task.chain(task2)(task1);
-                        return [4 /*yield*/, expect(Task.run(chained)).rejects.toThrow("first")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection from second task", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task1, task2, chained;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task1 = Task.of(5);
-                        task2 = function (_n) {
-                            return Task.fromPromise(function () { return Promise.reject(new Error("second")); });
-                        };
-                        chained = Task.chain(task2)(task1);
-                        return [4 /*yield*/, expect(Task.run(chained)).rejects.toThrow("second")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("ap", function () {
-        it("should apply a task of a function to a task of a value", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var add, taskFn, taskValue, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        add = function (a) { return function (b) { return a + b; }; };
-                        taskFn = Task.of(add(5));
-                        taskValue = Task.of(3);
-                        result = Task.ap(taskValue)(taskFn);
-                        return [4 /*yield*/, expect(Task.run(result)).resolves.toBe(8)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should run tasks in parallel", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var fnResolved, valueResolved, taskFn, taskValue, result, value;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        fnResolved = false;
-                        valueResolved = false;
-                        taskFn = Task.fromPromise(function () { return __awaiter(void 0, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 20); })];
-                                    case 1:
-                                        _a.sent();
-                                        fnResolved = true;
-                                        return [2 /*return*/, function (n) { return n * 2; }];
-                                }
-                            });
-                        }); });
-                        taskValue = Task.fromPromise(function () { return __awaiter(void 0, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
-                                    case 1:
-                                        _a.sent();
-                                        valueResolved = true;
-                                        return [2 /*return*/, 5];
-                                }
-                            });
-                        }); });
-                        result = Task.ap(taskValue)(taskFn);
-                        return [4 /*yield*/, Task.run(result)];
-                    case 1:
-                        value = _a.sent();
-                        expect(value).toBe(10);
-                        expect(fnResolved).toBe(true);
-                        expect(valueResolved).toBe(true);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection from the function task", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var taskFn, taskValue, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        taskFn = Task.fromPromise(function () {
-                            return Promise.reject(new Error("function error"));
-                        });
-                        taskValue = Task.of(3);
-                        result = Task.ap(taskValue)(taskFn);
-                        return [4 /*yield*/, expect(Task.run(result)).rejects.toThrow("function error")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection from the value task", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var taskFn, taskValue, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        taskFn = Task.of(function (n) { return n * 2; });
-                        taskValue = Task.fromPromise(function () {
-                            return Promise.reject(new Error("value error"));
-                        });
-                        result = Task.ap(taskValue)(taskFn);
-                        return [4 /*yield*/, expect(Task.run(result)).rejects.toThrow("value error")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate first rejection when both reject", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var taskFn, taskValue, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        taskFn = Task.fromPromise(function () {
-                            return Promise.reject(new Error("function error"));
-                        });
-                        taskValue = Task.fromPromise(function () {
-                            return Promise.reject(new Error("value error"));
-                        });
-                        result = Task.ap(taskValue)(taskFn);
-                        // Since they run in parallel, the first to reject wins
-                        return [4 /*yield*/, expect(Task.run(result)).rejects.toThrow()];
-                    case 1:
-                        // Since they run in parallel, the first to reject wins
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("sequence", function () {
-        beforeEach(function () {
-            vi.useFakeTimers();
-        });
-        afterEach(function () {
-            vi.useRealTimers();
-        });
-        it("should convert array of tasks to task of array", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var tasks, sequenced;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tasks = [Task.of(1), Task.of(2), Task.of(3)];
-                        sequenced = Task.sequence(tasks);
-                        return [4 /*yield*/, expect(Task.run(sequenced)).resolves.toEqual([1, 2, 3])];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should run tasks in parallel", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var delays, tasks, promise, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        delays = [30, 20, 10];
-                        tasks = delays.map(function (ms) {
-                            return Task.fromPromise(function () {
-                                return new Promise(function (resolve) { return setTimeout(function () { return resolve(ms); }, ms); });
-                            });
-                        });
-                        promise = Task.run(Task.sequence(tasks));
-                        // all tasks run in parallel - advance time once by max delay (30ms)
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(30)];
-                    case 1:
-                        // all tasks run in parallel - advance time once by max delay (30ms)
-                        _a.sent();
-                        return [4 /*yield*/, promise];
-                    case 2:
-                        result = _a.sent();
-                        expect(result).toEqual([30, 20, 10]);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle empty array", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var sequenced;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        sequenced = Task.sequence([]);
-                        return [4 /*yield*/, expect(Task.run(sequenced)).resolves.toEqual([])];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate first rejection", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var tasks, sequenced;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tasks = [
-                            Task.of(1),
-                            Task.fromPromise(function () { return Promise.reject(new Error("fail")); }),
-                            Task.of(3),
-                        ];
-                        sequenced = Task.sequence(tasks);
-                        return [4 /*yield*/, expect(Task.run(sequenced)).rejects.toThrow("fail")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("traverse", function () {
-        beforeEach(function () {
-            vi.useFakeTimers();
-        });
-        afterEach(function () {
-            vi.useRealTimers();
-        });
-        it("should map and sequence", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var fn, traverse, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        fn = function (n) { return Task.of(n * 2); };
-                        traverse = Task.traverse(fn);
-                        return [4 /*yield*/, Task.run(traverse([1, 2, 3]))];
-                    case 1:
-                        result = _a.sent();
-                        expect(result).toEqual([2, 4, 6]);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle empty array", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var fn, traverse, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        fn = function (n) { return Task.of(n * 2); };
-                        traverse = Task.traverse(fn);
-                        return [4 /*yield*/, Task.run(traverse([]))];
-                    case 1:
-                        result = _a.sent();
-                        expect(result).toEqual([]);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should run in parallel", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var completed, fn, traverse, promise, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        completed = 0;
-                        fn = function (n) {
-                            return Task.fromPromise(function () { return __awaiter(void 0, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, n * 10); })];
-                                        case 1:
-                                            _a.sent();
-                                            completed++;
-                                            return [2 /*return*/, n];
-                                    }
-                                });
-                            }); });
-                        };
-                        traverse = Task.traverse(fn);
-                        promise = Task.run(traverse([3, 2, 1]));
-                        // all tasks run in parallel - advance time once by max delay (3 * 10 = 30ms)
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(30)];
-                    case 1:
-                        // all tasks run in parallel - advance time once by max delay (3 * 10 = 30ms)
-                        _a.sent();
-                        return [4 /*yield*/, promise];
-                    case 2:
-                        result = _a.sent();
-                        expect(result).toEqual([3, 2, 1]);
-                        expect(completed).toBe(3);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("sequenceT", function () {
-        it("should combine tuple of tasks", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var t1, t2, t3, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        t1 = Task.of(1);
-                        t2 = Task.of("hello");
-                        t3 = Task.of(true);
-                        return [4 /*yield*/, Task.run(Task.sequenceT(t1, t2, t3))];
-                    case 1:
-                        result = _a.sent();
-                        expect(result).toEqual([1, "hello", true]);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle empty tuple", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Task.run(Task.sequenceT())];
-                    case 1:
-                        result = _a.sent();
-                        expect(result).toEqual([]);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var t1, t2, combined;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        t1 = Task.of(1);
-                        t2 = Task.fromPromise(function () { return Promise.reject(new Error("fail")); });
-                        combined = Task.sequenceT(t1, t2);
-                        return [4 /*yield*/, expect(Task.run(combined)).rejects.toThrow("fail")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("sequenceS", function () {
-        it("should combine record of tasks", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var tasks, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tasks = {
-                            a: Task.of(1),
-                            b: Task.of("hello"),
-                            c: Task.of(true),
-                        };
-                        return [4 /*yield*/, Task.run(Task.sequenceS(tasks))];
-                    case 1:
-                        result = _a.sent();
-                        expect(result).toEqual({ a: 1, b: "hello", c: true });
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle empty record", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Task.run(Task.sequenceS({}))];
-                    case 1:
-                        result = _a.sent();
-                        expect(result).toEqual({});
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var tasks, combined;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tasks = {
-                            a: Task.of(1),
-                            b: Task.fromPromise(function () { return Promise.reject(new Error("fail")); }),
-                        };
-                        combined = Task.sequenceS(tasks);
-                        return [4 /*yield*/, expect(Task.run(combined)).rejects.toThrow("fail")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("delay", function () {
-        beforeEach(function () {
-            vi.useFakeTimers();
-        });
-        afterEach(function () {
-            vi.useRealTimers();
-        });
-        it("should delay execution", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var promise, onDone;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promise = Task.run(Task.delay(50));
-                        onDone = vi.fn();
-                        promise.then(onDone);
-                        // at 49ms, should still be pending
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(49)];
-                    case 1:
-                        // at 49ms, should still be pending
-                        _a.sent();
-                        expect(onDone).not.toHaveBeenCalled();
-                        // at 50ms, should resolve
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(1)];
-                    case 2:
-                        // at 50ms, should resolve
-                        _a.sent();
-                        return [4 /*yield*/, promise];
-                    case 3:
-                        _a.sent();
-                        expect(onDone).toHaveBeenCalled();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle zero delay", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var promise;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promise = Task.run(Task.delay(0));
-                        // advance time by 0 to process microtasks
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(0)];
-                    case 1:
-                        // advance time by 0 to process microtasks
-                        _a.sent();
-                        return [4 /*yield*/, expect(promise).resolves.toBeUndefined()];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should handle negative delay as zero delay", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var promise;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promise = Task.run(Task.delay(-100));
-                        // negative values are treated as 0 by setTimeout
-                        return [4 /*yield*/, vi.advanceTimersByTimeAsync(0)];
-                    case 1:
-                        // negative values are treated as 0 by setTimeout
-                        _a.sent();
-                        return [4 /*yield*/, expect(promise).resolves.toBeUndefined()];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("chainFirst", function () {
-        it("should execute side effect but return original value", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var sideEffect, task, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        sideEffect = vi.fn(function (n) { return Task.of("effect: ".concat(n)); });
-                        task = Task.of(42);
-                        return [4 /*yield*/, Task.run(Task.chainFirst(sideEffect)(task))];
-                    case 1:
-                        result = _a.sent();
-                        expect(result).toBe(42);
-                        expect(sideEffect).toHaveBeenCalledWith(42);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should propagate rejection from side effect", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var sideEffect, task, chained;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        sideEffect = function (_n) {
-                            return Task.fromPromise(function () { return Promise.reject(new Error("side fail")); });
-                        };
-                        task = Task.of(42);
-                        chained = Task.chainFirst(sideEffect)(task);
-                        return [4 /*yield*/, expect(Task.run(chained)).rejects.toThrow("side fail")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should maintain laziness", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var mainEffect, sideEffect, task, chained;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        mainEffect = vi.fn(function () { return Promise.resolve(10); });
-                        sideEffect = vi.fn(function (n) { return Promise.resolve("side: ".concat(n)); });
-                        task = Task.fromPromise(mainEffect);
-                        chained = Task.chainFirst(function (n) {
-                            return Task.fromPromise(function () { return sideEffect(n); });
-                        })(task);
-                        expect(mainEffect).not.toHaveBeenCalled();
-                        expect(sideEffect).not.toHaveBeenCalled();
-                        return [4 /*yield*/, Task.run(chained)];
-                    case 1:
-                        _a.sent();
-                        expect(mainEffect).toHaveBeenCalledTimes(1);
-                        expect(sideEffect).toHaveBeenCalledTimes(1);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("error handling with Result", function () {
-        it("should work with Task<Result> for explicit error handling", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var safeTask, result1, result2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        safeTask = function (n) {
-                            return n > 0
-                                ? Task.of(Result.ok(n * 2))
-                                : Task.of(Result.err("negative number"));
-                        };
-                        return [4 /*yield*/, Task.run(safeTask(5))];
-                    case 1:
-                        result1 = _a.sent();
-                        expect(result1).toEqual({ success: true, data: 10 });
-                        return [4 /*yield*/, Task.run(safeTask(-5))];
-                    case 2:
-                        result2 = _a.sent();
-                        expect(result2).toEqual({ success: false, error: "negative number" });
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("Functor laws", function () {
-        it("should satisfy identity law: map(id) ≅ id", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, id, mapped, result1, result2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        task = Task.of(42);
-                        id = function (x) { return x; };
-                        mapped = Task.map(id)(task);
-                        return [4 /*yield*/, Task.run(task)];
-                    case 1:
-                        result1 = _a.sent();
-                        return [4 /*yield*/, Task.run(mapped)];
-                    case 2:
-                        result2 = _a.sent();
-                        expect(result1).toEqual(result2);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should satisfy composition law: map(g∘f) ≅ map(g)∘map(f)", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, f, g, composed1, composed2, result1, result2;
-            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; };
-                        composed1 = Task.map(function (x) { return g(f(x)); })(task);
-                        composed2 = Task.map(g)(Task.map(f)(task));
-                        return [4 /*yield*/, Task.run(composed1)];
-                    case 1:
-                        result1 = _a.sent();
-                        return [4 /*yield*/, Task.run(composed2)];
-                    case 2:
-                        result2 = _a.sent();
-                        expect(result1).toEqual(result2);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    describe("Monad laws", function () {
-        it("should satisfy left identity: chain(f)(of(x)) ≅ f(x)", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var x, f, result1, result2;
-            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:
-                        result1 = _a.sent();
-                        return [4 /*yield*/, Task.run(f(x))];
-                    case 2:
-                        result2 = _a.sent();
-                        expect(result1).toEqual(result2);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should satisfy right identity: chain(of)(m) ≅ m", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var task, chained, result1, result2;
-            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:
-                        result1 = _a.sent();
-                        return [4 /*yield*/, Task.run(chained)];
-                    case 2:
-                        result2 = _a.sent();
-                        expect(result1).toEqual(result2);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("should satisfy 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, left, right, result1, result2;
-            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); };
-                        left = Task.chain(g)(Task.chain(f)(task));
-                        right = Task.chain(function (x) { return Task.chain(g)(f(x)); })(task);
-                        return [4 /*yield*/, Task.run(left)];
-                    case 1:
-                        result1 = _a.sent();
-                        return [4 /*yield*/, Task.run(right)];
-                    case 2:
-                        result2 = _a.sent();
-                        expect(result1).toEqual(result2);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-});
-//# sourceMappingURL=task.test.mjs.map