@lsby/ts-fp-data 0.0.5 → 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

@@ -20,7 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/func/seq.ts
 var seq_exports = {};
 __export(seq_exports, {
-  seqArrayTask: () => seqArrayTask
+  seqArrayEither: () => seqArrayEither,
+  seqArrayTask: () => seqArrayTask,
+  seqEitherArray: () => seqEitherArray,
+  seqEitherTask: () => seqEitherTask
 });
 module.exports = __toCommonJS(seq_exports);
 
@@ -104,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;
@@ -111,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()));
   }
@@ -137,7 +161,29 @@ function seqArrayTask(a) {
     return Promise.all(a.map(async (a2) => await a2.run()));
   });
 }
+function seqEitherTask(value) {
+  return value.match(
+    (err) => Task.pure(new Left(err)),
+    (data) => data.map((a) => new Right(a))
+  );
+}
+function seqEitherArray(value) {
+  return value.match(
+    (err) => [new Left(err)],
+    (data) => data.map((a) => new Right(a))
+  );
+}
+function seqArrayEither(value) {
+  const err = value.filter((a) => a.isLeft())[0];
+  if (err)
+    return err;
+  const data = value.map((a) => a.assertRight().getRight());
+  return new Right(data);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  seqArrayTask
+  seqArrayEither,
+  seqArrayTask,
+  seqEitherArray,
+  seqEitherTask
 });

package/dist/cjs/func/seq.d.cts

@@ -1,6 +1,9 @@
+import { Either } from '../data/either.cjs';
 import { Task } from '../data/task.cjs';
-import '../data/either.cjs';
 
 declare function seqArrayTask<A>(a: Array<Task<A>>): Task<Array<A>>;
+declare function seqEitherTask<L, R>(value: Either<L, Task<R>>): Task<Either<L, R>>;
+declare function seqEitherArray<A, B>(value: Either<A, Array<B>>): Array<Either<A, B>>;
+declare function seqArrayEither<A, B>(value: Array<Either<A, B>>): Either<A, Array<B>>;
 
-export { seqArrayTask };
+export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherTask };

package/dist/cjs/index.cjs

@@ -27,7 +27,11 @@ __export(src_exports, {
   Nothing: () => Nothing,
   Right: () => Right,
   Task: () => Task,
-  seqArrayTask: () => seqArrayTask
+  TaskDo: () => TaskDo,
+  seqArrayEither: () => seqArrayEither,
+  seqArrayTask: () => seqArrayTask,
+  seqEitherArray: () => seqEitherArray,
+  seqEitherTask: () => seqEitherTask
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -111,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;
@@ -118,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()));
   }
@@ -198,6 +223,25 @@ function seqArrayTask(a) {
     return Promise.all(a.map(async (a2) => await a2.run()));
   });
 }
+function seqEitherTask(value) {
+  return value.match(
+    (err) => Task.pure(new Left(err)),
+    (data) => data.map((a) => new Right(a))
+  );
+}
+function seqEitherArray(value) {
+  return value.match(
+    (err) => [new Left(err)],
+    (data) => data.map((a) => new Right(a))
+  );
+}
+function seqArrayEither(value) {
+  const err = value.filter((a) => a.isLeft())[0];
+  if (err)
+    return err;
+  const data = value.map((a) => a.assertRight().getRight());
+  return new Right(data);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Either,
@@ -207,5 +251,9 @@ function seqArrayTask(a) {
   Nothing,
   Right,
   Task,
-  seqArrayTask
+  TaskDo,
+  seqArrayEither,
+  seqArrayTask,
+  seqEitherArray,
+  seqEitherTask
 });

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 { seqArrayTask } from './func/seq.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-LVW727CO.js

@@ -0,0 +1,40 @@
+import {
+  Task
+} from "./chunk-F7Q4HROJ.js";
+import {
+  Left,
+  Right
+} from "./chunk-VTI5CRVQ.js";
+
+// src/func/seq.ts
+function seqArrayTask(a) {
+  return new Task(async () => {
+    return Promise.all(a.map(async (a2) => await a2.run()));
+  });
+}
+function seqEitherTask(value) {
+  return value.match(
+    (err) => Task.pure(new Left(err)),
+    (data) => data.map((a) => new Right(a))
+  );
+}
+function seqEitherArray(value) {
+  return value.match(
+    (err) => [new Left(err)],
+    (data) => data.map((a) => new Right(a))
+  );
+}
+function seqArrayEither(value) {
+  const err = value.filter((a) => a.isLeft())[0];
+  if (err)
+    return err;
+  const data = value.map((a) => a.assertRight().getRight());
+  return new Right(data);
+}
+
+export {
+  seqArrayTask,
+  seqEitherTask,
+  seqEitherArray,
+  seqArrayEither
+};

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.d.ts

@@ -1,6 +1,9 @@
+import { Either } from '../data/either.js';
 import { Task } from '../data/task.js';
-import '../data/either.js';
 
 declare function seqArrayTask<A>(a: Array<Task<A>>): Task<Array<A>>;
+declare function seqEitherTask<L, R>(value: Either<L, Task<R>>): Task<Either<L, R>>;
+declare function seqEitherArray<A, B>(value: Either<A, Array<B>>): Array<Either<A, B>>;
+declare function seqArrayEither<A, B>(value: Array<Either<A, B>>): Either<A, Array<B>>;
 
-export { seqArrayTask };
+export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherTask };

package/dist/esm/func/seq.js

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

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 { seqArrayTask } from './func/seq.js';
+export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherTask } from './func/seq.js';

package/dist/esm/index.js

@@ -4,11 +4,15 @@ import {
   Nothing
 } from "./chunk-PP7TCBHD.js";
 import {
-  seqArrayTask
-} from "./chunk-VP7O7XD7.js";
+  seqArrayEither,
+  seqArrayTask,
+  seqEitherArray,
+  seqEitherTask
+} from "./chunk-LVW727CO.js";
 import {
-  Task
-} from "./chunk-2AQUF5MK.js";
+  Task,
+  TaskDo
+} from "./chunk-F7Q4HROJ.js";
 import {
   Either,
   Left,
@@ -22,5 +26,9 @@ export {
   Nothing,
   Right,
   Task,
-  seqArrayTask
+  TaskDo,
+  seqArrayEither,
+  seqArrayTask,
+  seqEitherArray,
+  seqEitherTask
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsby/ts-fp-data",
-  "version": "0.0.5",
+  "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
-};

package/dist/esm/chunk-VP7O7XD7.js

@@ -1,14 +0,0 @@
-import {
-  Task
-} from "./chunk-2AQUF5MK.js";
-
-// src/func/seq.ts
-function seqArrayTask(a) {
-  return new Task(async () => {
-    return Promise.all(a.map(async (a2) => await a2.run()));
-  });
-}
-
-export {
-  seqArrayTask
-};