@thi.ng/compose 2.1.71 → 3.0.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-03-27T09:53:45Z
+- **Last updated**: 2024-04-11T12:32:44Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,23 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+# [3.0.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/compose@3.0.0) (2024-04-08)
+
+#### 🛑 Breaking changes
+
+- remove/migrate delay() to different pkg ([745abbb](https://github.com/thi-ng/umbrella/commit/745abbb))
+- BREAKING CHANGE: migrate delay() & Delay class to [@thi.ng/memoize](https://github.com/thi-ng/umbrella/tree/main/packages/memoize)
+  - see [d8f4733c05e724c38195f209337d0a015e049ac4](https://github.com/thi-ng/umbrella/commit/d8f4733c05e724c38195f209337d0a015e049ac4) for details
+
+#### 🚀 Features
+
+- add async composition helpers ([168ea42](https://github.com/thi-ng/umbrella/commit/168ea42))
+  - add async functions:
+    - compAsync()
+    - juxtAsync()
+    - threadFirstAsync()/threadLastAsync()
+    - trampolineAsync()
+
 ### [2.1.35](https://github.com/thi-ng/umbrella/tree/@thi.ng/compose@2.1.35) (2023-08-04)
 
 #### ♻️ Refactoring

package/README.md

@@ -7,7 +7,7 @@
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/109331703950160316?domain=https%3A%2F%2Fmastodon.thi.ng&style=social)](https://mastodon.thi.ng/@toxi)
 
 > [!NOTE]
-> This is one of 190 standalone projects, maintained as part
+> This is one of 192 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -15,6 +15,8 @@
 > GitHub](https://github.com/sponsors/postspectacular). Thank you! ❤️
 
 - [About](#about)
+- [Composition helpers](#composition-helpers)
+  - [Async functions](#async-functions)
 - [Status](#status)
 - [Installation](#installation)
 - [Dependencies](#dependencies)
@@ -27,6 +29,28 @@
 
 Optimized functional composition helpers.
 
+## Composition helpers
+
+- [comp()](https://docs.thi.ng/umbrella/compose/functions/comp.html)
+- [compLeft()](https://docs.thi.ng/umbrella/compose/functions/compLeft.html)
+- [complement()](https://docs.thi.ng/umbrella/compose/functions/complement.html)
+- [constantly()](https://docs.thi.ng/umbrella/compose/functions/constantly.html)
+- [juxt()](https://docs.thi.ng/umbrella/compose/functions/juxt.html)
+- [partial()](https://docs.thi.ng/umbrella/compose/functions/partial.html)
+- [threadFirst()](https://docs.thi.ng/umbrella/compose/functions/threadFirst.html)
+- [threadLast()](https://docs.thi.ng/umbrella/compose/functions/threadLast.html)
+- [trampoline()](https://docs.thi.ng/umbrella/compose/functions/trampoline.html)
+
+### Async functions
+
+- [compAsync()](https://docs.thi.ng/umbrella/compose/functions/compAsync.html)
+- [delayed()](https://docs.thi.ng/umbrella/compose/functions/delayed.html)
+- [juxtAsync()](https://docs.thi.ng/umbrella/compose/functions/juxtAsync.html)
+- [promisify()](https://docs.thi.ng/umbrella/compose/functions/promisify.html)
+- [threadFirstAsync()](https://docs.thi.ng/umbrella/compose/functions/threadFirstAsync.html)
+- [threadLastAsync()](https://docs.thi.ng/umbrella/compose/functions/threadLastAsync.html)
+- [trampolineAsync()](https://docs.thi.ng/umbrella/compose/functions/trampolineAsync.html)
+
 ## Status
 
 **STABLE** - used in production
@@ -39,7 +63,13 @@ Optimized functional composition helpers.
 yarn add @thi.ng/compose
 ```
 
-ES module import:
+ESM import:
+
+```ts
+import * as comp from "@thi.ng/compose";
+```
+
+Browser ESM import:
 
 ```html
 <script type="module" src="https://cdn.skypack.dev/@thi.ng/compose"></script>
@@ -50,10 +80,10 @@ ES module import:
 For Node.js REPL:
 
 ```js
-const compose = await import("@thi.ng/compose");
+const comp = await import("@thi.ng/compose");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 858 bytes
+Package sizes (brotli'd, pre-treeshake): ESM: 815 bytes
 
 ## Dependencies
 
@@ -75,14 +105,6 @@ directory are using this package:
 
 [Generated API docs](https://docs.thi.ng/umbrella/compose/)
 
-- [comp()](https://github.com/thi-ng/umbrella/tree/develop/packages/compose/src/comp.ts)
-- [compL()](https://github.com/thi-ng/umbrella/tree/develop/packages/compose/src/comp.ts#L52)
-- [juxt()](https://github.com/thi-ng/umbrella/tree/develop/packages/compose/src/juxt.ts)
-- [partial()](https://github.com/thi-ng/umbrella/tree/develop/packages/compose/src/partial.ts)
-- [threadFirst()](https://github.com/thi-ng/umbrella/tree/develop/packages/compose/src/thread-first.ts)
-- [threadLast()](https://github.com/thi-ng/umbrella/tree/develop/packages/compose/src/thread-last.ts)
-- [trampoline()](https://github.com/thi-ng/umbrella/tree/develop/packages/compose/src/trampoline.ts)
-
 ## Authors
 
 - [Karsten Schmidt](https://thi.ng)

package/comp.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnAny } from "@thi.ng/api";
+import type { Fn, FnA, FnAny, FnAnyA } from "@thi.ng/api";
 /**
  * Returns the right-to-left composition of given functions. I.e. when
  * the composed function is called, the given right most function is
@@ -20,19 +20,33 @@ export declare function comp<A, B, C, D, E, F, G, H, I, J>(a: Fn<B, A>, b: Fn<C,
 /**
  * Similar to {@link comp}, but composes given functions in left-to-right order.
  */
-export declare function compL<A>(a: FnAny<A>): FnAny<A>;
-export declare function compL<A, B>(a: FnAny<A>, b: Fn<A, B>): FnAny<B>;
-export declare function compL<A, B, C>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>): FnAny<C>;
-export declare function compL<A, B, C, D>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>): FnAny<D>;
-export declare function compL<A, B, C, D, E>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>): FnAny<E>;
-export declare function compL<A, B, C, D, E, F>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>): FnAny<F>;
-export declare function compL<A, B, C, D, E, F, G>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>): FnAny<G>;
-export declare function compL<A, B, C, D, E, F, G, H>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>): FnAny<H>;
-export declare function compL<A, B, C, D, E, F, G, H, I>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>, i: Fn<H, I>): FnAny<I>;
-export declare function compL<A, B, C, D, E, F, G, H, I, J>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>, i: Fn<H, I>, j: Fn<I, J>): FnAny<J>;
-export declare function compL<A, B, C, D, E, F, G, H, I, J>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>, i: Fn<H, I>, j: Fn<I, J>, ...xs: Fn<any, any>[]): FnAny<any>;
+export declare function compLeft<A>(a: FnAny<A>): FnAny<A>;
+export declare function compLeft<A, B>(a: FnAny<A>, b: Fn<A, B>): FnAny<B>;
+export declare function compLeft<A, B, C>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>): FnAny<C>;
+export declare function compLeft<A, B, C, D>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>): FnAny<D>;
+export declare function compLeft<A, B, C, D, E>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>): FnAny<E>;
+export declare function compLeft<A, B, C, D, E, F>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>): FnAny<F>;
+export declare function compLeft<A, B, C, D, E, F, G>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>): FnAny<G>;
+export declare function compLeft<A, B, C, D, E, F, G, H>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>): FnAny<H>;
+export declare function compLeft<A, B, C, D, E, F, G, H, I>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>, i: Fn<H, I>): FnAny<I>;
+export declare function compLeft<A, B, C, D, E, F, G, H, I, J>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>, i: Fn<H, I>, j: Fn<I, J>): FnAny<J>;
+export declare function compLeft<A, B, C, D, E, F, G, H, I, J>(a: FnAny<A>, b: Fn<A, B>, c: Fn<B, C>, d: Fn<C, D>, e: Fn<D, E>, f: Fn<E, F>, g: Fn<F, G>, h: Fn<G, H>, i: Fn<H, I>, j: Fn<I, J>, ...xs: Fn<any, any>[]): FnAny<any>;
 /**
- * @deprecated renamed to {@link compL}
+ * @deprecated renamed to {@link compLeft}.
  */
-export declare const compI: typeof compL;
+export declare const compL: typeof compLeft;
+/**
+ * Async version of {@link comp}.
+ */
+export declare function compAsync<A, B>(a: FnAnyA<A>): FnAnyA<A>;
+export declare function compAsync<A, B>(a: FnA<B, A>, b: FnAnyA<B>): FnAnyA<A>;
+export declare function compAsync<A, B, C>(a: FnA<B, A>, b: FnA<C, B>, c: FnAnyA<C>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnAnyA<D>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D, E>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnA<E, D>, e: FnAnyA<D>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D, E, F>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnA<E, D>, e: FnA<F, E>, f: FnAnyA<F>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D, E, F, G>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnA<E, D>, e: FnA<F, E>, f: FnA<G, F>, g: FnAnyA<G>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D, E, F, G, H>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnA<E, D>, e: FnA<F, E>, f: FnA<G, F>, g: FnA<H, G>, h: FnAnyA<H>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D, E, F, G, H, I>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnA<E, D>, e: FnA<F, E>, f: FnA<G, F>, g: FnA<H, G>, h: FnA<I, H>, i: FnAnyA<I>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D, E, F, G, H, I, J>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnA<E, D>, e: FnA<F, E>, f: FnA<G, F>, g: FnA<H, G>, h: FnA<I, H>, i: FnA<J, I>, j: FnAnyA<J>): FnAnyA<A>;
+export declare function compAsync<A, B, C, D, E, F, G, H, I, J>(a: FnA<B, A>, b: FnA<C, B>, c: FnA<D, C>, d: FnA<E, D>, e: FnA<F, E>, f: FnA<G, F>, g: FnA<H, G>, h: FnA<I, H>, i: FnA<J, I>, j: FnA<any, J>, ...fns: FnAnyA<any>[]): FnAnyA<A>;
 //# sourceMappingURL=comp.d.ts.map

package/comp.js

@@ -28,12 +28,23 @@ function comp(...fns) {
       return fns.length === 10 ? fn : comp(fn, ...fns.slice(10));
   }
 }
-function compL(...fns) {
+function compLeft(...fns) {
   return comp.apply(null, fns.reverse());
 }
-const compI = compL;
+const compL = compLeft;
+function compAsync(...fns) {
+  return async (...xs) => {
+    let n = fns.length - 1;
+    let res = fns[n](...xs);
+    while (n-- > 0) {
+      res = await fns[n](res);
+    }
+    return res;
+  };
+}
 export {
   comp,
-  compI,
-  compL
+  compAsync,
+  compL,
+  compLeft
 };

package/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./comp.js";
 export * from "./complement.js";
 export * from "./constantly.js";
-export * from "./delay.js";
 export * from "./delayed.js";
 export * from "./identity.js";
 export * from "./ifdef.js";

package/index.js

@@ -1,7 +1,6 @@
 export * from "./comp.js";
 export * from "./complement.js";
 export * from "./constantly.js";
-export * from "./delay.js";
 export * from "./delayed.js";
 export * from "./identity.js";
 export * from "./ifdef.js";

package/juxt.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from "@thi.ng/api";
+import type { Fn, FnA } from "@thi.ng/api";
 export declare function juxt<T, A>(a: Fn<T, A>): Fn<T, [A]>;
 export declare function juxt<T, A, B>(a: Fn<T, A>, b: Fn<T, B>): Fn<T, [A, B]>;
 export declare function juxt<T, A, B, C>(a: Fn<T, A>, b: Fn<T, B>, c: Fn<T, C>): Fn<T, [A, B, C]>;
@@ -8,4 +8,20 @@ export declare function juxt<T, A, B, C, D, E, F>(a: Fn<T, A>, b: Fn<T, B>, c: F
 export declare function juxt<T, A, B, C, D, E, F, G>(a: Fn<T, A>, b: Fn<T, B>, c: Fn<T, C>, d: Fn<T, D>, e: Fn<T, E>, f: Fn<T, F>, g: Fn<T, G>): Fn<T, [A, B, C, D, E, F, G]>;
 export declare function juxt<T, A, B, C, D, E, F, G, H>(a: Fn<T, A>, b: Fn<T, B>, c: Fn<T, C>, d: Fn<T, D>, e: Fn<T, E>, f: Fn<T, F>, g: Fn<T, G>, h: Fn<T, H>): Fn<T, [A, B, C, D, E, F, G, H]>;
 export declare function juxt<T, A, B, C, D, E, F, G, H>(a: Fn<T, A>, b: Fn<T, B>, c: Fn<T, C>, d: Fn<T, D>, e: Fn<T, E>, f: Fn<T, F>, g: Fn<T, G>, h: Fn<T, H>, ...xs: Fn<T, any>[]): Fn<T, any[]>;
+/**
+ * Async version of {@link juxt}. Returns an async function which takes a single
+ * arg `x`, calls all given functions with `x` and then waits for all results
+ * before returning them as tuple.
+ *
+ * @param a
+ */
+export declare function juxtAsync<T, A>(a: FnA<T, A>): FnA<T, [A]>;
+export declare function juxtAsync<T, A, B>(a: FnA<T, A>, b: FnA<T, B>): FnA<T, [A, B]>;
+export declare function juxtAsync<T, A, B, C>(a: FnA<T, A>, b: FnA<T, B>, c: FnA<T, C>): FnA<T, [A, B, C]>;
+export declare function juxtAsync<T, A, B, C, D>(a: FnA<T, A>, b: FnA<T, B>, c: FnA<T, C>, d: FnA<T, D>): FnA<T, [A, B, C, D]>;
+export declare function juxtAsync<T, A, B, C, D, E>(a: FnA<T, A>, b: FnA<T, B>, c: FnA<T, C>, d: FnA<T, D>, e: FnA<T, E>): FnA<T, [A, B, C, D, E]>;
+export declare function juxtAsync<T, A, B, C, D, E, F>(a: FnA<T, A>, b: FnA<T, B>, c: FnA<T, C>, d: FnA<T, D>, e: FnA<T, E>, f: FnA<T, F>): FnA<T, [A, B, C, D, E, F]>;
+export declare function juxtAsync<T, A, B, C, D, E, F, G>(a: FnA<T, A>, b: FnA<T, B>, c: FnA<T, C>, d: FnA<T, D>, e: FnA<T, E>, f: FnA<T, F>, g: FnA<T, G>): FnA<T, [A, B, C, D, E, F, G]>;
+export declare function juxtAsync<T, A, B, C, D, E, F, G, H>(a: FnA<T, A>, b: FnA<T, B>, c: FnA<T, C>, d: FnA<T, D>, e: FnA<T, E>, f: FnA<T, F>, g: FnA<T, G>, h: FnA<T, H>): FnA<T, [A, B, C, D, E, F, G, H]>;
+export declare function juxtAsync<T, A, B, C, D, E, F, G, H>(a: FnA<T, A>, b: FnA<T, B>, c: FnA<T, C>, d: FnA<T, D>, e: FnA<T, E>, f: FnA<T, F>, g: FnA<T, G>, h: FnA<T, H>, ...xs: FnA<T, any>[]): FnA<T, any[]>;
 //# sourceMappingURL=juxt.d.ts.map

package/juxt.js

@@ -27,6 +27,10 @@ function juxt(...fns) {
       };
   }
 }
+function juxtAsync(...fns) {
+  return async (x) => await Promise.all(fns.map((f) => f(x)));
+}
 export {
-  juxt
+  juxt,
+  juxtAsync
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/compose",
-  "version": "2.1.71",
+  "version": "3.0.1",
   "description": "Optimized functional composition helpers",
   "type": "module",
   "module": "./index.js",
@@ -36,8 +36,8 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.31",
-    "@thi.ng/errors": "^2.5.2"
+    "@thi.ng/api": "^8.10.1",
+    "@thi.ng/errors": "^2.5.4"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.43.0",
@@ -75,9 +75,6 @@
     "./constantly": {
       "default": "./constantly.js"
     },
-    "./delay": {
-      "default": "./delay.js"
-    },
     "./delayed": {
       "default": "./delayed.js"
     },
@@ -106,5 +103,8 @@
       "default": "./trampoline.js"
     }
   },
-  "gitHead": "feb3b24654f2c931cd3c3308c1c0c807ee14d0e4\n"
+  "thi.ng": {
+    "alias": "comp"
+  },
+  "gitHead": "18a0c063a7b33d790e5bc2486c106f45f663ac28\n"
 }

package/thread-first.d.ts

@@ -1,4 +1,4 @@
-import type { FnAny } from "@thi.ng/api";
+import type { FnAny, FnAnyA, MaybePromise } from "@thi.ng/api";
 /**
  * Similar to {@link threadLast}. A dataflow operator to improve the legibility
  * of long (or deeply nested) call expressions. Takes an `init` value and a
@@ -38,4 +38,14 @@ import type { FnAny } from "@thi.ng/api";
  * @param fns - functions / S-expressions
  */
 export declare const threadFirst: (init: any, ...fns: (FnAny<any> | [FnAny<any>, ...any[]])[]) => any;
+/**
+ * Async version of {@link threadFirst}.
+ *
+ * @remarks
+ * Also see {@link threadLastAsync}.
+ *
+ * @param init
+ * @param fns
+ */
+export declare const threadFirstAsync: (init: MaybePromise<any>, ...fns: (FnAnyA<any> | [FnAnyA<any>, ...any[]])[]) => Promise<any>;
 //# sourceMappingURL=thread-first.d.ts.map

package/thread-first.js

@@ -2,6 +2,14 @@ const threadFirst = (init, ...fns) => fns.reduce(
   (acc, expr) => typeof expr === "function" ? expr(acc) : expr[0](acc, ...expr.slice(1)),
   init
 );
+const threadFirstAsync = async (init, ...fns) => {
+  let res = await init;
+  for (let expr of fns) {
+    res = await (typeof expr === "function" ? expr(res) : expr[0](res, ...expr.slice(1)));
+  }
+  return res;
+};
 export {
-  threadFirst
+  threadFirst,
+  threadFirstAsync
 };

package/thread-last.d.ts

@@ -1,4 +1,4 @@
-import type { FnAny } from "@thi.ng/api";
+import type { FnAny, FnAnyA, MaybePromise } from "@thi.ng/api";
 /**
  * Similar to {@link threadFirst}. A dataflow operator to improve the legibility
  * of long (or deeply nested) call expressions. Takes an `init` value and a
@@ -38,4 +38,14 @@ import type { FnAny } from "@thi.ng/api";
  * @param fns - functions / S-expressions
  */
 export declare const threadLast: (init: any, ...fns: (FnAny<any> | [FnAny<any>, ...any[]])[]) => any;
+/**
+ * Async version of {@link threadLast}.
+ *
+ * @remarks
+ * Also see {@link threadFirstAsync}.
+ *
+ * @param init
+ * @param fns
+ */
+export declare const threadLastAsync: (init: MaybePromise<any>, ...fns: (FnAnyA<any> | [FnAnyA<any>, ...any[]])[]) => Promise<any>;
 //# sourceMappingURL=thread-last.d.ts.map

package/thread-last.js

@@ -2,6 +2,14 @@ const threadLast = (init, ...fns) => fns.reduce(
   (acc, expr) => typeof expr === "function" ? expr(acc) : expr[0](...expr.slice(1), acc),
   init
 );
+const threadLastAsync = async (init, ...fns) => {
+  let res = await init;
+  for (let expr of fns) {
+    res = await (typeof expr === "function" ? expr(res) : expr[0](...expr.slice(1), res));
+  }
+  return res;
+};
 export {
-  threadLast
+  threadLast,
+  threadLastAsync
 };

package/trampoline.d.ts

@@ -1,4 +1,4 @@
-import type { Fn0 } from "@thi.ng/api";
+import type { Fn0, Fn0A, MaybePromise } from "@thi.ng/api";
 /**
  * Takes a function returning either a no-arg function (thunk) or its
  * already realized (non-function) result. Re-executes thunk for as long
@@ -32,4 +32,10 @@ import type { Fn0 } from "@thi.ng/api";
  * @param f - function
  */
 export declare const trampoline: <T>(f: T | Fn0<T | Fn0<T>>) => T;
+/**
+ * Async version of {@link trampoline}.
+ *
+ * @param f - function
+ */
+export declare const trampolineAsync: <T>(f: MaybePromise<T | Fn0A<T | Fn0A<T>>>) => Promise<T>;
 //# sourceMappingURL=trampoline.d.ts.map

package/trampoline.js

@@ -4,6 +4,14 @@ const trampoline = (f) => {
   }
   return f;
 };
+const trampolineAsync = async (f) => {
+  f = await f;
+  while (typeof f === "function") {
+    f = await f();
+  }
+  return f;
+};
 export {
-  trampoline
+  trampoline,
+  trampolineAsync
 };

package/delay.d.ts

@@ -1,11 +0,0 @@
-import type { Fn0, IDeref } from "@thi.ng/api";
-export declare const delay: <T>(body: Fn0<T>) => Delay<T>;
-export declare class Delay<T> implements IDeref<T> {
-    protected value: T;
-    protected body: Fn0<T>;
-    protected realized: boolean;
-    constructor(body: Fn0<T>);
-    deref(): T;
-    isRealized(): boolean;
-}
-//# sourceMappingURL=delay.d.ts.map

package/delay.js

@@ -1,24 +0,0 @@
-const delay = (body) => new Delay(body);
-class Delay {
-  value;
-  body;
-  realized;
-  constructor(body) {
-    this.body = body;
-    this.realized = false;
-  }
-  deref() {
-    if (!this.realized) {
-      this.value = this.body();
-      this.realized = true;
-    }
-    return this.value;
-  }
-  isRealized() {
-    return this.realized;
-  }
-}
-export {
-  Delay,
-  delay
-};