@thi.ng/pointfree 3.1.54 → 3.1.55

package/loop.js

@@ -1,86 +1,37 @@
 import { $ } from "./safe.js";
 import { $stackFn } from "./word.js";
-//////////////////// Loop constructs  ////////////////////
-/**
- * Higher order word. Takes a `test` and `body` stack program. Applies
- * test to copy of TOS and executes body. Repeats while test is truthy.
- *
- * ( -- ? )
- *
- * @example
- * ```ts
- * run([loop([dup, ispos], [dup, print, dec])], [[3]])
- * // 3
- * // 2
- * // 1
- * // [ true, [ 0 ], undefined ]
- * ```
- * @param test -
- * @param body -
- */
-export const defLoop = (test, body) => {
-    const _test = $stackFn(test);
-    const _body = $stackFn(body);
-    return (ctx) => {
-        while (true) {
-            ctx = _test(ctx);
-            $(ctx[0], 1);
-            if (!ctx[0].pop()) {
-                return ctx;
-            }
-            ctx = _body(ctx);
-        }
-    };
+const defLoop = (test, body) => {
+  const _test = $stackFn(test);
+  const _body = $stackFn(body);
+  return (ctx) => {
+    while (true) {
+      ctx = _test(ctx);
+      $(ctx[0], 1);
+      if (!ctx[0].pop()) {
+        return ctx;
+      }
+      ctx = _body(ctx);
+    }
+  };
 };
-/**
- * Non-HOF version of {@link loop}. Expects test result and body quotation /
- * word on d-stack.
- *
- * ( testq bodyq -- ? )
- *
- * @param ctx -
- */
-export const loopq = (ctx) => {
-    const stack = ctx[0];
-    $(stack, 2);
-    const body = stack.pop();
-    return defLoop(stack.pop(), body)(ctx);
+const loopq = (ctx) => {
+  const stack = ctx[0];
+  $(stack, 2);
+  const body = stack.pop();
+  return defLoop(stack.pop(), body)(ctx);
 };
-/**
- * Executes given `body` word/quotation `n` times. In each iteration
- * pushes current counter on d-stack prior to executing body.
- *
- * @example
- * ```ts
- * pf.run([3, ["i=", pf.swap, pf.add, pf.print], pf.dotimes])
- * // i=0
- * // i=1
- * // i=2
- * ```
- *
- * With empty body acts as finite range generator 0 .. n:
- *
- * ```
- * // range gen
- * pf.run([3, [], pf.dotimes])
- * [ [ 0, 1, 2 ], [], {} ]
- *
- * // range gen (collect results as array)
- * pf.runU([3, pf.cpdr, [], pf.dotimes, pf.movrd, pf.collect])
- * // [ 0, 1, 2 ]
- * ```
- *
- * ( n body -- ? )
- *
- * @param body -
- */
-export const dotimes = (ctx) => {
-    let stack = ctx[0];
-    $(stack, 2);
-    const w = $stackFn(stack.pop());
-    for (let i = 0, n = stack.pop(); i < n; i++) {
-        ctx[0].push(i);
-        ctx = w(ctx);
-    }
-    return ctx;
+const dotimes = (ctx) => {
+  let stack = ctx[0];
+  $(stack, 2);
+  const w = $stackFn(stack.pop());
+  for (let i = 0, n = stack.pop(); i < n; i++) {
+    ctx[0].push(i);
+    ctx = w(ctx);
+  }
+  return ctx;
+};
+export {
+  defLoop,
+  dotimes,
+  loopq
 };

package/math.js

@@ -1,148 +1,53 @@
 import { defOp1, defOp2 } from "./ops.js";
 import { swap } from "./stack.js";
 import { defWord } from "./word.js";
-//////////////////// Math ops ////////////////////
-/**
- * ( x y -- x+y )
- *
- * @param ctx -
- */
-export const add = defOp2((b, a) => a + b);
-/**
- * ( x y -- x*y )
- *
- * @param ctx -
- */
-export const mul = defOp2((b, a) => a * b);
-/**
- * ( x y -- x-y )
- *
- * @param ctx -
- */
-export const sub = defOp2((b, a) => a - b);
-/**
- * ( x y -- x/y )
- *
- * @param ctx -
- */
-export const div = defOp2((b, a) => a / b);
-/**
- * ( x -- 1/x )
- *
- * @param ctx -
- */
-export const oneover = defWord([1, swap, div]);
-/**
- * ( x y -- x%y )
- *
- * @param ctx -
- */
-export const mod = defOp2((b, a) => a % b);
-/**
- * ( x y -- min(x,y) )
- *
- * @param ctx -
- */
-export const min = defOp2(Math.min);
-/**
- * ( x y -- max(x,y) )
- *
- * @param ctx -
- */
-export const max = defOp2(Math.max);
-/**
- * ( x -- -x )
- *
- * @param ctx -
- */
-export const neg = defOp1((x) => -x);
-/**
- * ( x y -- pow(x,y) )
- *
- * @param ctx -
- */
-export const pow = defOp2((b, a) => Math.pow(a, b));
-/**
- * ( x -- sqrt(x) )
- *
- * @param ctx -
- */
-export const sqrt = defOp1(Math.sqrt);
-/**
- * ( x -- exp(x) )
- *
- * @param ctx -
- */
-export const exp = defOp1(Math.exp);
-/**
- * ( x -- log(x) )
- *
- * @param ctx -
- */
-export const log = defOp1(Math.log);
-/**
- * ( x -- sin(x) )
- *
- * @param ctx -
- */
-export const sin = defOp1(Math.sin);
-/**
- * ( x -- cos(x) )
- *
- * @param ctx -
- */
-export const cos = defOp1(Math.cos);
-/**
- * ( x -- tan(x) )
- *
- * @param ctx -
- */
-export const tan = defOp1(Math.tan);
-/**
- * ( x -- tanh(x) )
- *
- * @param ctx -
- */
-export const tanh = defOp1(Math.tanh);
-/**
- * ( x -- floor(x) )
- *
- * @param ctx -
- */
-export const floor = defOp1(Math.floor);
-/**
- * ( x -- ceil(x) )
- *
- * @param ctx -
- */
-export const ceil = defOp1(Math.ceil);
-/**
- * ( x y -- sqrt(x*x+y*y) )
- *
- * @param ctx -
- */
-export const hypot = defOp2(Math.hypot);
-/**
- * ( x y -- atan2(y,x) )
- *
- * @param ctx -
- */
-export const atan2 = defOp2(Math.atan2);
-/**
- * ( -- Math.random() )
- *
- * @param ctx -
- */
-export const rand = (ctx) => (ctx[0].push(Math.random()), ctx);
-/**
- * ( x -- bool )
- *
- * @param ctx -
- */
-export const even = defOp1((x) => !(x & 1));
-/**
- * ( x -- bool )
- *
- * @param ctx -
- */
-export const odd = defOp1((x) => !!(x & 1));
+const add = defOp2((b, a) => a + b);
+const mul = defOp2((b, a) => a * b);
+const sub = defOp2((b, a) => a - b);
+const div = defOp2((b, a) => a / b);
+const oneover = defWord([1, swap, div]);
+const mod = defOp2((b, a) => a % b);
+const min = defOp2(Math.min);
+const max = defOp2(Math.max);
+const neg = defOp1((x) => -x);
+const pow = defOp2((b, a) => Math.pow(a, b));
+const sqrt = defOp1(Math.sqrt);
+const exp = defOp1(Math.exp);
+const log = defOp1(Math.log);
+const sin = defOp1(Math.sin);
+const cos = defOp1(Math.cos);
+const tan = defOp1(Math.tan);
+const tanh = defOp1(Math.tanh);
+const floor = defOp1(Math.floor);
+const ceil = defOp1(Math.ceil);
+const hypot = defOp2(Math.hypot);
+const atan2 = defOp2(Math.atan2);
+const rand = (ctx) => (ctx[0].push(Math.random()), ctx);
+const even = defOp1((x) => !(x & 1));
+const odd = defOp1((x) => !!(x & 1));
+export {
+  add,
+  atan2,
+  ceil,
+  cos,
+  div,
+  even,
+  exp,
+  floor,
+  hypot,
+  log,
+  max,
+  min,
+  mod,
+  mul,
+  neg,
+  odd,
+  oneover,
+  pow,
+  rand,
+  sin,
+  sqrt,
+  sub,
+  tan,
+  tanh
+};

package/ops.js

@@ -1,85 +1,56 @@
 import { isArray } from "@thi.ng/checks/is-array";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { $, $n } from "./safe.js";
-//////////////////// Operator generators ////////////////////
-/**
- * Higher order word. Replaces TOS of d-stack with result of given op.
- *
- * ( x -- y )
- *
- * @param op -
- */
-export const defOp1 = (op) => {
-    return (ctx) => {
-        const stack = ctx[0];
-        const n = stack.length - 1;
-        $n(n, 0);
-        stack[n] = op(stack[n]);
-        return ctx;
-    };
-};
-/**
- * Higher order word. Takes 2 values from d-stack and writes back result
- * from given op. The arg order is (TOS, TOS-1)
- *
- * ( a b -- c )
- *
- * @param op -
- */
-export const defOp2 = (op) => (ctx) => {
+const defOp1 = (op) => {
+  return (ctx) => {
     const stack = ctx[0];
-    const n = stack.length - 2;
+    const n = stack.length - 1;
     $n(n, 0);
-    stack[n] = op(stack.pop(), stack[n]);
+    stack[n] = op(stack[n]);
     return ctx;
+  };
 };
-/**
- * Similar to {@link map2}, but for array operators. Either `a` or `b` can be a
- * non-array value, but not both. Creates new array of result values.
- * The result will have the same length as the shortest arg (if `a` and
- * `b` have different lengths).
- *
- * - ( a b -- a ), if `a` is an array
- * - ( a b -- b ), if `a` is not an array
- *
- * @param f -
- */
-export const defOp2v = (f) => (ctx) => {
-    $(ctx[0], 2);
-    const stack = ctx[0];
-    const b = stack.pop();
-    const n = stack.length - 1;
-    const a = stack[n];
-    const isa = isArray(a);
-    const isb = isArray(b);
-    stack[n] =
-        isa && isb
-            ? op2vAB(f, a, b)
-            : isb && !isa
-                ? op2vB(f, a, b)
-                : isa && !isb
-                    ? op2vA(f, a, b)
-                    : illegalArgs("at least one arg must be an array");
-    return ctx;
+const defOp2 = (op) => (ctx) => {
+  const stack = ctx[0];
+  const n = stack.length - 2;
+  $n(n, 0);
+  stack[n] = op(stack.pop(), stack[n]);
+  return ctx;
+};
+const defOp2v = (f) => (ctx) => {
+  $(ctx[0], 2);
+  const stack = ctx[0];
+  const b = stack.pop();
+  const n = stack.length - 1;
+  const a = stack[n];
+  const isa = isArray(a);
+  const isb = isArray(b);
+  stack[n] = isa && isb ? op2vAB(f, a, b) : isb && !isa ? op2vB(f, a, b) : isa && !isb ? op2vA(f, a, b) : illegalArgs("at least one arg must be an array");
+  return ctx;
 };
 const op2vAB = (f, a, b) => {
-    const res = new Array(Math.min(a.length, b.length));
-    for (let i = res.length - 1; i >= 0; i--) {
-        res[i] = f(b[i], a[i]);
-    }
-    return res;
+  const res = new Array(Math.min(a.length, b.length));
+  for (let i = res.length - 1; i >= 0; i--) {
+    res[i] = f(b[i], a[i]);
+  }
+  return res;
 };
 const op2vA = (f, a, b) => {
-    const res = new Array(a.length);
-    for (let i = res.length - 1; i >= 0; i--) {
-        res[i] = f(b, a[i]);
-    }
-    return res;
+  const res = new Array(a.length);
+  for (let i = res.length - 1; i >= 0; i--) {
+    res[i] = f(b, a[i]);
+  }
+  return res;
 };
 const op2vB = (f, a, b) => {
-    const res = new Array(b.length);
-    for (let i = res.length - 1; i >= 0; i--) {
-        res[i] = f(b[i], a);
-    }
-    return res;
+  const res = new Array(b.length);
+  for (let i = res.length - 1; i >= 0; i--) {
+    res[i] = f(b[i], a);
+  }
+  return res;
+};
+export {
+  defOp1,
+  defOp2,
+  defOp2v
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/pointfree",
-  "version": "3.1.54",
+  "version": "3.1.55",
   "description": "Pointfree functional composition / Forth style stack execution engine",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,14 +35,15 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/compose": "^2.1.50",
-    "@thi.ng/equiv": "^2.1.36",
-    "@thi.ng/errors": "^2.4.5"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/compose": "^2.1.51",
+    "@thi.ng/equiv": "^2.1.37",
+    "@thi.ng/errors": "^2.4.6"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -130,5 +133,5 @@
   "thi.ng": {
     "year": 2015
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/run.js

@@ -1,42 +1,23 @@
 import { isArray } from "@thi.ng/checks/is-array";
 import { isFunction } from "@thi.ng/checks/is-function";
 import { unwrap } from "./word.js";
-/**
- * Executes program / quotation with given stack context (initial D/R
- * stacks and optional environment). Returns updated context.
- *
- * @param prog -
- * @param ctx -
- */
-export const run = (prog, ctx = [[], [], {}]) => {
-    if (isFunction(prog)) {
-        return prog(ctx);
+const run = (prog, ctx = [[], [], {}]) => {
+  if (isFunction(prog)) {
+    return prog(ctx);
+  }
+  for (let p = isArray(prog) ? prog : [prog], n = p.length, i = 0, w; i < n; i++) {
+    if (isFunction(w = p[i])) {
+      ctx = w(ctx);
+    } else {
+      ctx[0].push(w);
     }
-    for (let p = isArray(prog) ? prog : [prog], n = p.length, i = 0, w; i < n; i++) {
-        if (isFunction((w = p[i]))) {
-            ctx = w(ctx);
-        }
-        else {
-            ctx[0].push(w);
-        }
-    }
-    return ctx;
+  }
+  return ctx;
+};
+const runU = (prog, ctx, n = 1) => unwrap(run(prog, ctx), n);
+const runE = (prog, ctx) => run(prog, ctx)[2];
+export {
+  run,
+  runE,
+  runU
 };
-/**
- * Like {@link run}, but returns unwrapped result. Syntax sugar for:
- * `unwrap(run(...),n)`
- *
- * @param prog -
- * @param ctx -
- * @param n -
- */
-export const runU = (prog, ctx, n = 1) => unwrap(run(prog, ctx), n);
-/**
- * Like {@link run}, but returns result environment. Syntax sugar for:
- * `run(...)[2]`
- *
- * @param prog -
- * @param ctx -
- * @param n -
- */
-export const runE = (prog, ctx) => run(prog, ctx)[2];

package/safe.js

@@ -1,15 +1,18 @@
 import { NO_OP } from "@thi.ng/api/api";
 import { illegalState } from "@thi.ng/errors/illegal-state";
-// ensure stack size
-export let $;
-export let $n;
-export const safeMode = (state) => {
-    if (state) {
-        $n = (m, n) => m < n && illegalState(`stack underflow`);
-        $ = (stack, n) => $n(stack.length, n);
-    }
-    else {
-        $ = $n = NO_OP;
-    }
+let $;
+let $n;
+const safeMode = (state) => {
+  if (state) {
+    $n = (m, n) => m < n && illegalState(`stack underflow`);
+    $ = (stack, n) => $n(stack.length, n);
+  } else {
+    $ = $n = NO_OP;
+  }
 };
 safeMode(true);
+export {
+  $,
+  $n,
+  safeMode
+};