@lsby/ts-fp-data 0.0.9-beta.1 → 0.0.9-beta.3

package/dist/cjs/data/task.cjs

@@ -112,37 +112,50 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(
-          (v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false })
-        )
+        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   bind(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false }))
+        (a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   exec(task) {
     return new _TaskDo(
-      this.accTask.bind((a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(() => Task.pure(a)))
+      this.accTask.bind((a) => task(a.env).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  effect(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  pure(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v })))
     );
   }
-  pure(value) {
+  if(cond, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v, lock: false }))
+        (a) => Task.pure(cond(a.env)).bind(
+          (c) => c ? Task.pure(task(a.env)).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({
+            env: a.env,
+            /*从类型可以确保if没命中的情况pureIf来补充正确的候选值, 所以这里跳过ts检查*/
+            lastValue: a.lastValue,
+            lock: false
+          })
+        )
       )
     );
   }
-  if(cond, value) {
+  pureR(task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(cond(a.env)).bind(
-          (c) => c ? value(a.env).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({ env: a.env, lastValue: a.lastValue, lock: false })
-        )
+        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v }))
       )
     );
   }
@@ -160,7 +173,7 @@ var Task = class _Task {
     return new _Task(async () => a);
   }
   static do() {
-    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0, lock: false })));
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
   }
   map(f) {
     return new _Task(async () => f(await this.f()));
@@ -171,6 +184,9 @@ var Task = class _Task {
   run() {
     return this.f();
   }
+  do() {
+    return new TaskDo(this.bind((a) => _Task.pure({ env: {}, lastValue: a })));
+  }
   async tryRun() {
     try {
       return new Right(await this.run());

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

@@ -1,36 +1,51 @@
 import { Either } from './either.cjs';
 
-interface TaskDoType<Env extends Record<string, any>, A> {
-    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoType<Env & Record<K, X>, A>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, A>;
-    exec(task: (env: Env) => void): TaskDoType<Env, A>;
-    pure(value: A): TaskDoType<Env, A>;
-    if(cond: (env: Env) => boolean, value: (env: Env) => Task<A>): TaskDoType<Env, A>;
+type TaskDoTypeBase<Env extends Record<string, any>, A> = {
+    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    exec<X>(task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env, A>;
+    effect<X>(task: (env: Env) => X): TaskDoTypeNoGet<Env, A>;
+};
+type TaskDoTypeReturn<Env extends Record<string, any>, _A> = {
+    pure<X>(task: (env: Env) => X): TaskDoTypeGet<Env, X>;
+};
+type TaskDoTypeIf<Env extends Record<string, any>, _A> = {
+    if<X>(cond: (env: Env) => boolean, task: (env: Env) => X): TaskDoTypeIfReturn<Env, X>;
+};
+type TaskDoTypeIfReturn<Env extends Record<string, any>, A> = {
+    pureR(task: (env: Env) => A): TaskDoTypeGet<Env, A>;
+};
+type TaskDoTypeGet<_Env extends Record<string, any>, A> = {
     getTask(): Task<A>;
-}
+};
+type TaskDoTypeNoGet<Env extends Record<string, any>, A> = TaskDoTypeBase<Env, A> & TaskDoTypeReturn<Env, A> & TaskDoTypeIf<Env, A>;
+type TaskDoType<Env extends Record<string, any>, A> = TaskDoTypeBase<Env, A> & TaskDoTypeReturn<Env, A> & TaskDoTypeGet<Env, A> & TaskDoTypeIf<Env, A> & TaskDoTypeIfReturn<Env, A>;
 declare class TaskDo<Env extends Record<string, any>, A> implements TaskDoType<Env, A> {
     private accTask;
     constructor(accTask: Task<{
         env: Env;
         lastValue: A;
-        lock: boolean;
+        lock?: boolean;
     }>);
-    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoType<Env & Record<K, X>, A>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, A>;
-    exec(task: (env: Env) => void): TaskDoType<Env, A>;
-    pure(value: A): TaskDoType<Env, A>;
-    if(cond: (env: Env) => boolean, value: (env: Env) => Task<A>): TaskDoType<Env, A>;
+    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    exec<X>(task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env, A>;
+    effect<X>(task: (env: Env) => X): TaskDoTypeNoGet<Env, A>;
+    pure<X>(task: (env: Env) => X): TaskDoTypeGet<Env, X>;
+    if<X>(cond: (env: Env) => boolean, task: (env: Env) => X): TaskDoTypeIfReturn<Env, X>;
+    pureR(task: (env: Env) => A): TaskDoTypeGet<Env, A>;
     getTask(): Task<A>;
 }
 declare class Task<A> {
     private f;
     static pure<A>(a: A): Task<A>;
-    static do(): TaskDo<Record<string, any>, void>;
+    static do(): TaskDoTypeBase<Record<string, any>, void>;
     constructor(f: () => Promise<A>);
     map<B>(f: (a: A) => B): Task<B>;
     bind<B>(f: (a: A) => Task<B>): Task<B>;
     run(): Promise<A>;
+    do(): TaskDoTypeBase<{}, A>;
     tryRun(): Promise<Either<Error, A>>;
 }
 
-export { Task, TaskDo, type TaskDoType };
+export { Task, TaskDo, type TaskDoType, type TaskDoTypeBase, type TaskDoTypeGet, type TaskDoTypeIf, type TaskDoTypeIfReturn, type TaskDoTypeNoGet, type TaskDoTypeReturn };

package/dist/cjs/func/seq.cjs

@@ -114,37 +114,50 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(
-          (v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false })
-        )
+        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   bind(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false }))
+        (a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   exec(task) {
     return new _TaskDo(
-      this.accTask.bind((a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(() => Task.pure(a)))
+      this.accTask.bind((a) => task(a.env).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  effect(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  pure(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v })))
     );
   }
-  pure(value) {
+  if(cond, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v, lock: false }))
+        (a) => Task.pure(cond(a.env)).bind(
+          (c) => c ? Task.pure(task(a.env)).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({
+            env: a.env,
+            /*从类型可以确保if没命中的情况pureIf来补充正确的候选值, 所以这里跳过ts检查*/
+            lastValue: a.lastValue,
+            lock: false
+          })
+        )
       )
     );
   }
-  if(cond, value) {
+  pureR(task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(cond(a.env)).bind(
-          (c) => c ? value(a.env).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({ env: a.env, lastValue: a.lastValue, lock: false })
-        )
+        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v }))
       )
     );
   }
@@ -162,7 +175,7 @@ var Task = class _Task {
     return new _Task(async () => a);
   }
   static do() {
-    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0, lock: false })));
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
   }
   map(f) {
     return new _Task(async () => f(await this.f()));
@@ -173,6 +186,9 @@ var Task = class _Task {
   run() {
     return this.f();
   }
+  do() {
+    return new TaskDo(this.bind((a) => _Task.pure({ env: {}, lastValue: a })));
+  }
   async tryRun() {
     try {
       return new Right(await this.run());

package/dist/cjs/index.cjs

@@ -122,37 +122,50 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(
-          (v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false })
-        )
+        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   bind(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false }))
+        (a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   exec(task) {
     return new _TaskDo(
-      this.accTask.bind((a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(() => Task.pure(a)))
+      this.accTask.bind((a) => task(a.env).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  effect(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  pure(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v })))
     );
   }
-  pure(value) {
+  if(cond, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v, lock: false }))
+        (a) => Task.pure(cond(a.env)).bind(
+          (c) => c ? Task.pure(task(a.env)).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({
+            env: a.env,
+            /*从类型可以确保if没命中的情况pureIf来补充正确的候选值, 所以这里跳过ts检查*/
+            lastValue: a.lastValue,
+            lock: false
+          })
+        )
       )
     );
   }
-  if(cond, value) {
+  pureR(task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(cond(a.env)).bind(
-          (c) => c ? value(a.env).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({ env: a.env, lastValue: a.lastValue, lock: false })
-        )
+        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v }))
       )
     );
   }
@@ -170,7 +183,7 @@ var Task = class _Task {
     return new _Task(async () => a);
   }
   static do() {
-    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0, lock: false })));
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
   }
   map(f) {
     return new _Task(async () => f(await this.f()));
@@ -181,6 +194,9 @@ var Task = class _Task {
   run() {
     return this.f();
   }
+  do() {
+    return new TaskDo(this.bind((a) => _Task.pure({ env: {}, lastValue: a })));
+  }
   async tryRun() {
     try {
       return new Right(await this.run());

package/dist/cjs/index.d.cts

@@ -1,4 +1,4 @@
-export { Task, TaskDo, TaskDoType } from './data/task.cjs';
+export { Task, TaskDo, TaskDoType, TaskDoTypeBase, TaskDoTypeGet, TaskDoTypeIf, TaskDoTypeIfReturn, TaskDoTypeNoGet, TaskDoTypeReturn } 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-KGTFYSGN.js → chunk-IHXXIFRN.js}

@@ -1,6 +1,6 @@
 import {
   Task
-} from "./chunk-XMHK7KBY.js";
+} from "./chunk-OYLE35IQ.js";
 import {
   Left,
   Right

package/dist/esm/{chunk-XMHK7KBY.js → chunk-OYLE35IQ.js}

@@ -11,37 +11,50 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(
-          (v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false })
-        )
+        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   bind(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue, lock: false }))
+        (a) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: a.lastValue }))
       )
     );
   }
   exec(task) {
     return new _TaskDo(
-      this.accTask.bind((a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind(() => Task.pure(a)))
+      this.accTask.bind((a) => task(a.env).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  effect(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind(() => Task.pure({ env: a.env, lastValue: a.lastValue })))
+    );
+  }
+  pure(task) {
+    return new _TaskDo(
+      this.accTask.bind((a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v })))
     );
   }
-  pure(value) {
+  if(cond, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v, lock: false }))
+        (a) => Task.pure(cond(a.env)).bind(
+          (c) => c ? Task.pure(task(a.env)).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({
+            env: a.env,
+            /*从类型可以确保if没命中的情况pureIf来补充正确的候选值, 所以这里跳过ts检查*/
+            lastValue: a.lastValue,
+            lock: false
+          })
+        )
       )
     );
   }
-  if(cond, value) {
+  pureR(task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => a.lock ? Task.pure(a) : Task.pure(cond(a.env)).bind(
-          (c) => c ? value(a.env).bind((x) => Task.pure({ env: a.env, lastValue: x, lock: true })) : Task.pure({ env: a.env, lastValue: a.lastValue, lock: false })
-        )
+        (a) => a.lock ? Task.pure(a) : Task.pure(task(a.env)).bind((v) => Task.pure({ env: a.env, lastValue: v }))
       )
     );
   }
@@ -59,7 +72,7 @@ var Task = class _Task {
     return new _Task(async () => a);
   }
   static do() {
-    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0, lock: false })));
+    return new TaskDo(new _Task(async () => ({ env: {}, lastValue: void 0 })));
   }
   map(f) {
     return new _Task(async () => f(await this.f()));
@@ -70,6 +83,9 @@ var Task = class _Task {
   run() {
     return this.f();
   }
+  do() {
+    return new TaskDo(this.bind((a) => _Task.pure({ env: {}, lastValue: a })));
+  }
   async tryRun() {
     try {
       return new Right(await this.run());

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

@@ -1,36 +1,51 @@
 import { Either } from './either.js';
 
-interface TaskDoType<Env extends Record<string, any>, A> {
-    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoType<Env & Record<K, X>, A>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, A>;
-    exec(task: (env: Env) => void): TaskDoType<Env, A>;
-    pure(value: A): TaskDoType<Env, A>;
-    if(cond: (env: Env) => boolean, value: (env: Env) => Task<A>): TaskDoType<Env, A>;
+type TaskDoTypeBase<Env extends Record<string, any>, A> = {
+    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    exec<X>(task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env, A>;
+    effect<X>(task: (env: Env) => X): TaskDoTypeNoGet<Env, A>;
+};
+type TaskDoTypeReturn<Env extends Record<string, any>, _A> = {
+    pure<X>(task: (env: Env) => X): TaskDoTypeGet<Env, X>;
+};
+type TaskDoTypeIf<Env extends Record<string, any>, _A> = {
+    if<X>(cond: (env: Env) => boolean, task: (env: Env) => X): TaskDoTypeIfReturn<Env, X>;
+};
+type TaskDoTypeIfReturn<Env extends Record<string, any>, A> = {
+    pureR(task: (env: Env) => A): TaskDoTypeGet<Env, A>;
+};
+type TaskDoTypeGet<_Env extends Record<string, any>, A> = {
     getTask(): Task<A>;
-}
+};
+type TaskDoTypeNoGet<Env extends Record<string, any>, A> = TaskDoTypeBase<Env, A> & TaskDoTypeReturn<Env, A> & TaskDoTypeIf<Env, A>;
+type TaskDoType<Env extends Record<string, any>, A> = TaskDoTypeBase<Env, A> & TaskDoTypeReturn<Env, A> & TaskDoTypeGet<Env, A> & TaskDoTypeIf<Env, A> & TaskDoTypeIfReturn<Env, A>;
 declare class TaskDo<Env extends Record<string, any>, A> implements TaskDoType<Env, A> {
     private accTask;
     constructor(accTask: Task<{
         env: Env;
         lastValue: A;
-        lock: boolean;
+        lock?: boolean;
     }>);
-    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoType<Env & Record<K, X>, A>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, A>;
-    exec(task: (env: Env) => void): TaskDoType<Env, A>;
-    pure(value: A): TaskDoType<Env, A>;
-    if(cond: (env: Env) => boolean, value: (env: Env) => Task<A>): TaskDoType<Env, A>;
+    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env & Record<K, X>, A>;
+    exec<X>(task: (env: Env) => Task<X>): TaskDoTypeNoGet<Env, A>;
+    effect<X>(task: (env: Env) => X): TaskDoTypeNoGet<Env, A>;
+    pure<X>(task: (env: Env) => X): TaskDoTypeGet<Env, X>;
+    if<X>(cond: (env: Env) => boolean, task: (env: Env) => X): TaskDoTypeIfReturn<Env, X>;
+    pureR(task: (env: Env) => A): TaskDoTypeGet<Env, A>;
     getTask(): Task<A>;
 }
 declare class Task<A> {
     private f;
     static pure<A>(a: A): Task<A>;
-    static do(): TaskDo<Record<string, any>, void>;
+    static do(): TaskDoTypeBase<Record<string, any>, void>;
     constructor(f: () => Promise<A>);
     map<B>(f: (a: A) => B): Task<B>;
     bind<B>(f: (a: A) => Task<B>): Task<B>;
     run(): Promise<A>;
+    do(): TaskDoTypeBase<{}, A>;
     tryRun(): Promise<Either<Error, A>>;
 }
 
-export { Task, TaskDo, type TaskDoType };
+export { Task, TaskDo, type TaskDoType, type TaskDoTypeBase, type TaskDoTypeGet, type TaskDoTypeIf, type TaskDoTypeIfReturn, type TaskDoTypeNoGet, type TaskDoTypeReturn };

package/dist/esm/data/task.js

@@ -1,7 +1,7 @@
 import {
   Task,
   TaskDo
-} from "../chunk-XMHK7KBY.js";
+} from "../chunk-OYLE35IQ.js";
 import "../chunk-VTI5CRVQ.js";
 export {
   Task,

package/dist/esm/func/seq.js

@@ -3,8 +3,8 @@ import {
   seqArrayTask,
   seqEitherArray,
   seqEitherTask
-} from "../chunk-KGTFYSGN.js";
-import "../chunk-XMHK7KBY.js";
+} from "../chunk-IHXXIFRN.js";
+import "../chunk-OYLE35IQ.js";
 import "../chunk-VTI5CRVQ.js";
 export {
   seqArrayEither,

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
-export { Task, TaskDo, TaskDoType } from './data/task.js';
+export { Task, TaskDo, TaskDoType, TaskDoTypeBase, TaskDoTypeGet, TaskDoTypeIf, TaskDoTypeIfReturn, TaskDoTypeNoGet, TaskDoTypeReturn } 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

@@ -1,18 +1,18 @@
-import {
-  Just,
-  Maybe,
-  Nothing
-} from "./chunk-PP7TCBHD.js";
 import {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
   seqEitherTask
-} from "./chunk-KGTFYSGN.js";
+} from "./chunk-IHXXIFRN.js";
+import {
+  Just,
+  Maybe,
+  Nothing
+} from "./chunk-PP7TCBHD.js";
 import {
   Task,
   TaskDo
-} from "./chunk-XMHK7KBY.js";
+} from "./chunk-OYLE35IQ.js";
 import {
   Either,
   Left,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsby/ts-fp-data",
-  "version": "0.0.9-beta.1",
+  "version": "0.0.9-beta.3",
   "type": "module",
   "exports": {
     "require": "./dist/cjs/index.cjs",