@cgtk/std 0.0.197 → 0.0.199

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/iterable.d.ts

@@ -5,24 +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 map: <T, U = T>(f: Fn<T, U>) => (xs: IteratorObject<T>) => IteratorObject<U, 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 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 { bind, pipe, comp, scan, apply, noop, 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,11 +15,9 @@ export function* empty() { }
 export function* concat(...xxs) { for (const xs of xxs)
     yield* xs; }
 ;
-export const map = (f) => (xs) => xs.map(f);
 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();
@@ -50,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);
@@ -134,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, bind((take), n), accum);
-    const next = comp(bind((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) => zip(...xs).forEach(apply(f));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.197",
+  "version": "0.0.199",
   "type": "module",
   "main": "./index.js",
   "exports": {

package/scope.d.ts

@@ -14,6 +14,5 @@ export declare const compose: <R extends Structure<Scope<any>>>(rs: R) => Scope<
 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

@@ -29,13 +29,11 @@ export const compose = (rs) => {
         }
         return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
     };
-    const value = rec(rs);
-    return scope(value, F.forEach(...disposes));
+    return scope(rec(rs), 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/string.d.ts

@@ -7,3 +7,4 @@ export declare const decode: (label?: string, opts?: TextDecoderOptions) => (x:
 export declare const readLine: (delims?: Set<number>) => (data: Uint8Array, offset?: number) => string;
 export declare const DATA_URL: RegExp;
 export declare const came2kebab: (s: string) => string;
+export declare const join: (sep: string, ...xs: Array<string | undefined>) => string;

package/string.js

@@ -1,5 +1,6 @@
 import { EMPTY } from "./constants.js";
 import { seek } from "./array.js";
+import { isDefined } from "./checks.js";
 export const basename = (path) => path.split("/").at(-1) ?? "";
 export const dirname = (path) => {
     const parts = path.split("/");
@@ -28,3 +29,4 @@ export const readLine = (delims = new Set([0x0A])) => {
 };
 export const DATA_URL = /^data:(?<mime>[\w/\-\+]+)?(;(?<params>[\w\-]+\=[^;,\s]+)*)?(;(?<encoding>base64))?,(?<data>.*)$/;
 export const came2kebab = (s) => s.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+export const join = (sep, ...xs) => xs.filter(isDefined).join(sep);

package/treemap.js

@@ -1,6 +1,5 @@
 import { before } from "./fn.js";
 import { isDefined } from "./checks.js";
-import { EMPTY } from "./constants.js";
 export const treemap = () => {
     const nodes = new Set();
     const parents = new Map();
@@ -10,20 +9,17 @@ export const treemap = () => {
         const hasChanged = changed;
         if (hasChanged) {
             children.clear();
-            for (const k of nodes) {
+            nodes.forEach(k => {
                 const p = parents.get(k);
-                if (isDefined(p)) {
-                    if (!children.has(p))
-                        children.set(p, []);
-                    children.get(p).push(k);
-                }
-            }
+                if (isDefined(p))
+                    children.getOrInsert(p, []).push(k);
+            });
             changed = false;
         }
         return hasChanged;
     };
     const updated = before(update);
-    const getChildren = updated((key) => children.get(key) ?? EMPTY.LIST);
+    const getChildren = updated((key) => children.getOrInsert(key, []));
     const parent = updated((key) => parents.get(key));
     const roots = () => nodes.values().filter(k => !parents.has(k));
     return {

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);