@lsby/ts-fp-data 0.1.0 → 0.1.4

package/dist/cjs/data/lazy.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/data/lazy.ts
+var lazy_exports = {};
+__export(lazy_exports, {
+  Lazy: () => Lazy,
+  LazyDeferValue: () => LazyDeferValue,
+  LazyForceValue: () => LazyForceValue
+});
+module.exports = __toCommonJS(lazy_exports);
+var Lazy = class {
+};
+var LazyDeferValue = class _LazyDeferValue extends Lazy {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  cache = null;
+  run() {
+    if (this.cache)
+      return this.cache;
+    this.cache = this.value();
+    return this.cache;
+  }
+  map(f) {
+    return new _LazyDeferValue(() => f(this.run()));
+  }
+};
+var LazyForceValue = class _LazyForceValue extends Lazy {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  run() {
+    return this.value;
+  }
+  map(f) {
+    return new _LazyForceValue(f(this.run()));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Lazy,
+  LazyDeferValue,
+  LazyForceValue
+});

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

@@ -0,0 +1,19 @@
+declare abstract class Lazy<A> {
+    abstract run(): A;
+    abstract map<B>(f: (a: A) => B): Lazy<B>;
+}
+declare class LazyDeferValue<A> extends Lazy<A> {
+    private value;
+    private cache;
+    constructor(value: () => A);
+    run(): A;
+    map<B>(f: (a: A) => B): Lazy<B>;
+}
+declare class LazyForceValue<A> extends Lazy<A> {
+    private value;
+    constructor(value: A);
+    run(): A;
+    map<B>(f: (a: A) => B): Lazy<B>;
+}
+
+export { Lazy, LazyDeferValue, LazyForceValue };

package/dist/cjs/func/seq.cjs

@@ -23,7 +23,9 @@ __export(seq_exports, {
   seqArrayEither: () => seqArrayEither,
   seqArrayTask: () => seqArrayTask,
   seqEitherArray: () => seqEitherArray,
-  seqEitherTask: () => seqEitherTask
+  seqEitherPromise: () => seqEitherPromise,
+  seqEitherTask: () => seqEitherTask,
+  seqMaybePromise: () => seqMaybePromise
 });
 module.exports = __toCommonJS(seq_exports);
 
@@ -106,6 +108,72 @@ var Right = class _Right extends Either {
   }
 };
 
+// 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) {
@@ -225,10 +293,24 @@ function seqArrayEither(value) {
   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)
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
-  seqEitherTask
+  seqEitherPromise,
+  seqEitherTask,
+  seqMaybePromise
 });

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

@@ -1,9 +1,12 @@
 import { Either } from '../data/either.cjs';
+import { Maybe } from '../data/maybe.cjs';
 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>>;
 
-export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherTask };
+export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherPromise, seqEitherTask, seqMaybePromise };

package/dist/cjs/index.cjs

@@ -22,6 +22,9 @@ var src_exports = {};
 __export(src_exports, {
   Either: () => Either,
   Just: () => Just,
+  Lazy: () => Lazy,
+  LazyDeferValue: () => LazyDeferValue,
+  LazyForceValue: () => LazyForceValue,
   Left: () => Left,
   Maybe: () => Maybe,
   Nothing: () => Nothing,
@@ -31,7 +34,9 @@ __export(src_exports, {
   seqArrayEither: () => seqArrayEither,
   seqArrayTask: () => seqArrayTask,
   seqEitherArray: () => seqEitherArray,
-  seqEitherTask: () => seqEitherTask
+  seqEitherPromise: () => seqEitherPromise,
+  seqEitherTask: () => seqEitherTask,
+  seqMaybePromise: () => seqMaybePromise
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -114,6 +119,104 @@ var Right = class _Right extends Either {
   }
 };
 
+// src/data/lazy.ts
+var Lazy = class {
+};
+var LazyDeferValue = class _LazyDeferValue extends Lazy {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  cache = null;
+  run() {
+    if (this.cache)
+      return this.cache;
+    this.cache = this.value();
+    return this.cache;
+  }
+  map(f) {
+    return new _LazyDeferValue(() => f(this.run()));
+  }
+};
+var LazyForceValue = class _LazyForceValue extends Lazy {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  run() {
+    return this.value;
+  }
+  map(f) {
+    return new _LazyForceValue(f(this.run()));
+  }
+};
+
+// 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) {
@@ -208,72 +311,6 @@ var Task = class _Task {
   }
 };
 
-// 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/func/seq.ts
 function seqArrayTask(a) {
   return new Task(async () => {
@@ -299,10 +336,25 @@ function seqArrayEither(value) {
   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)
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Either,
   Just,
+  Lazy,
+  LazyDeferValue,
+  LazyForceValue,
   Left,
   Maybe,
   Nothing,
@@ -312,5 +364,7 @@ function seqArrayEither(value) {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
-  seqEitherTask
+  seqEitherPromise,
+  seqEitherTask,
+  seqMaybePromise
 });

package/dist/cjs/index.d.cts

@@ -1,4 +1,5 @@
-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';
+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';

package/dist/esm/chunk-NEBLA4MD.js

@@ -0,0 +1,37 @@
+// src/data/lazy.ts
+var Lazy = class {
+};
+var LazyDeferValue = class _LazyDeferValue extends Lazy {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  cache = null;
+  run() {
+    if (this.cache)
+      return this.cache;
+    this.cache = this.value();
+    return this.cache;
+  }
+  map(f) {
+    return new _LazyDeferValue(() => f(this.run()));
+  }
+};
+var LazyForceValue = class _LazyForceValue extends Lazy {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  run() {
+    return this.value;
+  }
+  map(f) {
+    return new _LazyForceValue(f(this.run()));
+  }
+};
+
+export {
+  Lazy,
+  LazyDeferValue,
+  LazyForceValue
+};

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

@@ -1,3 +1,7 @@
+import {
+  Just,
+  Nothing
+} from "./chunk-CQG32QQC.js";
 import {
   Task
 } from "./chunk-OYLE35IQ.js";
@@ -31,10 +35,24 @@ function seqArrayEither(value) {
   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
+  seqArrayEither,
+  seqMaybePromise,
+  seqEitherPromise
 };

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

@@ -0,0 +1,19 @@
+declare abstract class Lazy<A> {
+    abstract run(): A;
+    abstract map<B>(f: (a: A) => B): Lazy<B>;
+}
+declare class LazyDeferValue<A> extends Lazy<A> {
+    private value;
+    private cache;
+    constructor(value: () => A);
+    run(): A;
+    map<B>(f: (a: A) => B): Lazy<B>;
+}
+declare class LazyForceValue<A> extends Lazy<A> {
+    private value;
+    constructor(value: A);
+    run(): A;
+    map<B>(f: (a: A) => B): Lazy<B>;
+}
+
+export { Lazy, LazyDeferValue, LazyForceValue };

package/dist/esm/data/lazy.js

@@ -0,0 +1,10 @@
+import {
+  Lazy,
+  LazyDeferValue,
+  LazyForceValue
+} from "../chunk-NEBLA4MD.js";
+export {
+  Lazy,
+  LazyDeferValue,
+  LazyForceValue
+};

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

@@ -1,9 +1,12 @@
 import { Either } from '../data/either.js';
+import { Maybe } from '../data/maybe.js';
 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>>;
 
-export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherTask };
+export { seqArrayEither, seqArrayTask, seqEitherArray, seqEitherPromise, seqEitherTask, seqMaybePromise };

package/dist/esm/func/seq.js

@@ -2,13 +2,18 @@ import {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
-  seqEitherTask
-} from "../chunk-IHXXIFRN.js";
+  seqEitherPromise,
+  seqEitherTask,
+  seqMaybePromise
+} from "../chunk-UQKW2A3C.js";
+import "../chunk-CQG32QQC.js";
 import "../chunk-OYLE35IQ.js";
 import "../chunk-VTI5CRVQ.js";
 export {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
-  seqEitherTask
+  seqEitherPromise,
+  seqEitherTask,
+  seqMaybePromise
 };

package/dist/esm/index.d.ts

@@ -1,4 +1,5 @@
-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';
+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';

package/dist/esm/index.js

@@ -1,14 +1,21 @@
 import {
-  Just,
-  Maybe,
-  Nothing
-} from "./chunk-CQG32QQC.js";
+  Lazy,
+  LazyDeferValue,
+  LazyForceValue
+} from "./chunk-NEBLA4MD.js";
 import {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
-  seqEitherTask
-} from "./chunk-IHXXIFRN.js";
+  seqEitherPromise,
+  seqEitherTask,
+  seqMaybePromise
+} from "./chunk-UQKW2A3C.js";
+import {
+  Just,
+  Maybe,
+  Nothing
+} from "./chunk-CQG32QQC.js";
 import {
   Task,
   TaskDo
@@ -21,6 +28,9 @@ import {
 export {
   Either,
   Just,
+  Lazy,
+  LazyDeferValue,
+  LazyForceValue,
   Left,
   Maybe,
   Nothing,
@@ -30,5 +40,7 @@ export {
   seqArrayEither,
   seqArrayTask,
   seqEitherArray,
-  seqEitherTask
+  seqEitherPromise,
+  seqEitherTask,
+  seqMaybePromise
 };

package/package.json

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