@cgtk/std 0.0.196 → 0.0.198

package/array.d.ts

@@ -13,3 +13,8 @@ export declare const tuple: <T, N extends number>(...xs: T[] & {
     length: N;
 }) => Tuple<T, N>;
 export declare const seek: <T>(arr: ArrayLike<T>, vals: Set<T | number>, offset?: number) => number;
+export declare const unique: <T>(vals: T[], compareFn?: (a: T, b: T) => number) => {
+    indices: number[];
+    inverse: number[];
+};
+export declare const argsort: <T>(arr: T[], compareFn?: (a: T, b: T) => number) => number[];

package/array.js

@@ -20,3 +20,20 @@ export const seek = (arr, vals, offset = 0) => {
             return i;
     return -1;
 };
+const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+export const unique = (vals, compareFn = compare) => {
+    const pairs = vals.map((x, i) => [x, i]);
+    pairs.sort((a, b) => compareFn(a[0], b[0]));
+    const indices = [], inverse = Array.from({ length: pairs.length });
+    let k = -1;
+    pairs.forEach((x, i) => {
+        if (i == 0 || x[0] != pairs[i - 1][0])
+            indices.push(x[1]), k++;
+        inverse[x[1]] = k;
+    });
+    return { indices, inverse };
+};
+export const argsort = (arr, compareFn = compare) => arr
+    .map((x, i) => [x, i])
+    .sort((a, b) => compareFn(a[0], b[0]))
+    .map(x => x[1]);

package/async.d.ts

@@ -1,8 +1,7 @@
-import type { Fn, Lazy, Maybe, Dispose, MaybePromise } from "./types.js";
-export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<unknown>;
+import type { Lazy, Maybe, Dispose, MaybePromise, Promisified, AsyncDispose } from "./types.js";
+export declare const RESOLVED: Promise<void>;
+export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<void>;
 export declare const delay: (ms: number, signal?: AbortSignal) => <T>(x: T) => Promise<T>;
 export declare const probing: <T>(p: Promise<T>) => Lazy<Maybe<T>>;
-export declare const resolved: <T>(p: Promise<T>) => (f: Fn<T>) => () => void;
-export declare const promise: <T>(x: MaybePromise<T>) => Promise<any>;
-export declare const then: <T>(p: Promise<T>) => <R>(f: Fn<T, R>) => Promise<R>;
-export declare const dispose: (p: Promise<Dispose>) => () => void;
+export declare const promisify: <T>(x: MaybePromise<T>) => Promisified<T>;
+export declare const dispose: (p: Promise<Dispose>) => AsyncDispose;

package/async.js

@@ -1,5 +1,6 @@
-import { filterT, noop } from "./fn.js";
-import { isDefined } from "./checks.js";
+import { noop, then } from "./fn.js";
+import { isPromise } from "./checks.js";
+export const RESOLVED = Promise.resolve();
 export const timeout = (ms, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
         reject(signal.reason);
@@ -8,7 +9,7 @@ export const timeout = (ms, signal) => new Promise((resolve, reject) => {
             if (signal?.aborted)
                 reject(signal.reason);
             else
-                resolve(undefined);
+                resolve();
         }, ms);
         signal?.addEventListener("abort", () => (clearTimeout(t), reject(signal.reason)), { once: true });
     }
@@ -19,26 +20,10 @@ export const probing = (p) => {
     p.then(x => value = x);
     return () => value;
 };
-export const resolved = (p) => {
-    const val = probing(p);
-    return (f) => {
-        const g = (filterT((isDefined), f));
-        return () => g(val());
-    };
-};
-export const promise = (x) => (x instanceof Promise) ? x : Promise.resolve(x);
-export const then = (p) => (f) => p.then(f);
+export const promisify = (x) => (isPromise(x) ? x : Promise.resolve(x));
 export const dispose = (p) => {
-    let dispose = noop;
-    let disposed = false;
-    p.then(d => {
-        if (disposed)
-            d();
-        else
-            dispose = d;
-    });
-    return () => {
-        disposed = true;
-        dispose();
-    };
+    const { promise, resolve } = Promise.withResolvers();
+    let dispose = noop, disposed = false;
+    p.then(d => (dispose = then(d, resolve), disposed && dispose()));
+    return () => (disposed = true, dispose(), promise);
 };

package/checks.d.ts

@@ -28,3 +28,6 @@ export declare const isEmpty: (x: {
     length: number;
 }) => boolean;
 export declare const counted: (n: number) => () => boolean;
+export declare const isBitSet: (x: number, n: number) => boolean;
+export declare const isPromise: <T = any>(x: any) => x is Promise<T>;
+export declare const isPromiseLike: <T = any>(x: any) => x is PromiseLike<T>;

package/checks.js

@@ -43,3 +43,6 @@ export const counted = (n) => {
     let m = 0;
     return () => m++ < n;
 };
+export const isBitSet = (x, n) => (x & (1 << n)) !== 0;
+export const isPromise = (x) => x instanceof Promise;
+export const isPromiseLike = (x) => x instanceof Promise;

package/fn.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, FnF, Pred, TPred, Last, Lazy, Dispose, Reactive } from "./types.js";
+import type { Fn, FnV, FnF, Pred, Last, Lazy, Dispose, Reactive, Promisified, MaybePromise } from "./types.js";
 export declare const tee: <T>(f: Fn<T, void>) => Fn<T, T>;
 export declare const comp: <Fs extends Fn[]>(...fs: Fs) => (x: Fs[0] extends Fn<infer T> ? T : never) => Last<Fs> extends Fn<any, infer R> ? R : never;
 export declare const pipe: <T, Fs extends [Fn<T>, ...Fn[]]>(x: T, ...fs: Fs) => Last<Fs> extends Fn<any, infer R> ? R : never;
@@ -17,7 +17,6 @@ export declare const where: <T, U, V>(p: Pred<T>, f: Fn<T, U>, g: Fn<T, V>) => (
 export declare const before: <F extends Fn<void>>(f: F) => FnF;
 export declare const after: <F extends Fn<void>>(f: F) => FnF;
 export declare const filter: <T>(p: Pred<T>, f: Fn<T>) => (x: T) => void;
-export declare const filterT: <T>(p: TPred<T>, f: Fn<T>) => <S>(x: S) => void;
 export declare const scan: <T, S>(f: FnV<[S, T], S>, a: S) => Fn<T, S>;
 export declare const memoize: <T extends any[], K, V>(f: FnV<T, V>, key?: FnV<T, K>, cache?: Map<K, V>) => (...xs: T) => NonNullable<V>;
 export declare const abortable: <T = any>(f: Fn<AbortSignal>) => (reason?: T) => void;
@@ -27,3 +26,5 @@ export declare const idemp: <F extends FnV<any[], Dispose | void>>(d: Fn<Dispose
 export declare const toggler: (f: Fn<void, Dispose>) => Fn<boolean, Dispose>;
 export declare const voidify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => void;
 export declare const effectual: <T>(f: Reactive<T>, g: Fn<T>) => Dispose;
+export declare const promisify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => Promisified<ReturnType<F>>;
+export declare const then: <T, F extends FnV<any, MaybePromise<any>>>(f: F, g?: Fn<Awaited<ReturnType<F>>, T>) => (...xs: Parameters<F>) => Promise<T>;

package/fn.js

@@ -1,4 +1,6 @@
 import { add } from "./set.js";
+import * as Async from "./async.js";
+import { isPromise } from "./checks.js";
 export const tee = f => x => (f(x), x);
 export const comp = (...fs) => (x) => fs.reduce((x, f) => f(x), x);
 export const pipe = (x, ...fs) => fs.reduce((x, f) => f(x), x);
@@ -22,8 +24,6 @@ export const after = (f) => g => (...xs) => {
 };
 export const filter = (p, f) => (x) => { if (p(x))
     f(x); };
-export const filterT = (p, f) => (x) => { if (p(x))
-    f(x); };
 export const scan = (f, a) => (x) => a = f(a, x);
 export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs) => {
     const k = key(...xs);
@@ -56,3 +56,8 @@ export const toggler = (f) => {
 };
 export const voidify = (f) => (...xs) => { f(...xs); };
 export const effectual = (f, g) => disposable(d => d(f(idemp(d, g))));
+export const promisify = (f) => (...xs) => Async.promisify(f(...xs));
+export const then = (f, g = identity) => (...xs) => {
+    const r = f(...xs);
+    return isPromise(r) ? r.then(g) : Promise.resolve(g(r));
+};

package/iterable.d.ts

@@ -5,34 +5,22 @@ export declare const just: <T>(x: T) => IteratorObject<T>;
 export declare const enumerate: (n?: number) => <T>(x: T) => Indexed<T>;
 export declare function empty(): Generator<never, void, unknown>;
 export declare function concat<T>(...xxs: ReadonlyArray<IteratorObject<T>>): Generator<T, void, unknown>;
-export declare const toArray: <T>(xs: IteratorObject<T>) => T[];
-export declare const map: <T, U = T>(f: Fn<T, U>) => (xs: IteratorObject<T>) => IteratorObject<U, undefined, unknown>;
-export declare const filter: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => IteratorObject<T, undefined, unknown>;
-export declare const drop: (n: number) => <T>(xs: IteratorObject<T>) => IteratorObject<T, undefined, unknown>;
-export declare const flatMap: <T, U = Iterable<T>>(f: Fn<T, Iterator<U> | Iterable<U>>) => (xs: IteratorObject<T>) => IteratorObject<U, undefined, unknown>;
-export declare const forEach: <T>(f?: Fn<T>) => (xs: IteratorObject<T>) => void;
-export declare const some: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => boolean;
-export declare const every: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => boolean;
-export declare const find: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => T | undefined;
-export declare const flat: <T>(xs: IteratorObject<IteratorObject<T>>) => IteratorObject<T, undefined, unknown>;
 export declare const prepend: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export declare const append: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export declare const first: <T>(xs: IteratorObject<T>) => T | undefined;
-export declare const reduce: <T, S>(f: FnV<[S, T, number], S>, a: S) => (xs: IteratorObject<T>) => S;
 export declare const reduceRec: <T, A, R>(xs: IteratorObject<T>, f: FnV<[A, T, Fn<A>], R>, o: A, result: Fn<A, R>) => R;
-export declare const traverse: <T>(children: Fn<T, Iterable<T>>, f: Fn<T>) => Fn<T>;
-export declare const take: (n: number) => <T>(xs: IteratorObject<T>) => Generator<T>;
+export declare const take: <T>(n: number, xs: IteratorObject<T>) => Generator<T, void, unknown>;
 export declare function arange(a: number, b?: number, s?: number): Generator<number, void, unknown>;
 export declare const linspace: (a: number, b: number, n: number) => Generator<number, void, unknown>;
 export declare const steps: (a: number, b: number, s?: number, o?: number, eps?: number) => Generator<number, void, unknown>;
-export declare const strided: (n: number, s: number) => <T>(xs: Iterable<T>) => Generator<T[], void, unknown>;
+export declare const strided: <T>(n: number, s: number, xs: Iterable<T>) => Generator<T[], void, unknown>;
 export declare const stopAt: <T>(p: Pred<T>) => (xs: IteratorObject<T>) => Generator<T, void, unknown>;
 export declare const until: (p: Pred<void>) => <A>(xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export type Iterators<T extends any[]> = {
     [k in keyof T]: IteratorObject<T[k]>;
 };
 export declare function zip<T extends unknown[]>(...xs: Iterators<T>): Generator<T>;
-export declare const iterA: <T>(xs: Promise<T>[]) => AsyncGenerator<Awaited<T>, void, unknown>;
+export declare const iterA: <T>(xs: Iterable<Promise<T>>) => AsyncGenerator<Awaited<T>, void, unknown>;
 export declare const forEachA: <T>(f?: Fn<T>) => (xs: AsyncIterable<T>) => Promise<void>;
 export declare const mapA: <A, B>(f: Fn<A, B>) => Fn<AsyncIterator<A>, AsyncIterableIterator<B>>;
 export declare const flatMapA: <A, B>(f: Fn<A, Iterable<B>>) => (xs: AsyncIterator<A>) => AsyncGenerator<Awaited<B>, void, any>;

package/iterable.js

@@ -1,5 +1,5 @@
 import { assert, isDefined } from "./checks.js";
-import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn.js";
+import { scan, apply, noop, constantly } from "./fn.js";
 import { set } from "./map.js";
 export const next = (xs) => {
     const { done, value } = xs.next();
@@ -15,20 +15,9 @@ export function* empty() { }
 export function* concat(...xxs) { for (const xs of xxs)
     yield* xs; }
 ;
-export const toArray = (xs) => xs.toArray();
-export const map = (f) => (xs) => xs.map(f);
-export const filter = (f) => (xs) => xs.filter(f);
-export const drop = (n) => (xs) => xs.drop(n);
-export const flatMap = (f) => (xs) => xs.flatMap(f);
-export const forEach = (f = noop) => (xs) => xs.forEach(f);
-export const some = (f) => (xs) => xs.some(f);
-export const every = (f) => (xs) => xs.every(f);
-export const find = (f) => (xs) => xs.find(f);
-export const flat = (xs) => xs.flatMap(identity);
 export const prepend = (ys) => (xs) => concat(ys, xs);
 export const append = (ys) => (xs) => concat(xs, ys);
 export const first = (xs) => xs.find(constantly(true));
-export const reduce = (f, a) => (xs) => xs.reduce(f, a);
 export const reduceRec = (xs, f, o, result) => {
     const next = (o) => {
         const { done, value } = xs.next();
@@ -39,8 +28,7 @@ export const reduceRec = (xs, f, o, result) => {
     };
     return next(o);
 };
-export const traverse = (children, f) => (x) => (f(x), forEach(traverse(children, f))(Iterator.from(children(x))));
-export const take = n => function* (xs) {
+export const take = function* (n, xs) {
     for (let i = 0; i < n; i++) {
         const { done, value } = xs.next();
         if (done)
@@ -60,7 +48,7 @@ export const steps = (a, b, s = 1, o = 0, eps = 1e-8) => {
     const end = Math.floor((b - o) / s) * s + o;
     return arange(start, end + s - eps, s);
 };
-export const strided = (n, s) => function* (xs) {
+export const strided = function* (n, s, xs) {
     const cur = [];
     for (const x of xs) {
         cur.push(x);
@@ -144,15 +132,14 @@ export const reduceA = (f, a) => async (xs) => {
     return a;
 };
 export const race = (n) => async function* (xs) {
-    const it = pipe(xs, map(enumerate()), map(([i, x]) => [i, x.then(y => [i, y])]));
-    const accum = reduce((set), new Map());
-    const tasks = pipe(it, (take(n)), accum);
-    const next = comp((take(1)), accum);
+    const it = xs.map((x, i) => [i, x.then(y => [i, y])]);
+    const acc = new Map();
+    const tasks = take(n, it).reduce(set, acc);
     while (tasks.size > 0) {
         const [i, x] = await Promise.race(tasks.values());
         tasks.delete(i);
         yield x;
-        next(it);
+        take(1, it).reduce(set, acc);
     }
 };
-export const zmap = (f) => (...xs) => forEach(apply(f))(zip(...xs));
+export const zmap = (f) => (...xs) => zip(...xs).forEach(apply(f));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.196",
+  "version": "0.0.198",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -37,7 +37,7 @@
     "./npy": "./npy.js",
     "./port": "./port.js",
     "./rect": "./rect.js",
-    "./resource": "./resource.js",
+    "./scope": "./scope.js",
     "./utils": "./utils.js"
   },
   "publishConfig": {

package/port.d.ts

@@ -1,4 +1,4 @@
-import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive } from "./types.js";
+import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive, AsyncDispose } from "./types.js";
 export interface Message<K, V> {
     type: K;
     payload: V;
@@ -25,6 +25,6 @@ interface TransferableFnV<T extends any[], R> {
 }
 export declare const client: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: TransferableFnV<Parameters<S[k]>, Promise<ReturnType<S[k]>>>; };
 export declare const server: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: Fn<FnV<Parameters<S[k]>, MaybePromise<ReturnType<S[k]>>>, Dispose>; };
-export declare const startClient: (worker: Worker, f: Fn<Worker, Dispose | void>) => Promise<Dispose>;
+export declare const startClient: (worker: Worker, f: Fn<Worker, Dispose | void>) => Promise<AsyncDispose>;
 export declare const startServer: (worker: Worker, f: Fn<Worker, MaybePromise<Dispose>>) => Promise<Dispose>;
 export {};

package/port.js

@@ -1,7 +1,7 @@
-import { forEach, noop, bind } from "./fn.js";
+import { noop, bind, then } from "./fn.js";
 import { isDefined } from "./checks.js";
 import { on } from "./dom.js";
-import { promise } from "./async.js";
+import { promisify } from "./async.js";
 ;
 export const onMessages = (target, fs) => on(target, "message", ({ data: { type, payload } }) => (type in fs) && fs[type](payload));
 export const onMessage = (target, name, f) => on(target, "message", ({ data: { type, payload } }) => type == name && f(payload));
@@ -39,18 +39,18 @@ export const server = (target) => {
     onMessage(target, "rpc", async ({ id, name, args }) => {
         const f = fns.get(name);
         if (isDefined(f))
-            rpc({ id, result: await promise(f(...args)) });
+            rpc({ id, result: await promisify(f(...args)) });
     });
     return new Proxy({}, {
         get: (_, k) => (f) => (fns.set(k, f), () => fns.delete(k))
     });
 };
 export const startClient = async (worker, f) => {
-    const cli = client(worker);
-    await cli.start();
-    return forEach(f(worker) ?? noop, () => cli.stop().then(() => worker.terminate()));
+    const { start, stop } = client(worker);
+    await start();
+    return then(stop, f(worker) ?? noop);
 };
 export const startServer = async (worker, f) => {
-    const ser = server(worker);
-    return ser.start(async () => { ser.stop(await promise(f(worker))); });
+    const { start, stop } = server(worker);
+    return start(async () => { stop(await promisify(f(worker))); });
 };

package/scope.d.ts

@@ -0,0 +1,19 @@
+import type { Fn, FnV, Dispose, AsyncDispose, MaybePromise, Structure } from "./types.js";
+type Result = Dispose | AsyncDispose | void;
+export type Scope<T> = Dispose & {
+    value: T;
+    dispose: Dispose;
+    map<S>(f: Fn<T, S>): Scope<S>;
+    use(f: Fn<T, MaybePromise<Result>>): Scope<T>;
+};
+export declare const scope: <T>(value: T, dispose?: Dispose) => Scope<T>;
+type Unwrapped<T> = T extends Scope<infer U> ? U : {
+    [K in keyof T]: Unwrapped<T[K]>;
+};
+export declare const compose: <R extends Structure<Scope<any>>>(rs: R) => Scope<Unwrapped<R>>;
+export declare const of: <T>(x: T, f: Fn<T, Dispose>) => Scope<T>;
+type Use = <T>(r: Scope<T>) => T;
+export declare const gen: <R>(f: FnV<[Use, Fn<Dispose, Dispose>], R>) => Scope<R>;
+export declare const consume: (f: Fn<Use, Dispose | void>) => Dispose;
+export declare const worker: (w: Worker) => Scope<Worker>;
+export {};

package/scope.js

@@ -0,0 +1,41 @@
+import * as F from "./fn.js";
+import * as Async from "./async.js";
+import { isPromise, isFunction } from "./checks.js";
+import { add } from "./set.js";
+export const scope = (value, dispose = F.noop) => {
+    const s = (() => dispose());
+    s.value = value;
+    s.dispose = dispose;
+    s.map = f => scope(f(value), dispose);
+    s.use = f => {
+        const r = f(value);
+        const d = isPromise(r) ?
+            Async.dispose(r.then(d => F.then(d ?? F.noop, dispose))) :
+            F.then(r ?? F.noop, dispose);
+        return scope(value, d);
+    };
+    return s;
+};
+const iLeaf = (r) => Object.hasOwn(r, "value") && Object.hasOwn(r, "dispose") && isFunction(r["dispose"]);
+export const compose = (rs) => {
+    const disposes = [];
+    const rec = (rs) => {
+        if (iLeaf(rs)) {
+            disposes.push(rs.dispose);
+            return rs.value;
+        }
+        else if (Array.isArray(rs)) {
+            return rs.map(rec);
+        }
+        return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
+    };
+    const value = rec(rs);
+    return scope(value, F.forEach(...disposes));
+};
+export const of = (x, f) => scope(x, f(x));
+export const gen = (f) => {
+    const res = new Set();
+    return scope(f(r => (res.add(r.dispose), r.value), F.bind(add, res)), () => res.forEach(f => f()));
+};
+export const consume = (f) => F.disposable(use => use(f(r => (use(r.dispose), r.value)) ?? F.noop));
+export const worker = (w) => of(w, x => x.terminate.bind(x));

package/typedarray.d.ts

@@ -24,7 +24,7 @@ export declare const ctor: <T extends TypedArray>(x: T) => Constructor<T>;
 export declare const emptyLike: <T extends TypedArray>(x: T) => T;
 export declare const set: <T extends TypedArray>(xs: T, x: ArrayLike<Number<T>> | T, i: number) => T;
 export declare const concat: <T extends TypedArray>(chunks: T[]) => T;
-export declare const iter: (size: number, stride?: number) => <T extends TypedArray>(data: T) => Generator<T>;
+export declare const iter: <T extends TypedArray>(data: T, size: number, stride?: number) => Generator<T>;
 export declare const tile: (n: number) => (out: TypedArray, x: TypedArray) => TypedArray;
 export declare const tileEvery: (m: number, n: number) => <T extends TypedArray>(xs: T, out?: T) => T;
 export declare const strided: <T extends TypedArray>(data: T, size: number, stride?: number, out?: T) => T;

package/typedarray.js

@@ -1,5 +1,5 @@
 import { bind } from "./fn.js";
-import { zmap, map as mapI, reduce } from "./iterable.js";
+import { zmap } from "./iterable.js";
 import { push } from "./array.js";
 export const view = (type, length) => (buf = new ArrayBuffer(type.BYTES_PER_ELEMENT * length), offset = 0) => new type(buf, offset, length);
 export const u8 = bind((view), Uint8Array);
@@ -22,7 +22,7 @@ export const concat = (chunks) => {
     chunks.reduce((offset, chunk) => (out.set(chunk, offset), offset + chunk.length), 0);
     return out;
 };
-export const iter = (size, stride = size) => function* (data) {
+export const iter = function* (data, size, stride = size) {
     const C = ctor(data);
     for (let i = 0, n = data.length; i < n - size + 1; i += stride) {
         const offset = data.byteOffset + i * C.BYTES_PER_ELEMENT;
@@ -34,6 +34,6 @@ export const tile = (n) => (out, x) => {
         set(out, x, i * x.length);
     return out;
 };
-export const tileEvery = (m, n) => (xs, out = new (ctor(xs))(xs.length * n)) => (zmap(tile(n))(iter(m * n)(out), iter(m)(xs)), out);
-export const strided = (data, size, stride = size, out = new (ctor(data))(data.length / size * stride)) => (iter(size)(data).forEach((p, i) => set(out, p, i * stride)), out);
-export const toFixed = (n, sep = ',') => (xs) => reduce((push), [])(mapI(x => x.toFixed(n))(Iterator.from(xs))).join(sep);
+export const tileEvery = (m, n) => (xs, out = new (ctor(xs))(xs.length * n)) => (zmap(tile(n))(iter(out, m * n), iter(xs, m)), out);
+export const strided = (data, size, stride = size, out = new (ctor(data))(data.length / size * stride)) => (iter(data, size).forEach((p, i) => set(out, p, i * stride)), out);
+export const toFixed = (n, sep = ',') => (xs) => Iterator.from(xs).map(x => x.toFixed(n)).reduce((push), []).join(sep);

package/types.d.ts

@@ -14,9 +14,11 @@ export type Fns<T> = {
 };
 export type FnF = <F extends FnV>(f: F) => (...xs: Parameters<F>) => ReturnType<F>;
 export type Dispose = Fn<void>;
+export type AsyncDispose = Fn<void, Promise<void>>;
 export type Reactive<T = unknown, R = any> = Fn<Fn<T, R>, Dispose>;
 export type Lazy<T> = () => T;
-export type MaybePromise<T = unknown> = T | PromiseLike<T>;
+export type MaybePromise<T = unknown> = T | Promise<T>;
+export type Promisified<T> = T extends Promise<any> ? T : Promise<T>;
 export type Last<T extends any[]> = T extends [...any, infer Rest] ? Rest : never;
 export type Tail<T extends any[]> = T extends [any, ...(infer Rest)] ? Rest : never;
 export type Push<T extends any[], V> = [...T, V];

package/resource.d.ts

@@ -1,19 +0,0 @@
-import type { Fn, FnV, Dispose, Structure, Reactive, RecordOf } from "./types.js";
-export type Resource<T> = Reactive<T, Dispose | void> & {
-    value: T;
-    dispose: Dispose;
-    map<S>(f: Fn<T, S>): Resource<S>;
-    flatMap<S>(f: Fn<T, Resource<S>>): Resource<S>;
-    promise(f: Fn<T, Promise<Dispose | void>>): Promise<Dispose>;
-};
-export declare const resource: <T>(value: T, dispose?: Dispose) => Resource<T>;
-export declare const awaited: <T>({ value, dispose }: Resource<Promise<T>>) => Promise<Resource<Awaited<T>>>;
-type Unwrapped<T> = T extends Resource<infer U> ? U : {
-    [K in keyof T]: Unwrapped<T[K]>;
-};
-export declare const compose: <R extends Structure<Resource<any>>>(rs: R) => Resource<Unwrapped<R>>;
-export declare const of: <T>(x: T, f: Fn<T, Dispose>) => Resource<T>;
-export declare const gen: <R>(f: FnV<[<T>(r: Resource<T>) => T, Fn<Dispose, Dispose>], R>) => Resource<R>;
-export declare const consume: (f: Fn<(<T>(r: Resource<T>) => T), Dispose | void>) => Dispose;
-export declare const swapping: <F extends RecordOf<FnV<any, Dispose | void>>>(fs: F) => Resource<{ [K in import("./types.js").Entry<keyof F, FnV<Parameters<import("./types.js").ValueOf<F>>, Dispose>> as K[0]]: K[1]; }>;
-export {};

package/resource.js

@@ -1,46 +0,0 @@
-import * as F from "./fn.js";
-import { isFunction } from "./checks.js";
-import { add } from "./set.js";
-import { mapValues } from "./object.js";
-export const resource = (value, dispose = F.noop) => {
-    const res = ((f) => F.forEach(f(value) ?? F.noop, dispose));
-    res.value = value;
-    res.dispose = dispose;
-    res.map = (f) => resource(f(value), dispose);
-    res.flatMap = (f) => {
-        const res = f(value);
-        return resource(res.value, F.forEach(res.dispose, dispose));
-    };
-    res.promise = async (f) => F.forEach((await f(value)) ?? F.noop, dispose);
-    return res;
-};
-export const awaited = async ({ value, dispose }) => resource(await value, dispose);
-const isResource = (r) => isFunction(r) &&
-    Object.hasOwn(r, "value") &&
-    Object.hasOwn(r, "dispose") &&
-    isFunction(r["dispose"]);
-export const compose = (rs) => {
-    const disposes = [];
-    const rec = (rs) => {
-        if (isResource(rs)) {
-            disposes.push(rs.dispose);
-            return rs.value;
-        }
-        else if (Array.isArray(rs)) {
-            return rs.map(rec);
-        }
-        return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
-    };
-    const value = rec(rs);
-    return resource(value, F.forEach(...disposes));
-};
-export const of = (x, f) => resource(x, f(x));
-export const gen = (f) => {
-    const res = new Set();
-    return resource(f((r) => (res.add(r.dispose), r.value), F.bind(add, res)), () => res.forEach((f) => f()));
-};
-export const consume = (f) => F.disposable((use) => use(f((r) => (use(r.dispose), r.value)) ?? F.noop));
-export const swapping = (fs) => {
-    const swap = F.swapping();
-    return resource(mapValues(fs, swap), swap(F.noop));
-};