@lsby/ts-fp-data 0.1.4 → 0.2.1

package/dist/cjs/data/either.cjs

@@ -25,6 +25,80 @@ __export(either_exports, {
   Right: () => Right
 });
 module.exports = __toCommonJS(either_exports);
+
+// src/data/maybe.ts
+var Maybe = class {
+  static pure(a) {
+    return new Just(a);
+  }
+};
+var Just = class _Just extends Maybe {
+  constructor(\u503C) {
+    super();
+    this.\u503C = \u503C;
+  }
+  map(f) {
+    return new _Just(f(this.\u503C));
+  }
+  bind(f) {
+    return f(this.\u503C);
+  }
+  isJust() {
+    return true;
+  }
+  isNothing() {
+    return false;
+  }
+  assertJust() {
+    return this;
+  }
+  assertNothing() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  getJust() {
+    return this.\u503C;
+  }
+  getJustOrNull() {
+    return this.\u503C;
+  }
+  match(_onNothing, onJust) {
+    return onJust(this.\u503C);
+  }
+  mplus(_a) {
+    return this;
+  }
+};
+var Nothing = class _Nothing extends Maybe {
+  map(_f) {
+    return new _Nothing();
+  }
+  bind(_f) {
+    return new _Nothing();
+  }
+  isJust() {
+    return false;
+  }
+  isNothing() {
+    return true;
+  }
+  assertJust() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  assertNothing() {
+    return this;
+  }
+  getJustOrNull() {
+    return null;
+  }
+  match(onNothing, _onJust) {
+    return onNothing();
+  }
+  mplus(a) {
+    return a;
+  }
+};
+
+// src/data/either.ts
 var Either = class {
   static pure(a) {
     return new Right(a);
@@ -65,6 +139,12 @@ var Left = class _Left extends Either {
   match(onLeft, _onRight) {
     return onLeft(this.\u503C);
   }
+  mplus(a) {
+    return a;
+  }
+  toMaybe() {
+    return new Nothing();
+  }
 };
 var Right = class _Right extends Either {
   constructor(\u503C) {
@@ -101,6 +181,12 @@ var Right = class _Right extends Either {
   match(_onLeft, onRight) {
     return onRight(this.\u503C);
   }
+  mplus(_a) {
+    return this;
+  }
+  toMaybe() {
+    return new Just(this.\u503C);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1,3 +1,5 @@
+import { Maybe } from './maybe.cjs';
+
 declare abstract class Either<L, R> {
     static pure<L, R>(a: R): Either<L, R>;
     abstract map<B>(_f: (a: R) => B): Either<L, B>;
@@ -9,6 +11,8 @@ declare abstract class Either<L, R> {
     abstract assertLeft(): Left<L, R>;
     abstract assertRight(): Right<L, R>;
     abstract match<X>(onLeft: (a: L) => X, onRight: (a: R) => X): X;
+    abstract mplus(a: Either<L, R>): Either<L, R>;
+    abstract toMaybe(): Maybe<R>;
 }
 declare class Left<L, R> extends Either<L, R> {
     private 值;
@@ -23,6 +27,8 @@ declare class Left<L, R> extends Either<L, R> {
     assertLeft(): Left<L, R>;
     assertRight(): Right<L, R>;
     match<X>(onLeft: (a: L) => X, _onRight: (a: R) => X): X;
+    mplus(a: Either<L, R>): Either<L, R>;
+    toMaybe(): Maybe<R>;
 }
 declare class Right<L, R> extends Either<L, R> {
     private 值;
@@ -37,6 +43,8 @@ declare class Right<L, R> extends Either<L, R> {
     assertLeft(): Left<L, R>;
     assertRight(): Right<L, R>;
     match<X>(_onLeft: (a: L) => X, onRight: (a: R) => X): X;
+    mplus(_a: Either<L, R>): Either<L, R>;
+    toMaybe(): Maybe<R>;
 }
 
 export { Either, Left, Right };

package/dist/cjs/data/maybe.cjs

@@ -59,9 +59,12 @@ var Just = class _Just extends Maybe {
   getJustOrNull() {
     return this.\u503C;
   }
-  match(onJust, _onNothing) {
+  match(_onNothing, onJust) {
     return onJust(this.\u503C);
   }
+  mplus(_a) {
+    return this;
+  }
 };
 var Nothing = class _Nothing extends Maybe {
   map(_f) {
@@ -85,9 +88,12 @@ var Nothing = class _Nothing extends Maybe {
   getJustOrNull() {
     return null;
   }
-  match(_onJust, onNothing) {
+  match(onNothing, _onJust) {
     return onNothing();
   }
+  mplus(a) {
+    return a;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -5,9 +5,10 @@ declare abstract class Maybe<A> {
     abstract isJust(): this is Just<A>;
     abstract isNothing(): this is Nothing<A>;
     abstract assertJust(): Just<A>;
-    abstract assertNothing(): Nothing<A>;
+    abstract assertNothing(): Nothing<any>;
     abstract getJustOrNull(): A | null;
-    abstract match<B>(onJust: (a: A) => B, onNothing: () => B): B;
+    abstract match<B>(onNothing: () => B, onJust: (a: A) => B): B;
+    abstract mplus(a: Maybe<A>): Maybe<A>;
 }
 declare class Just<A> extends Maybe<A> {
     private 值;
@@ -20,7 +21,8 @@ declare class Just<A> extends Maybe<A> {
     assertNothing(): Nothing<A>;
     getJust(): A;
     getJustOrNull(): A | null;
-    match<B>(onJust: (a: A) => B, _onNothing: () => B): B;
+    match<B>(_onNothing: () => B, onJust: (a: A) => B): B;
+    mplus(_a: Maybe<A>): Maybe<A>;
 }
 declare class Nothing<A> extends Maybe<A> {
     map<B>(_f: (a: A) => B): Maybe<B>;
@@ -30,7 +32,8 @@ declare class Nothing<A> extends Maybe<A> {
     assertJust(): Just<A>;
     assertNothing(): Nothing<A>;
     getJustOrNull(): A | null;
-    match<B>(_onJust: (a: A) => B, onNothing: () => B): B;
+    match<B>(onNothing: () => B, _onJust: (a: A) => B): B;
+    mplus(a: Maybe<A>): Maybe<A>;
 }
 
 export { Just, Maybe, Nothing };

package/dist/cjs/data/task.cjs

@@ -25,6 +25,78 @@ __export(task_exports, {
 });
 module.exports = __toCommonJS(task_exports);
 
+// src/data/maybe.ts
+var Maybe = class {
+  static pure(a) {
+    return new Just(a);
+  }
+};
+var Just = class _Just extends Maybe {
+  constructor(\u503C) {
+    super();
+    this.\u503C = \u503C;
+  }
+  map(f) {
+    return new _Just(f(this.\u503C));
+  }
+  bind(f) {
+    return f(this.\u503C);
+  }
+  isJust() {
+    return true;
+  }
+  isNothing() {
+    return false;
+  }
+  assertJust() {
+    return this;
+  }
+  assertNothing() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  getJust() {
+    return this.\u503C;
+  }
+  getJustOrNull() {
+    return this.\u503C;
+  }
+  match(_onNothing, onJust) {
+    return onJust(this.\u503C);
+  }
+  mplus(_a) {
+    return this;
+  }
+};
+var Nothing = class _Nothing extends Maybe {
+  map(_f) {
+    return new _Nothing();
+  }
+  bind(_f) {
+    return new _Nothing();
+  }
+  isJust() {
+    return false;
+  }
+  isNothing() {
+    return true;
+  }
+  assertJust() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  assertNothing() {
+    return this;
+  }
+  getJustOrNull() {
+    return null;
+  }
+  match(onNothing, _onJust) {
+    return onNothing();
+  }
+  mplus(a) {
+    return a;
+  }
+};
+
 // src/data/either.ts
 var Either = class {
   static pure(a) {
@@ -66,6 +138,12 @@ var Left = class _Left extends Either {
   match(onLeft, _onRight) {
     return onLeft(this.\u503C);
   }
+  mplus(a) {
+    return a;
+  }
+  toMaybe() {
+    return new Nothing();
+  }
 };
 var Right = class _Right extends Either {
   constructor(\u503C) {
@@ -102,6 +180,12 @@ var Right = class _Right extends Either {
   match(_onLeft, onRight) {
     return onRight(this.\u503C);
   }
+  mplus(_a) {
+    return this;
+  }
+  toMaybe() {
+    return new Just(this.\u503C);
+  }
 };
 
 // src/data/task.ts

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

@@ -1,4 +1,5 @@
 import { Either } from './either.cjs';
+import './maybe.cjs';
 
 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>;

package/dist/cjs/func/seq.cjs

@@ -20,15 +20,90 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/func/seq.ts
 var seq_exports = {};
 __export(seq_exports, {
-  seqArrayEither: () => seqArrayEither,
+  seqArrayEitherCollectRight: () => seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft: () => seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust: () => seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing: () => seqArrayMaybeFirstNothing,
   seqArrayTask: () => seqArrayTask,
   seqEitherArray: () => seqEitherArray,
-  seqEitherPromise: () => seqEitherPromise,
   seqEitherTask: () => seqEitherTask,
-  seqMaybePromise: () => seqMaybePromise
+  seqMaybeArray: () => seqMaybeArray,
+  seqMaybeTask: () => seqMaybeTask
 });
 module.exports = __toCommonJS(seq_exports);
 
+// src/data/maybe.ts
+var Maybe = class {
+  static pure(a) {
+    return new Just(a);
+  }
+};
+var Just = class _Just extends Maybe {
+  constructor(\u503C) {
+    super();
+    this.\u503C = \u503C;
+  }
+  map(f) {
+    return new _Just(f(this.\u503C));
+  }
+  bind(f) {
+    return f(this.\u503C);
+  }
+  isJust() {
+    return true;
+  }
+  isNothing() {
+    return false;
+  }
+  assertJust() {
+    return this;
+  }
+  assertNothing() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  getJust() {
+    return this.\u503C;
+  }
+  getJustOrNull() {
+    return this.\u503C;
+  }
+  match(_onNothing, onJust) {
+    return onJust(this.\u503C);
+  }
+  mplus(_a) {
+    return this;
+  }
+};
+var Nothing = class _Nothing extends Maybe {
+  map(_f) {
+    return new _Nothing();
+  }
+  bind(_f) {
+    return new _Nothing();
+  }
+  isJust() {
+    return false;
+  }
+  isNothing() {
+    return true;
+  }
+  assertJust() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  assertNothing() {
+    return this;
+  }
+  getJustOrNull() {
+    return null;
+  }
+  match(onNothing, _onJust) {
+    return onNothing();
+  }
+  mplus(a) {
+    return a;
+  }
+};
+
 // src/data/either.ts
 var Either = class {
   static pure(a) {
@@ -70,6 +145,12 @@ var Left = class _Left extends Either {
   match(onLeft, _onRight) {
     return onLeft(this.\u503C);
   }
+  mplus(a) {
+    return a;
+  }
+  toMaybe() {
+    return new Nothing();
+  }
 };
 var Right = class _Right extends Either {
   constructor(\u503C) {
@@ -106,71 +187,11 @@ var Right = class _Right extends Either {
   match(_onLeft, onRight) {
     return onRight(this.\u503C);
   }
-};
-
-// src/data/maybe.ts
-var Maybe = class {
-  static pure(a) {
-    return new Just(a);
-  }
-};
-var Just = class _Just extends Maybe {
-  constructor(\u503C) {
-    super();
-    this.\u503C = \u503C;
-  }
-  map(f) {
-    return new _Just(f(this.\u503C));
-  }
-  bind(f) {
-    return f(this.\u503C);
-  }
-  isJust() {
-    return true;
-  }
-  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 {
-  map(_f) {
-    return new _Nothing();
-  }
-  bind(_f) {
-    return new _Nothing();
-  }
-  isJust() {
-    return false;
-  }
-  isNothing() {
-    return true;
-  }
-  assertJust() {
-    throw new Error("\u65AD\u8A00\u5931\u8D25");
-  }
-  assertNothing() {
+  mplus(_a) {
     return this;
   }
-  getJustOrNull() {
-    return null;
-  }
-  match(_onJust, onNothing) {
-    return onNothing();
+  toMaybe() {
+    return new Just(this.\u503C);
   }
 };
 
@@ -286,31 +307,47 @@ function seqEitherArray(value) {
     (data) => data.map((a) => new Right(a))
   );
 }
-function seqArrayEither(value) {
-  const err = value.filter((a) => a.isLeft())[0];
+function seqArrayEitherFirstLeft(value) {
+  var err = value.filter((a) => a.isLeft())[0];
   if (err)
     return err;
-  const data = value.map((a) => a.assertRight().getRight());
+  var data = value.map((a) => a.assertRight().getRight());
   return new Right(data);
 }
-function seqMaybePromise(a) {
+function seqArrayEitherCollectRight(value) {
+  return seqArrayEitherFirstLeft(value.filter((a) => a.isRight()));
+}
+function seqArrayMaybeFirstNothing(a) {
+  const firstNothing = a.find((maybe) => maybe.isNothing());
+  if (firstNothing)
+    return new Nothing();
+  const values = a.map((maybe) => maybe.assertJust().getJust());
+  return new Just(values);
+}
+function seqArrayMaybeCollectJust(a) {
+  return seqArrayMaybeFirstNothing(a.filter((a2) => a2.isJust()));
+}
+function seqMaybeArray(a) {
   return a.match(
-    async (a2) => new Just(await a2),
-    async () => new Nothing()
+    () => [new Nothing()],
+    (array) => array.map((x) => new Just(x))
   );
 }
-function seqEitherPromise(a) {
+function seqMaybeTask(a) {
   return a.match(
-    async (a2) => new Left(a2),
-    async (a2) => new Right(await a2)
+    () => Task.pure(new Nothing()),
+    (task) => task.map((a2) => new Just(a2))
   );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  seqArrayEither,
+  seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing,
   seqArrayTask,
   seqEitherArray,
-  seqEitherPromise,
   seqEitherTask,
-  seqMaybePromise
+  seqMaybeArray,
+  seqMaybeTask
 });

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

@@ -5,8 +5,11 @@ import { Task } from '../data/task.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>>;
-declare function seqMaybePromise<A>(a: Maybe<Promise<A>>): Promise<Maybe<A>>;
-declare function seqEitherPromise<L, R>(a: Either<L, Promise<R>>): Promise<Either<L, R>>;
+declare function seqArrayEitherFirstLeft<A, B>(value: Array<Either<A, B>>): Either<A, Array<B>>;
+declare function seqArrayEitherCollectRight<A, B>(value: Array<Either<A, B>>): Either<A, Array<B>>;
+declare function seqArrayMaybeFirstNothing<X>(a: Array<Maybe<X>>): Maybe<Array<X>>;
+declare function seqArrayMaybeCollectJust<X>(a: Array<Maybe<X>>): Maybe<Array<X>>;
+declare function seqMaybeArray<X>(a: Maybe<Array<X>>): Array<Maybe<X>>;
+declare function seqMaybeTask<X>(a: Maybe<Task<X>>): Task<Maybe<X>>;
 
-export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherPromise, seqEitherTask, seqMaybePromise };
+export { seqArrayEitherCollectRight, seqArrayEitherFirstLeft, seqArrayMaybeCollectJust, seqArrayMaybeFirstNothing, seqArrayTask, seqEitherArray, seqEitherTask, seqMaybeArray, seqMaybeTask };

package/dist/cjs/index.cjs

@@ -31,15 +31,90 @@ __export(src_exports, {
   Right: () => Right,
   Task: () => Task,
   TaskDo: () => TaskDo,
-  seqArrayEither: () => seqArrayEither,
+  seqArrayEitherCollectRight: () => seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft: () => seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust: () => seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing: () => seqArrayMaybeFirstNothing,
   seqArrayTask: () => seqArrayTask,
   seqEitherArray: () => seqEitherArray,
-  seqEitherPromise: () => seqEitherPromise,
   seqEitherTask: () => seqEitherTask,
-  seqMaybePromise: () => seqMaybePromise
+  seqMaybeArray: () => seqMaybeArray,
+  seqMaybeTask: () => seqMaybeTask
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/data/maybe.ts
+var Maybe = class {
+  static pure(a) {
+    return new Just(a);
+  }
+};
+var Just = class _Just extends Maybe {
+  constructor(\u503C) {
+    super();
+    this.\u503C = \u503C;
+  }
+  map(f) {
+    return new _Just(f(this.\u503C));
+  }
+  bind(f) {
+    return f(this.\u503C);
+  }
+  isJust() {
+    return true;
+  }
+  isNothing() {
+    return false;
+  }
+  assertJust() {
+    return this;
+  }
+  assertNothing() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  getJust() {
+    return this.\u503C;
+  }
+  getJustOrNull() {
+    return this.\u503C;
+  }
+  match(_onNothing, onJust) {
+    return onJust(this.\u503C);
+  }
+  mplus(_a) {
+    return this;
+  }
+};
+var Nothing = class _Nothing extends Maybe {
+  map(_f) {
+    return new _Nothing();
+  }
+  bind(_f) {
+    return new _Nothing();
+  }
+  isJust() {
+    return false;
+  }
+  isNothing() {
+    return true;
+  }
+  assertJust() {
+    throw new Error("\u65AD\u8A00\u5931\u8D25");
+  }
+  assertNothing() {
+    return this;
+  }
+  getJustOrNull() {
+    return null;
+  }
+  match(onNothing, _onJust) {
+    return onNothing();
+  }
+  mplus(a) {
+    return a;
+  }
+};
+
 // src/data/either.ts
 var Either = class {
   static pure(a) {
@@ -81,6 +156,12 @@ var Left = class _Left extends Either {
   match(onLeft, _onRight) {
     return onLeft(this.\u503C);
   }
+  mplus(a) {
+    return a;
+  }
+  toMaybe() {
+    return new Nothing();
+  }
 };
 var Right = class _Right extends Either {
   constructor(\u503C) {
@@ -117,6 +198,12 @@ var Right = class _Right extends Either {
   match(_onLeft, onRight) {
     return onRight(this.\u503C);
   }
+  mplus(_a) {
+    return this;
+  }
+  toMaybe() {
+    return new Just(this.\u503C);
+  }
 };
 
 // src/data/lazy.ts
@@ -151,72 +238,6 @@ var LazyForceValue = class _LazyForceValue extends Lazy {
   }
 };
 
-// src/data/maybe.ts
-var Maybe = class {
-  static pure(a) {
-    return new Just(a);
-  }
-};
-var Just = class _Just extends Maybe {
-  constructor(\u503C) {
-    super();
-    this.\u503C = \u503C;
-  }
-  map(f) {
-    return new _Just(f(this.\u503C));
-  }
-  bind(f) {
-    return f(this.\u503C);
-  }
-  isJust() {
-    return true;
-  }
-  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 {
-  map(_f) {
-    return new _Nothing();
-  }
-  bind(_f) {
-    return new _Nothing();
-  }
-  isJust() {
-    return false;
-  }
-  isNothing() {
-    return true;
-  }
-  assertJust() {
-    throw new Error("\u65AD\u8A00\u5931\u8D25");
-  }
-  assertNothing() {
-    return this;
-  }
-  getJustOrNull() {
-    return null;
-  }
-  match(_onJust, onNothing) {
-    return onNothing();
-  }
-};
-
 // src/data/task.ts
 var TaskDo = class _TaskDo {
   constructor(accTask) {
@@ -329,23 +350,36 @@ function seqEitherArray(value) {
     (data) => data.map((a) => new Right(a))
   );
 }
-function seqArrayEither(value) {
-  const err = value.filter((a) => a.isLeft())[0];
+function seqArrayEitherFirstLeft(value) {
+  var err = value.filter((a) => a.isLeft())[0];
   if (err)
     return err;
-  const data = value.map((a) => a.assertRight().getRight());
+  var data = value.map((a) => a.assertRight().getRight());
   return new Right(data);
 }
-function seqMaybePromise(a) {
+function seqArrayEitherCollectRight(value) {
+  return seqArrayEitherFirstLeft(value.filter((a) => a.isRight()));
+}
+function seqArrayMaybeFirstNothing(a) {
+  const firstNothing = a.find((maybe) => maybe.isNothing());
+  if (firstNothing)
+    return new Nothing();
+  const values = a.map((maybe) => maybe.assertJust().getJust());
+  return new Just(values);
+}
+function seqArrayMaybeCollectJust(a) {
+  return seqArrayMaybeFirstNothing(a.filter((a2) => a2.isJust()));
+}
+function seqMaybeArray(a) {
   return a.match(
-    async (a2) => new Just(await a2),
-    async () => new Nothing()
+    () => [new Nothing()],
+    (array) => array.map((x) => new Just(x))
   );
 }
-function seqEitherPromise(a) {
+function seqMaybeTask(a) {
   return a.match(
-    async (a2) => new Left(a2),
-    async (a2) => new Right(await a2)
+    () => Task.pure(new Nothing()),
+    (task) => task.map((a2) => new Just(a2))
   );
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -361,10 +395,13 @@ function seqEitherPromise(a) {
   Right,
   Task,
   TaskDo,
-  seqArrayEither,
+  seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing,
   seqArrayTask,
   seqEitherArray,
-  seqEitherPromise,
   seqEitherTask,
-  seqMaybePromise
+  seqMaybeArray,
+  seqMaybeTask
 });

package/dist/cjs/index.d.cts

@@ -2,4 +2,4 @@ export { Either, Left, Right } from './data/either.cjs';
 export { Lazy, LazyDeferValue, LazyForceValue } from './data/lazy.cjs';
 export { Just, Maybe, Nothing } from './data/maybe.cjs';
 export { Task, TaskDo, TaskDoType, TaskDoTypeBase, TaskDoTypeGet, TaskDoTypeIf, TaskDoTypeIfReturn, TaskDoTypeNoGet, TaskDoTypeReturn } from './data/task.cjs';
-export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherPromise, seqEitherTask, seqMaybePromise } from './func/seq.cjs';
+export { seqArrayEitherCollectRight, seqArrayEitherFirstLeft, seqArrayMaybeCollectJust, seqArrayMaybeFirstNothing, seqArrayTask, seqEitherArray, seqEitherTask, seqMaybeArray, seqMaybeTask } from './func/seq.cjs';

package/dist/esm/chunk-B2G2C6YM.js

@@ -0,0 +1,74 @@
+import {
+  Task
+} from "./chunk-IB4BVSOW.js";
+import {
+  Left,
+  Right
+} from "./chunk-BE7V6GBG.js";
+import {
+  Just,
+  Nothing
+} from "./chunk-NXA54GUD.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 seqArrayEitherFirstLeft(value) {
+  var err = value.filter((a) => a.isLeft())[0];
+  if (err)
+    return err;
+  var data = value.map((a) => a.assertRight().getRight());
+  return new Right(data);
+}
+function seqArrayEitherCollectRight(value) {
+  return seqArrayEitherFirstLeft(value.filter((a) => a.isRight()));
+}
+function seqArrayMaybeFirstNothing(a) {
+  const firstNothing = a.find((maybe) => maybe.isNothing());
+  if (firstNothing)
+    return new Nothing();
+  const values = a.map((maybe) => maybe.assertJust().getJust());
+  return new Just(values);
+}
+function seqArrayMaybeCollectJust(a) {
+  return seqArrayMaybeFirstNothing(a.filter((a2) => a2.isJust()));
+}
+function seqMaybeArray(a) {
+  return a.match(
+    () => [new Nothing()],
+    (array) => array.map((x) => new Just(x))
+  );
+}
+function seqMaybeTask(a) {
+  return a.match(
+    () => Task.pure(new Nothing()),
+    (task) => task.map((a2) => new Just(a2))
+  );
+}
+
+export {
+  seqArrayTask,
+  seqEitherTask,
+  seqEitherArray,
+  seqArrayEitherFirstLeft,
+  seqArrayEitherCollectRight,
+  seqArrayMaybeFirstNothing,
+  seqArrayMaybeCollectJust,
+  seqMaybeArray,
+  seqMaybeTask
+};

package/dist/esm/{chunk-VTI5CRVQ.js → chunk-BE7V6GBG.js}

@@ -1,3 +1,8 @@
+import {
+  Just,
+  Nothing
+} from "./chunk-NXA54GUD.js";
+
 // src/data/either.ts
 var Either = class {
   static pure(a) {
@@ -39,6 +44,12 @@ var Left = class _Left extends Either {
   match(onLeft, _onRight) {
     return onLeft(this.\u503C);
   }
+  mplus(a) {
+    return a;
+  }
+  toMaybe() {
+    return new Nothing();
+  }
 };
 var Right = class _Right extends Either {
   constructor(\u503C) {
@@ -75,6 +86,12 @@ var Right = class _Right extends Either {
   match(_onLeft, onRight) {
     return onRight(this.\u503C);
   }
+  mplus(_a) {
+    return this;
+  }
+  toMaybe() {
+    return new Just(this.\u503C);
+  }
 };
 
 export {

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

@@ -1,7 +1,7 @@
 import {
   Left,
   Right
-} from "./chunk-VTI5CRVQ.js";
+} from "./chunk-BE7V6GBG.js";
 
 // src/data/task.ts
 var TaskDo = class _TaskDo {

package/dist/esm/{chunk-CQG32QQC.js → chunk-NXA54GUD.js}

@@ -33,9 +33,12 @@ var Just = class _Just extends Maybe {
   getJustOrNull() {
     return this.\u503C;
   }
-  match(onJust, _onNothing) {
+  match(_onNothing, onJust) {
     return onJust(this.\u503C);
   }
+  mplus(_a) {
+    return this;
+  }
 };
 var Nothing = class _Nothing extends Maybe {
   map(_f) {
@@ -59,9 +62,12 @@ var Nothing = class _Nothing extends Maybe {
   getJustOrNull() {
     return null;
   }
-  match(_onJust, onNothing) {
+  match(onNothing, _onJust) {
     return onNothing();
   }
+  mplus(a) {
+    return a;
+  }
 };
 
 export {

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

@@ -1,3 +1,5 @@
+import { Maybe } from './maybe.js';
+
 declare abstract class Either<L, R> {
     static pure<L, R>(a: R): Either<L, R>;
     abstract map<B>(_f: (a: R) => B): Either<L, B>;
@@ -9,6 +11,8 @@ declare abstract class Either<L, R> {
     abstract assertLeft(): Left<L, R>;
     abstract assertRight(): Right<L, R>;
     abstract match<X>(onLeft: (a: L) => X, onRight: (a: R) => X): X;
+    abstract mplus(a: Either<L, R>): Either<L, R>;
+    abstract toMaybe(): Maybe<R>;
 }
 declare class Left<L, R> extends Either<L, R> {
     private 值;
@@ -23,6 +27,8 @@ declare class Left<L, R> extends Either<L, R> {
     assertLeft(): Left<L, R>;
     assertRight(): Right<L, R>;
     match<X>(onLeft: (a: L) => X, _onRight: (a: R) => X): X;
+    mplus(a: Either<L, R>): Either<L, R>;
+    toMaybe(): Maybe<R>;
 }
 declare class Right<L, R> extends Either<L, R> {
     private 值;
@@ -37,6 +43,8 @@ declare class Right<L, R> extends Either<L, R> {
     assertLeft(): Left<L, R>;
     assertRight(): Right<L, R>;
     match<X>(_onLeft: (a: L) => X, onRight: (a: R) => X): X;
+    mplus(_a: Either<L, R>): Either<L, R>;
+    toMaybe(): Maybe<R>;
 }
 
 export { Either, Left, Right };

package/dist/esm/data/either.js

@@ -2,7 +2,8 @@ import {
   Either,
   Left,
   Right
-} from "../chunk-VTI5CRVQ.js";
+} from "../chunk-BE7V6GBG.js";
+import "../chunk-NXA54GUD.js";
 export {
   Either,
   Left,

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

@@ -5,9 +5,10 @@ declare abstract class Maybe<A> {
     abstract isJust(): this is Just<A>;
     abstract isNothing(): this is Nothing<A>;
     abstract assertJust(): Just<A>;
-    abstract assertNothing(): Nothing<A>;
+    abstract assertNothing(): Nothing<any>;
     abstract getJustOrNull(): A | null;
-    abstract match<B>(onJust: (a: A) => B, onNothing: () => B): B;
+    abstract match<B>(onNothing: () => B, onJust: (a: A) => B): B;
+    abstract mplus(a: Maybe<A>): Maybe<A>;
 }
 declare class Just<A> extends Maybe<A> {
     private 值;
@@ -20,7 +21,8 @@ declare class Just<A> extends Maybe<A> {
     assertNothing(): Nothing<A>;
     getJust(): A;
     getJustOrNull(): A | null;
-    match<B>(onJust: (a: A) => B, _onNothing: () => B): B;
+    match<B>(_onNothing: () => B, onJust: (a: A) => B): B;
+    mplus(_a: Maybe<A>): Maybe<A>;
 }
 declare class Nothing<A> extends Maybe<A> {
     map<B>(_f: (a: A) => B): Maybe<B>;
@@ -30,7 +32,8 @@ declare class Nothing<A> extends Maybe<A> {
     assertJust(): Just<A>;
     assertNothing(): Nothing<A>;
     getJustOrNull(): A | null;
-    match<B>(_onJust: (a: A) => B, onNothing: () => B): B;
+    match<B>(onNothing: () => B, _onJust: (a: A) => B): B;
+    mplus(a: Maybe<A>): Maybe<A>;
 }
 
 export { Just, Maybe, Nothing };

package/dist/esm/data/maybe.js

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

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

@@ -1,4 +1,5 @@
 import { Either } from './either.js';
+import './maybe.js';
 
 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>;

package/dist/esm/data/task.js

@@ -1,8 +1,9 @@
 import {
   Task,
   TaskDo
-} from "../chunk-OYLE35IQ.js";
-import "../chunk-VTI5CRVQ.js";
+} from "../chunk-IB4BVSOW.js";
+import "../chunk-BE7V6GBG.js";
+import "../chunk-NXA54GUD.js";
 export {
   Task,
   TaskDo

package/dist/esm/func/seq.d.ts

@@ -5,8 +5,11 @@ import { Task } from '../data/task.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>>;
-declare function seqMaybePromise<A>(a: Maybe<Promise<A>>): Promise<Maybe<A>>;
-declare function seqEitherPromise<L, R>(a: Either<L, Promise<R>>): Promise<Either<L, R>>;
+declare function seqArrayEitherFirstLeft<A, B>(value: Array<Either<A, B>>): Either<A, Array<B>>;
+declare function seqArrayEitherCollectRight<A, B>(value: Array<Either<A, B>>): Either<A, Array<B>>;
+declare function seqArrayMaybeFirstNothing<X>(a: Array<Maybe<X>>): Maybe<Array<X>>;
+declare function seqArrayMaybeCollectJust<X>(a: Array<Maybe<X>>): Maybe<Array<X>>;
+declare function seqMaybeArray<X>(a: Maybe<Array<X>>): Array<Maybe<X>>;
+declare function seqMaybeTask<X>(a: Maybe<Task<X>>): Task<Maybe<X>>;
 
-export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherPromise, seqEitherTask, seqMaybePromise };
+export { seqArrayEitherCollectRight, seqArrayEitherFirstLeft, seqArrayMaybeCollectJust, seqArrayMaybeFirstNothing, seqArrayTask, seqEitherArray, seqEitherTask, seqMaybeArray, seqMaybeTask };

package/dist/esm/func/seq.js

@@ -1,19 +1,25 @@
 import {
-  seqArrayEither,
+  seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing,
   seqArrayTask,
   seqEitherArray,
-  seqEitherPromise,
   seqEitherTask,
-  seqMaybePromise
-} from "../chunk-UQKW2A3C.js";
-import "../chunk-CQG32QQC.js";
-import "../chunk-OYLE35IQ.js";
-import "../chunk-VTI5CRVQ.js";
+  seqMaybeArray,
+  seqMaybeTask
+} from "../chunk-B2G2C6YM.js";
+import "../chunk-IB4BVSOW.js";
+import "../chunk-BE7V6GBG.js";
+import "../chunk-NXA54GUD.js";
 export {
-  seqArrayEither,
+  seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing,
   seqArrayTask,
   seqEitherArray,
-  seqEitherPromise,
   seqEitherTask,
-  seqMaybePromise
+  seqMaybeArray,
+  seqMaybeTask
 };

package/dist/esm/index.d.ts

@@ -2,4 +2,4 @@ export { Either, Left, Right } from './data/either.js';
 export { Lazy, LazyDeferValue, LazyForceValue } from './data/lazy.js';
 export { Just, Maybe, Nothing } from './data/maybe.js';
 export { Task, TaskDo, TaskDoType, TaskDoTypeBase, TaskDoTypeGet, TaskDoTypeIf, TaskDoTypeIfReturn, TaskDoTypeNoGet, TaskDoTypeReturn } from './data/task.js';
-export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherPromise, seqEitherTask, seqMaybePromise } from './func/seq.js';
+export { seqArrayEitherCollectRight, seqArrayEitherFirstLeft, seqArrayMaybeCollectJust, seqArrayMaybeFirstNothing, seqArrayTask, seqEitherArray, seqEitherTask, seqMaybeArray, seqMaybeTask } from './func/seq.js';

package/dist/esm/index.js

@@ -4,27 +4,30 @@ import {
   LazyForceValue
 } from "./chunk-NEBLA4MD.js";
 import {
-  seqArrayEither,
+  seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing,
   seqArrayTask,
   seqEitherArray,
-  seqEitherPromise,
   seqEitherTask,
-  seqMaybePromise
-} from "./chunk-UQKW2A3C.js";
-import {
-  Just,
-  Maybe,
-  Nothing
-} from "./chunk-CQG32QQC.js";
+  seqMaybeArray,
+  seqMaybeTask
+} from "./chunk-B2G2C6YM.js";
 import {
   Task,
   TaskDo
-} from "./chunk-OYLE35IQ.js";
+} from "./chunk-IB4BVSOW.js";
 import {
   Either,
   Left,
   Right
-} from "./chunk-VTI5CRVQ.js";
+} from "./chunk-BE7V6GBG.js";
+import {
+  Just,
+  Maybe,
+  Nothing
+} from "./chunk-NXA54GUD.js";
 export {
   Either,
   Just,
@@ -37,10 +40,13 @@ export {
   Right,
   Task,
   TaskDo,
-  seqArrayEither,
+  seqArrayEitherCollectRight,
+  seqArrayEitherFirstLeft,
+  seqArrayMaybeCollectJust,
+  seqArrayMaybeFirstNothing,
   seqArrayTask,
   seqEitherArray,
-  seqEitherPromise,
   seqEitherTask,
-  seqMaybePromise
+  seqMaybeArray,
+  seqMaybeTask
 };

package/package.json

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

package/dist/esm/chunk-UQKW2A3C.js

@@ -1,58 +0,0 @@
-import {
-  Just,
-  Nothing
-} from "./chunk-CQG32QQC.js";
-import {
-  Task
-} from "./chunk-OYLE35IQ.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);
-}
-function seqMaybePromise(a) {
-  return a.match(
-    async (a2) => new Just(await a2),
-    async () => new Nothing()
-  );
-}
-function seqEitherPromise(a) {
-  return a.match(
-    async (a2) => new Left(a2),
-    async (a2) => new Right(await a2)
-  );
-}
-
-export {
-  seqArrayTask,
-  seqEitherTask,
-  seqEitherArray,
-  seqArrayEither,
-  seqMaybePromise,
-  seqEitherPromise
-};