@lsby/ts-fp-data 0.0.6 → 0.0.7

package/dist/cjs/data/task.cjs

@@ -20,7 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/data/task.ts
 var task_exports = {};
 __export(task_exports, {
-  Task: () => Task
+  Task: () => Task,
+  TaskDo: () => TaskDo
 });
 module.exports = __toCommonJS(task_exports);
 
@@ -104,6 +105,24 @@ var Right = class _Right extends Either {
 };
 
 // src/data/task.ts
+var TaskDo = class _TaskDo {
+  constructor(accTask) {
+    this.accTask = accTask;
+  }
+  bind(name, task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+    );
+  }
+  exec(task) {
+    return new _TaskDo(this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  }
+  getTask() {
+    return new Task(async () => {
+      return (await this.accTask.run()).lastValue;
+    });
+  }
+};
 var Task = class _Task {
   constructor(f) {
     this.f = f;
@@ -111,6 +130,9 @@ var Task = class _Task {
   static pure(a) {
     return new _Task(async () => a);
   }
+  static do() {
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
+  }
   map(f) {
     return new _Task(async () => f(await this.f()));
   }
@@ -132,5 +154,6 @@ var Task = class _Task {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Task
+  Task,
+  TaskDo
 });

package/dist/cjs/data/task.d.cts

@@ -1,8 +1,24 @@
 import { Either } from './either.cjs';
 
+interface TaskDoType<Env extends Record<string, any>, A> {
+    bind<K extends string, A>(name: K, task: (env: Env) => Task<A>): TaskDoType<Env & Record<K, A>, A>;
+    exec<A>(task: (env: Env) => Task<A>): TaskDoType<Env, A>;
+    getTask(): Task<A>;
+}
+declare class TaskDo<Env extends Record<string, any>, A> implements TaskDoType<Env, A> {
+    private accTask;
+    constructor(accTask: Task<{
+        env: Env;
+        lastValue: A;
+    }>);
+    bind<K extends string, A>(name: K, task: (env: Env) => Task<A>): TaskDoType<Env & Record<K, A>, A>;
+    exec<A>(task: (env: Env) => Task<A>): TaskDoType<Env, A>;
+    getTask(): Task<A>;
+}
 declare class Task<A> {
     private f;
     static pure<A>(a: A): Task<A>;
+    static do(): TaskDo<Record<string, any>, unknown>;
     constructor(f: () => Promise<A>);
     map<B>(f: (a: A) => B): Task<B>;
     bind<B>(f: (a: A) => Task<B>): Task<B>;
@@ -10,4 +26,4 @@ declare class Task<A> {
     tryRun(): Promise<Either<Error, A>>;
 }
 
-export { Task };
+export { Task, TaskDo, type TaskDoType };

package/dist/cjs/func/seq.cjs

@@ -107,6 +107,24 @@ var Right = class _Right extends Either {
 };
 
 // src/data/task.ts
+var TaskDo = class _TaskDo {
+  constructor(accTask) {
+    this.accTask = accTask;
+  }
+  bind(name, task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+    );
+  }
+  exec(task) {
+    return new _TaskDo(this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  }
+  getTask() {
+    return new Task(async () => {
+      return (await this.accTask.run()).lastValue;
+    });
+  }
+};
 var Task = class _Task {
   constructor(f) {
     this.f = f;
@@ -114,6 +132,9 @@ var Task = class _Task {
   static pure(a) {
     return new _Task(async () => a);
   }
+  static do() {
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
+  }
   map(f) {
     return new _Task(async () => f(await this.f()));
   }

package/dist/cjs/index.cjs

@@ -27,6 +27,7 @@ __export(src_exports, {
   Nothing: () => Nothing,
   Right: () => Right,
   Task: () => Task,
+  TaskDo: () => TaskDo,
   seqArrayEither: () => seqArrayEither,
   seqArrayTask: () => seqArrayTask,
   seqEitherArray: () => seqEitherArray,
@@ -114,6 +115,24 @@ var Right = class _Right extends Either {
 };
 
 // src/data/task.ts
+var TaskDo = class _TaskDo {
+  constructor(accTask) {
+    this.accTask = accTask;
+  }
+  bind(name, task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+    );
+  }
+  exec(task) {
+    return new _TaskDo(this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  }
+  getTask() {
+    return new Task(async () => {
+      return (await this.accTask.run()).lastValue;
+    });
+  }
+};
 var Task = class _Task {
   constructor(f) {
     this.f = f;
@@ -121,6 +140,9 @@ var Task = class _Task {
   static pure(a) {
     return new _Task(async () => a);
   }
+  static do() {
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
+  }
   map(f) {
     return new _Task(async () => f(await this.f()));
   }
@@ -229,6 +251,7 @@ function seqArrayEither(value) {
   Nothing,
   Right,
   Task,
+  TaskDo,
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,

package/dist/cjs/index.d.cts

@@ -1,4 +1,4 @@
-export { Task } from './data/task.cjs';
+export { Task, TaskDo, TaskDoType } from './data/task.cjs';
 export { Just, Maybe, Nothing } from './data/maybe.cjs';
 export { Either, Left, Right } from './data/either.cjs';
 export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherTask } from './func/seq.cjs';

package/dist/esm/chunk-F7Q4HROJ.js

@@ -0,0 +1,58 @@
+import {
+  Left,
+  Right
+} from "./chunk-VTI5CRVQ.js";
+
+// src/data/task.ts
+var TaskDo = class _TaskDo {
+  constructor(accTask) {
+    this.accTask = accTask;
+  }
+  bind(name, task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+    );
+  }
+  exec(task) {
+    return new _TaskDo(this.accTask.bind((a) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  }
+  getTask() {
+    return new Task(async () => {
+      return (await this.accTask.run()).lastValue;
+    });
+  }
+};
+var Task = class _Task {
+  constructor(f) {
+    this.f = f;
+  }
+  static pure(a) {
+    return new _Task(async () => a);
+  }
+  static do() {
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
+  }
+  map(f) {
+    return new _Task(async () => f(await this.f()));
+  }
+  bind(f) {
+    return new _Task(async () => f(await this.f()).run());
+  }
+  run() {
+    return this.f();
+  }
+  async tryRun() {
+    try {
+      return new Right(await this.run());
+    } catch (e) {
+      if (e instanceof Error)
+        return new Left(e);
+      return new Left(new Error(String(e)));
+    }
+  }
+};
+
+export {
+  TaskDo,
+  Task
+};

package/dist/esm/{chunk-M4F5SG35.js → chunk-LVW727CO.js}

@@ -1,6 +1,6 @@
 import {
   Task
-} from "./chunk-2AQUF5MK.js";
+} from "./chunk-F7Q4HROJ.js";
 import {
   Left,
   Right

package/dist/esm/data/task.d.ts

@@ -1,8 +1,24 @@
 import { Either } from './either.js';
 
+interface TaskDoType<Env extends Record<string, any>, A> {
+    bind<K extends string, A>(name: K, task: (env: Env) => Task<A>): TaskDoType<Env & Record<K, A>, A>;
+    exec<A>(task: (env: Env) => Task<A>): TaskDoType<Env, A>;
+    getTask(): Task<A>;
+}
+declare class TaskDo<Env extends Record<string, any>, A> implements TaskDoType<Env, A> {
+    private accTask;
+    constructor(accTask: Task<{
+        env: Env;
+        lastValue: A;
+    }>);
+    bind<K extends string, A>(name: K, task: (env: Env) => Task<A>): TaskDoType<Env & Record<K, A>, A>;
+    exec<A>(task: (env: Env) => Task<A>): TaskDoType<Env, A>;
+    getTask(): Task<A>;
+}
 declare class Task<A> {
     private f;
     static pure<A>(a: A): Task<A>;
+    static do(): TaskDo<Record<string, any>, unknown>;
     constructor(f: () => Promise<A>);
     map<B>(f: (a: A) => B): Task<B>;
     bind<B>(f: (a: A) => Task<B>): Task<B>;
@@ -10,4 +26,4 @@ declare class Task<A> {
     tryRun(): Promise<Either<Error, A>>;
 }
 
-export { Task };
+export { Task, TaskDo, type TaskDoType };

package/dist/esm/data/task.js

@@ -1,7 +1,9 @@
 import {
-  Task
-} from "../chunk-2AQUF5MK.js";
+  Task,
+  TaskDo
+} from "../chunk-F7Q4HROJ.js";
 import "../chunk-VTI5CRVQ.js";
 export {
-  Task
+  Task,
+  TaskDo
 };

package/dist/esm/func/seq.js

@@ -3,8 +3,8 @@ import {
   seqArrayTask,
   seqEitherArray,
   seqEitherTask
-} from "../chunk-M4F5SG35.js";
-import "../chunk-2AQUF5MK.js";
+} from "../chunk-LVW727CO.js";
+import "../chunk-F7Q4HROJ.js";
 import "../chunk-VTI5CRVQ.js";
 export {
   seqArrayEither,

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
-export { Task } from './data/task.js';
+export { Task, TaskDo, TaskDoType } from './data/task.js';
 export { Just, Maybe, Nothing } from './data/maybe.js';
 export { Either, Left, Right } from './data/either.js';
 export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherTask } from './func/seq.js';

package/dist/esm/index.js

@@ -8,10 +8,11 @@ import {
   seqArrayTask,
   seqEitherArray,
   seqEitherTask
-} from "./chunk-M4F5SG35.js";
+} from "./chunk-LVW727CO.js";
 import {
-  Task
-} from "./chunk-2AQUF5MK.js";
+  Task,
+  TaskDo
+} from "./chunk-F7Q4HROJ.js";
 import {
   Either,
   Left,
@@ -25,6 +26,7 @@ export {
   Nothing,
   Right,
   Task,
+  TaskDo,
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsby/ts-fp-data",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "exports": {
     "require": "./dist/cjs/index.cjs",
@@ -36,6 +36,7 @@
     "other:pub": "npm run other:typecheck && npm run build:all && bumpp && pnpm -r publish --access public",
     "other:typecheck": "tsc --noEmit",
     "other:typecheck:watch": "tsc --noEmit -w",
-    "run:start": "tsx src/index.ts"
+    "run:start": "tsx src/index.ts",
+    "run:test": "tsx test/index.ts"
   }
 }

package/dist/esm/chunk-2AQUF5MK.js

@@ -1,36 +0,0 @@
-import {
-  Left,
-  Right
-} from "./chunk-VTI5CRVQ.js";
-
-// src/data/task.ts
-var Task = class _Task {
-  constructor(f) {
-    this.f = f;
-  }
-  static pure(a) {
-    return new _Task(async () => a);
-  }
-  map(f) {
-    return new _Task(async () => f(await this.f()));
-  }
-  bind(f) {
-    return new _Task(async () => f(await this.f()).run());
-  }
-  run() {
-    return this.f();
-  }
-  async tryRun() {
-    try {
-      return new Right(await this.run());
-    } catch (e) {
-      if (e instanceof Error)
-        return new Left(e);
-      return new Left(new Error(String(e)));
-    }
-  }
-};
-
-export {
-  Task
-};