@lsby/ts-fp-data 0.0.9-beta.2 → 0.0.9

package/dist/cjs/data/maybe.cjs

@@ -35,9 +35,6 @@ var Just = class _Just extends Maybe {
     super();
     this.\u503C = \u503C;
   }
-  match(onJust, _onNothing) {
-    return onJust(this.\u503C);
-  }
   map(f) {
     return new _Just(f(this.\u503C));
   }
@@ -50,17 +47,23 @@ var Just = class _Just extends Maybe {
   isNothing() {
     return false;
   }
+  assertJust() {
+    return this;
+  }
+  assertNothing() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
   getJust() {
     return this.\u503C;
   }
   getJustOrNull() {
     return this.\u503C;
   }
+  match(onJust, _onNothing) {
+    return onJust(this.\u503C);
+  }
 };
 var Nothing = class _Nothing extends Maybe {
-  match(_onJust, onNothing) {
-    return onNothing();
-  }
   map(_f) {
     return new _Nothing();
   }
@@ -73,9 +76,18 @@ var Nothing = class _Nothing extends Maybe {
   isNothing() {
     return true;
   }
+  assertJust() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  assertNothing() {
+    return this;
+  }
   getJustOrNull() {
     return null;
   }
+  match(_onJust, onNothing) {
+    return onNothing();
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -4,27 +4,33 @@ declare abstract class Maybe<A> {
     abstract bind<B>(f: (a: A) => Maybe<B>): Maybe<B>;
     abstract isJust(): this is Just<A>;
     abstract isNothing(): this is Nothing<A>;
+    abstract assertJust(): Just<A>;
+    abstract assertNothing(): Nothing<A>;
     abstract getJustOrNull(): A | null;
     abstract match<B>(onJust: (a: A) => B, onNothing: () => B): B;
 }
 declare class Just<A> extends Maybe<A> {
     private 值;
     constructor(值: A);
-    match<B>(onJust: (a: A) => B, _onNothing: () => B): B;
     map<B>(f: (a: A) => B): Maybe<B>;
     bind<B>(f: (a: A) => Maybe<B>): Maybe<B>;
     isJust(): this is Just<A>;
     isNothing(): this is Nothing<A>;
+    assertJust(): Just<A>;
+    assertNothing(): Nothing<A>;
     getJust(): A;
     getJustOrNull(): A | null;
+    match<B>(onJust: (a: A) => B, _onNothing: () => B): B;
 }
 declare class Nothing<A> extends Maybe<A> {
-    match<B>(_onJust: (a: A) => B, onNothing: () => B): B;
     map<B>(_f: (a: A) => B): Maybe<B>;
     bind<B>(_f: (a: A) => Maybe<B>): Maybe<B>;
     isJust(): this is Just<A>;
     isNothing(): this is Nothing<A>;
+    assertJust(): Just<A>;
+    assertNothing(): Nothing<A>;
     getJustOrNull(): A | null;
+    match<B>(_onJust: (a: A) => B, onNothing: () => B): B;
 }
 
 export { Just, Maybe, Nothing };

package/dist/cjs/data/task.cjs

@@ -112,25 +112,52 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v }))
+        (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) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+      this.accTask.bind(
+        (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) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+    return new _TaskDo(
+      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) {
-    return new _TaskDo(this.accTask.bind((a) => Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  if(cond, task) {
+    return new _TaskDo(
+      this.accTask.bind(
+        (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
+          })
+        )
+      )
+    );
+  }
+  pureR(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, lastValue: v }))
+      )
+    );
   }
   getTask() {
     return new Task(async () => {
@@ -157,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,35 +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>, X>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, X>;
-    exec<X>(task: (env: Env) => Task<X>): TaskDoType<Env, X>;
-    effect<X>(task: (env: Env) => X): TaskDoType<Env, X>;
-    pure<X>(value: X): TaskDoType<Env, X>;
+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;
     }>);
-    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoType<Env & Record<K, X>, X>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, X>;
-    exec<X>(task: (env: Env) => Task<X>): TaskDoType<Env, X>;
-    effect<X>(task: (env: Env) => X): TaskDoType<Env, X>;
-    pure<X>(value: X): TaskDoType<Env, X>;
+    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,25 +114,52 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v }))
+        (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) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+      this.accTask.bind(
+        (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) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+    return new _TaskDo(
+      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) {
-    return new _TaskDo(this.accTask.bind((a) => Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  if(cond, task) {
+    return new _TaskDo(
+      this.accTask.bind(
+        (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
+          })
+        )
+      )
+    );
+  }
+  pureR(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, lastValue: v }))
+      )
+    );
   }
   getTask() {
     return new Task(async () => {
@@ -159,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,25 +122,52 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v }))
+        (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) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+      this.accTask.bind(
+        (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) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+    return new _TaskDo(
+      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) {
-    return new _TaskDo(this.accTask.bind((a) => Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  if(cond, task) {
+    return new _TaskDo(
+      this.accTask.bind(
+        (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
+          })
+        )
+      )
+    );
+  }
+  pureR(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, lastValue: v }))
+      )
+    );
   }
   getTask() {
     return new Task(async () => {
@@ -167,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());
@@ -189,9 +219,6 @@ var Just = class _Just extends Maybe {
     super();
     this.\u503C = \u503C;
   }
-  match(onJust, _onNothing) {
-    return onJust(this.\u503C);
-  }
   map(f) {
     return new _Just(f(this.\u503C));
   }
@@ -204,17 +231,23 @@ var Just = class _Just extends Maybe {
   isNothing() {
     return false;
   }
+  assertJust() {
+    return this;
+  }
+  assertNothing() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
   getJust() {
     return this.\u503C;
   }
   getJustOrNull() {
     return this.\u503C;
   }
+  match(onJust, _onNothing) {
+    return onJust(this.\u503C);
+  }
 };
 var Nothing = class _Nothing extends Maybe {
-  match(_onJust, onNothing) {
-    return onNothing();
-  }
   map(_f) {
     return new _Nothing();
   }
@@ -227,9 +260,18 @@ var Nothing = class _Nothing extends Maybe {
   isNothing() {
     return true;
   }
+  assertJust() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  assertNothing() {
+    return this;
+  }
   getJustOrNull() {
     return null;
   }
+  match(_onJust, onNothing) {
+    return onNothing();
+  }
 };
 
 // src/func/seq.ts

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-PP7TCBHD.js → chunk-CQG32QQC.js}

@@ -9,9 +9,6 @@ var Just = class _Just extends Maybe {
     super();
     this.\u503C = \u503C;
   }
-  match(onJust, _onNothing) {
-    return onJust(this.\u503C);
-  }
   map(f) {
     return new _Just(f(this.\u503C));
   }
@@ -24,17 +21,23 @@ var Just = class _Just extends Maybe {
   isNothing() {
     return false;
   }
+  assertJust() {
+    return this;
+  }
+  assertNothing() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
   getJust() {
     return this.\u503C;
   }
   getJustOrNull() {
     return this.\u503C;
   }
+  match(onJust, _onNothing) {
+    return onJust(this.\u503C);
+  }
 };
 var Nothing = class _Nothing extends Maybe {
-  match(_onJust, onNothing) {
-    return onNothing();
-  }
   map(_f) {
     return new _Nothing();
   }
@@ -47,9 +50,18 @@ var Nothing = class _Nothing extends Maybe {
   isNothing() {
     return true;
   }
+  assertJust() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  assertNothing() {
+    return this;
+  }
   getJustOrNull() {
     return null;
   }
+  match(_onJust, onNothing) {
+    return onNothing();
+  }
 };
 
 export {

package/dist/esm/{chunk-YEO4J4FS.js → chunk-IHXXIFRN.js}

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

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

@@ -11,25 +11,52 @@ var TaskDo = class _TaskDo {
   let(name, task) {
     return new _TaskDo(
       this.accTask.bind(
-        (a) => Task.pure(task(a.env)).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v }))
+        (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) => task(a.env).bind((v) => Task.pure({ env: { ...a.env, [name]: v }, lastValue: v })))
+      this.accTask.bind(
+        (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) => task(a.env).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+    return new _TaskDo(
+      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) {
-    return new _TaskDo(this.accTask.bind((a) => Task.pure(value).bind((v) => Task.pure({ env: a.env, lastValue: v }))));
+  if(cond, task) {
+    return new _TaskDo(
+      this.accTask.bind(
+        (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
+          })
+        )
+      )
+    );
+  }
+  pureR(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, lastValue: v }))
+      )
+    );
   }
   getTask() {
     return new Task(async () => {
@@ -56,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/maybe.d.ts

@@ -4,27 +4,33 @@ declare abstract class Maybe<A> {
     abstract bind<B>(f: (a: A) => Maybe<B>): Maybe<B>;
     abstract isJust(): this is Just<A>;
     abstract isNothing(): this is Nothing<A>;
+    abstract assertJust(): Just<A>;
+    abstract assertNothing(): Nothing<A>;
     abstract getJustOrNull(): A | null;
     abstract match<B>(onJust: (a: A) => B, onNothing: () => B): B;
 }
 declare class Just<A> extends Maybe<A> {
     private 值;
     constructor(值: A);
-    match<B>(onJust: (a: A) => B, _onNothing: () => B): B;
     map<B>(f: (a: A) => B): Maybe<B>;
     bind<B>(f: (a: A) => Maybe<B>): Maybe<B>;
     isJust(): this is Just<A>;
     isNothing(): this is Nothing<A>;
+    assertJust(): Just<A>;
+    assertNothing(): Nothing<A>;
     getJust(): A;
     getJustOrNull(): A | null;
+    match<B>(onJust: (a: A) => B, _onNothing: () => B): B;
 }
 declare class Nothing<A> extends Maybe<A> {
-    match<B>(_onJust: (a: A) => B, onNothing: () => B): B;
     map<B>(_f: (a: A) => B): Maybe<B>;
     bind<B>(_f: (a: A) => Maybe<B>): Maybe<B>;
     isJust(): this is Just<A>;
     isNothing(): this is Nothing<A>;
+    assertJust(): Just<A>;
+    assertNothing(): Nothing<A>;
     getJustOrNull(): A | null;
+    match<B>(_onJust: (a: A) => B, onNothing: () => B): B;
 }
 
 export { Just, Maybe, Nothing };

package/dist/esm/data/maybe.js

@@ -2,7 +2,7 @@ import {
   Just,
   Maybe,
   Nothing
-} from "../chunk-PP7TCBHD.js";
+} from "../chunk-CQG32QQC.js";
 export {
   Just,
   Maybe,

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

@@ -1,35 +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>, X>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, X>;
-    exec<X>(task: (env: Env) => Task<X>): TaskDoType<Env, X>;
-    effect<X>(task: (env: Env) => X): TaskDoType<Env, X>;
-    pure<X>(value: X): TaskDoType<Env, X>;
+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;
     }>);
-    let<K extends string, X>(name: K, task: (env: Env) => X): TaskDoType<Env & Record<K, X>, X>;
-    bind<K extends string, X>(name: K, task: (env: Env) => Task<X>): TaskDoType<Env & Record<K, X>, X>;
-    exec<X>(task: (env: Env) => Task<X>): TaskDoType<Env, X>;
-    effect<X>(task: (env: Env) => X): TaskDoType<Env, X>;
-    pure<X>(value: X): TaskDoType<Env, X>;
+    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-ZUDRGXSS.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-YEO4J4FS.js";
-import "../chunk-ZUDRGXSS.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

@@ -2,17 +2,17 @@ import {
   Just,
   Maybe,
   Nothing
-} from "./chunk-PP7TCBHD.js";
+} from "./chunk-CQG32QQC.js";
 import {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
   seqEitherTask
-} from "./chunk-YEO4J4FS.js";
+} from "./chunk-IHXXIFRN.js";
 import {
   Task,
   TaskDo
-} from "./chunk-ZUDRGXSS.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.2",
+  "version": "0.0.9",
   "type": "module",
   "exports": {
     "require": "./dist/cjs/index.cjs",
@@ -9,22 +9,24 @@
   "files": [
     "dist"
   ],
-  "dependencies": {},
   "devDependencies": {
     "@ianvs/prettier-plugin-sort-imports": "^4.2.1",
     "@types/node": "^20.12.10",
     "@typescript-eslint/eslint-plugin": "^7.8.0",
     "@typescript-eslint/parser": "^7.8.0",
+    "@vitest/coverage-v8": "^2.0.2",
     "bumpp": "^9.4.1",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-sort-class-members": "^1.20.0",
     "eslint-plugin-unused-imports": "^3.2.0",
+    "open-cli": "^8.0.0",
     "prettier": "3.2.5",
     "prettier-plugin-packagejson": "^2.5.0",
     "tsup": "^8.0.2",
     "tsx": "^4.9.3",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "vitest": "^2.0.2"
   },
   "scripts": {
     "build:all": "npm run build:cjs && npm run build:esm",
@@ -37,6 +39,7 @@
     "other:typecheck": "tsc --noEmit",
     "other:typecheck:watch": "tsc --noEmit -w",
     "run:start": "tsx src/index.ts",
-    "run:test": "tsx test/index.ts"
+    "test:base": "vitest run",
+    "test:coverage": "vitest run --coverage && open-cli ./coverage/index.html"
   }
 }