@thi.ng/pointfree 3.1.54 → 3.1.55

package/cond.js

@@ -2,82 +2,46 @@ import { illegalState } from "@thi.ng/errors/illegal-state";
 import { $ } from "./safe.js";
 import { nop } from "./stack.js";
 import { $stackFn } from "./word.js";
-//////////////////// Conditionals  ////////////////////
-/**
- * Higher order word. Takes two stack programs: truthy and falsey
- * branches, respectively. When executed, pops TOS and runs only one of
- * the branches depending if TOS was truthy or not.
- *
- * Note: Unlike JS `if() {...} else {...}` constructs, the actual
- * conditional is NOT part of this word.
- *
- * ( bool -- ? )
- *
- * @param _then -
- * @param _else -
- */
-export const defCond = (_then, _else = nop) => (ctx) => {
-    $(ctx[0], 1);
-    return $stackFn(ctx[0].pop() ? _then : _else)(ctx);
+const defCond = (_then, _else = nop) => (ctx) => {
+  $(ctx[0], 1);
+  return $stackFn(ctx[0].pop() ? _then : _else)(ctx);
 };
-/**
- * Non-HOF version of {@link cond}, expects `test` result and both branches on
- * d-stack. Executes `thenq` word/quotation if `test` is truthy, else
- * runs `elseq`.
- *
- * ( test thenq elseq -- ? )
- *
- * @param ctx -
- */
-export const condq = (ctx) => {
-    const stack = ctx[0];
-    $(stack, 3);
-    const _else = stack.pop();
-    const _then = stack.pop();
-    return $stackFn(stack.pop() ? _then : _else)(ctx);
+const condq = (ctx) => {
+  const stack = ctx[0];
+  $(stack, 3);
+  const _else = stack.pop();
+  const _then = stack.pop();
+  return $stackFn(stack.pop() ? _then : _else)(ctx);
 };
-/**
- * Similar to {@link condq}, but only expects `test` result and truthy branch
- * d-stack. Executes word/quotation if `test` is truthy, else does nothing.
- *
- * ( test whenq -- ? )
- *
- * @param ctx -
- */
-export const whenq = (ctx) => {
-    const stack = ctx[0];
-    $(stack, 2);
-    const _then = stack.pop();
-    return stack.pop() ? $stackFn(_then)(ctx) : ctx;
+const whenq = (ctx) => {
+  const stack = ctx[0];
+  $(stack, 2);
+  const _then = stack.pop();
+  return stack.pop() ? $stackFn(_then)(ctx) : ctx;
 };
-/**
- * Higher order word. Takes an object of stack programs with keys in the
- * object being used to check for equality with TOS. If a match is
- * found, executes corresponding stack program. If a `default` key is
- * specified and no other cases matched, run `default` program. In all
- * other cases throws an error.
- *
- * Important: The default case has the original TOS re-added to the
- * d-stack before execution.
- *
- * @param cases -
- */
-export const defCases = (cases) => (ctx) => {
-    $(ctx[0], 1);
-    const stack = ctx[0];
-    const tos = stack.pop();
-    const cas = cases[tos];
-    if (cas !== undefined) {
-        return $stackFn(cas)(ctx);
-    }
-    if (cases.default) {
-        stack.push(tos);
-        return $stackFn(cases.default)(ctx);
-    }
-    return illegalState(`no matching case for: ${tos}`);
+const defCases = (cases) => (ctx) => {
+  $(ctx[0], 1);
+  const stack = ctx[0];
+  const tos = stack.pop();
+  const cas = cases[tos];
+  if (cas !== void 0) {
+    return $stackFn(cas)(ctx);
+  }
+  if (cases.default) {
+    stack.push(tos);
+    return $stackFn(cases.default)(ctx);
+  }
+  return illegalState(`no matching case for: ${tos}`);
 };
-export const casesq = (ctx) => {
-    const stack = ctx[0];
-    $(stack, 2);
-    return defCases(stack.pop())(ctx);
+const casesq = (ctx) => {
+  const stack = ctx[0];
+  $(stack, 2);
+  return defCases(stack.pop())(ctx);
+};
+export {
+  casesq,
+  condq,
+  defCases,
+  defCond,
+  whenq
 };

package/context.js

@@ -1,12 +1,8 @@
-/**
- * Creates a new StackContext tuple from given d-stack and/or
- * environment only (the r-stack is always initialized empty).
- *
- * @param stack - initial d-stack
- * @param env - initial environment
- */
-export const ctx = (stack = [], env = {}) => [
-    stack,
-    [],
-    env,
+const ctx = (stack = [], env = {}) => [
+  stack,
+  [],
+  env
 ];
+export {
+  ctx
+};

package/dataflow.js

@@ -2,173 +2,59 @@ import { and, or } from "./logic.js";
 import { $ } from "./safe.js";
 import { dup, dup2, dup3, over, swap } from "./stack.js";
 import { $stackFn, defWord, exec } from "./word.js";
-//////////////////// Dataflow combinators  ////////////////////
-// these combinators have been ported from Factor:
-// http://docs.factorcode.org:8080/content/article-dataflow-combinators.html
-/**
- * Removes `x` from d-stack, calls `q` and restores `x` to the top of
- * the d-stack after quotation is finished.
- *
- * ( x q -- x )
- *
- * Same behavior as: `[swap, movdr, exec, movrd]`, only the current
- * implementation doesn't use r-stack and stashes `x` off stack.
- *
- * @param ctx -
- */
-export const dip = (ctx) => {
-    const stack = ctx[0];
-    $(stack, 2);
-    const q = stack.pop();
-    const x = stack.pop();
-    ctx = $stackFn(q)(ctx);
-    ctx[0].push(x);
-    return ctx;
+const dip = (ctx) => {
+  const stack = ctx[0];
+  $(stack, 2);
+  const q = stack.pop();
+  const x = stack.pop();
+  ctx = $stackFn(q)(ctx);
+  ctx[0].push(x);
+  return ctx;
+};
+const dip2 = defWord([swap, [dip], dip]);
+const dip3 = defWord([swap, [dip2], dip]);
+const dip4 = defWord([swap, [dip3], dip]);
+const keep = defWord([over, [exec], dip]);
+const keep2 = defWord([[dup2], dip, dip2]);
+const keep3 = defWord([[dup3], dip, dip3]);
+const bi = defWord([[keep], dip, exec]);
+const bi2 = defWord([[keep2], dip, exec]);
+const bi3 = defWord([[keep3], dip, exec]);
+const tri = defWord([[[keep], dip, keep], dip, exec]);
+const tri2 = defWord([[[keep2], dip, keep2], dip, exec]);
+const tri3 = defWord([[[keep3], dip, keep3], dip, exec]);
+const bis = defWord([[dip], dip, exec]);
+const bis2 = defWord([[dip2], dip, exec]);
+const tris = defWord([[[dip2], dip, dip], dip, exec]);
+const tris2 = defWord([[dip4], dip2, bis2]);
+const bia = defWord([dup, bis]);
+const bia2 = defWord([dup, bis2]);
+const tria = defWord([dup, dup, tris]);
+const tria2 = defWord([dup, dup, tris2]);
+const both = defWord([bia, and]);
+const either = defWord([bia, or]);
+export {
+  bi,
+  bi2,
+  bi3,
+  bia,
+  bia2,
+  bis,
+  bis2,
+  both,
+  dip,
+  dip2,
+  dip3,
+  dip4,
+  either,
+  keep,
+  keep2,
+  keep3,
+  tri,
+  tri2,
+  tri3,
+  tria,
+  tria2,
+  tris,
+  tris2
 };
-/**
- * Removes `x y` from d-stack, calls `q` and restores removed vals
- * to the top of the d-stack after quotation is finished.
- *
- * ( x y q -- x y )
- */
-export const dip2 = defWord([swap, [dip], dip]);
-/**
- * Removes `x y z` from d-stack, calls `q` and restores removed
- * vals to the top of the d-stack after quotation is finished.
- *
- * ( x y z q -- x y z )
- */
-export const dip3 = defWord([swap, [dip2], dip]);
-/**
- * Removes `x y z w` from d-stack, calls `q` and restores removed
- * vals to the top of the d-stack after quotation is finished.
- *
- * ( x y z w q -- x y z w )
- */
-export const dip4 = defWord([swap, [dip3], dip]);
-/**
- * Calls a quotation with a value on the d-stack, restoring the value
- * after quotation finished.
- *
- * ( x q -- .. x )
- */
-export const keep = defWord([over, [exec], dip]);
-/**
- * Call a quotation with two values on the stack, restoring the values
- * after quotation finished.
- *
- * ( x y q -- .. x y )
- */
-export const keep2 = defWord([[dup2], dip, dip2]);
-/**
- * Call a quotation with three values on the stack, restoring the values
- * after quotation finished.
- *
- * ( x y z q -- .. x y z )
- */
-export const keep3 = defWord([[dup3], dip, dip3]);
-/**
- * First applies `p` to the value `x`, then applies `q` to the same
- * value.
- *
- * ( x p q -- px qx )
- */
-export const bi = defWord([[keep], dip, exec]);
-/**
- * First applies `p` to the two input values `x y`, then applies `q` to
- * the same values.
- *
- * ( x y p q -- pxy qxy )
- */
-export const bi2 = defWord([[keep2], dip, exec]);
-/**
- * First applies `p` to the three input values `x y z`, then applies `q`
- * to the same values.
- *
- * ( x y z p q -- pxyz qxyz )
- */
-export const bi3 = defWord([[keep3], dip, exec]);
-/**
- * Applies `p` to `x`, then `q` to `x`, and finally `r` to `x`
- *
- * ( x p q r -- px qx rx )
- */
-export const tri = defWord([[[keep], dip, keep], dip, exec]);
-/**
- * Applies `p` to the two input values `x y`, then same with `q`, and
- * finally with `r`.
- *
- * ( x y p q r -- pxy qxy rxy )
- */
-export const tri2 = defWord([[[keep2], dip, keep2], dip, exec]);
-/**
- * Applies `p` to the three input values `x y z`, then same with `q`,
- * and finally with `r`.
- *
- * ( x y z p q r -- pxyz qxyz rxyz )
- */
-export const tri3 = defWord([[[keep3], dip, keep3], dip, exec]);
-/**
- * Applies `p` to `x`, then applies `q` to `y`.
- *
- * ( x y p q -- px qy )
- */
-export const bis = defWord([[dip], dip, exec]);
-/**
- * Applies `p` to `a b`, then applies `q` to `c d`.
- *
- * ( a b c d p q -- pab qcd )
- */
-export const bis2 = defWord([[dip2], dip, exec]);
-/**
- * Applies `p` to `x`, then `q` to `y`, and finally `r` to `z`.
- *
- * ( x y z p q r -- )
- */
-export const tris = defWord([[[dip2], dip, dip], dip, exec]);
-/**
- * Applies `p` to `u v`, then `q` to `w x`, and finally `r` to `y z`.
- *
- * ( u v w x y z p q r -- puv qwx ryz )
- */
-export const tris2 = defWord([[dip4], dip2, bis2]);
-/**
- * Applies the quotation `q` to `x`, then to `y`.
- *
- * ( x y q -- qx qy )
- */
-export const bia = defWord([dup, bis]);
-/**
- * Applies the quotation `q` to `x y`, then to `z w`.
- *
- * ( x y z w q -- qxy qzw )
- */
-export const bia2 = defWord([dup, bis2]);
-/**
- * Applies the `q` to `x`, then to `y`, and finally to `z`.
- *
- * ( x y z q -- qx qy qz )
- */
-export const tria = defWord([dup, dup, tris]);
-/**
- * Applies the quotation to `u v`, then to `w x`, and then to `y z`.
- *
- * ( u v w x y z q -- quv qwx qyz )
- */
-export const tria2 = defWord([dup, dup, tris2]);
-/**
- * Applies `q` individually to both input vals `x y` and combines
- * results with `and`. The final result will be true if both interim
- * results were truthy.
- *
- * ( x y q -- qx && qy )
- */
-export const both = defWord([bia, and]);
-/**
- * Applies `q` individually to both input vals `x y` and combines results with `or`.
- * The final result will be true if at least one of the interim results
- * was truthy.
- *
- * ( x y q -- qx || qy )
- */
-export const either = defWord([bia, or]);

package/env.js

@@ -1,68 +1,29 @@
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { $ } from "./safe.js";
-//////////////////// Environment  ////////////////////
-/**
- * Pushes current env onto d-stack.
- *
- * ( -- env )
- *
- * @param ctx -
- * @param env -
- */
-export const pushenv = (ctx) => (ctx[0].push(ctx[2]), ctx);
-/**
- * Loads value for `key` from current env and pushes it on d-stack.
- * Throws error if var doesn't exist.
- *
- * ( key -- env[key] )
- *
- * @param ctx -
- * @param env -
- */
-export const load = (ctx) => {
-    const stack = ctx[0];
-    $(stack, 1);
-    const id = stack.pop();
-    !ctx[2].hasOwnProperty(id) && illegalArgs(`unknown var: ${id}`);
-    stack.push(ctx[2][id]);
-    return ctx;
+const pushenv = (ctx) => (ctx[0].push(ctx[2]), ctx);
+const load = (ctx) => {
+  const stack = ctx[0];
+  $(stack, 1);
+  const id = stack.pop();
+  !ctx[2].hasOwnProperty(id) && illegalArgs(`unknown var: ${id}`);
+  stack.push(ctx[2][id]);
+  return ctx;
 };
-/**
- * Stores `val` under `key` in env.
- *
- * ( val key -- )
- *
- * @param ctx -
- * @param env -
- */
-export const store = (ctx) => ($(ctx[0], 2), (ctx[2][ctx[0].pop()] = ctx[0].pop()), ctx);
-/**
- * Higher order word. Similar to {@link load}, but always uses given
- * preconfigured `key` instead of reading it from d-stack at runtime
- * (also slightly faster). Throws error if var doesn't exist.
- *
- * ( -- env[key] )
- * @param ctx -
- * @param env -
- */
-export const defLoadKey = (key) => (ctx) => {
-    !ctx[2].hasOwnProperty(key) &&
-        illegalArgs(`unknown var: ${key.toString()}`);
-    ctx[0].push(ctx[2][key]);
-    return ctx;
+const store = (ctx) => ($(ctx[0], 2), ctx[2][ctx[0].pop()] = ctx[0].pop(), ctx);
+const defLoadKey = (key) => (ctx) => {
+  !ctx[2].hasOwnProperty(key) && illegalArgs(`unknown var: ${key.toString()}`);
+  ctx[0].push(ctx[2][key]);
+  return ctx;
 };
-/**
- * Higher order word. Similar to {@link store}, but always uses given
- * preconfigure `key` instead of reading it from d-stack at runtime
- * (also slightly faster).
- *
- * ( val -- )
- *
- * @param ctx -
- * @param env -
- */
-export const defStoreKey = (key) => (ctx) => {
-    $(ctx[0], 1);
-    ctx[2][key] = ctx[0].pop();
-    return ctx;
+const defStoreKey = (key) => (ctx) => {
+  $(ctx[0], 1);
+  ctx[2][key] = ctx[0].pop();
+  return ctx;
+};
+export {
+  defLoadKey,
+  defStoreKey,
+  load,
+  pushenv,
+  store
 };

package/index.js

@@ -14,5 +14,12 @@ export * from "./safe.js";
 export * from "./stack.js";
 export * from "./string.js";
 export * from "./word.js";
-export { $ as ensureStack, $n as ensureStackN } from "./safe.js";
-export { defOp1 as maptos, defOp2 as map2, defOp2v as op2v } from "./ops.js";
+import { $, $n } from "./safe.js";
+import { defOp1, defOp2, defOp2v } from "./ops.js";
+export {
+  $ as ensureStack,
+  $n as ensureStackN,
+  defOp2 as map2,
+  defOp1 as maptos,
+  defOp2v as op2v
+};

package/io.js

@@ -1,12 +1,9 @@
 import { $ } from "./safe.js";
-//////////////////// I/O  ////////////////////
-/**
- * Prints TOS to console
- *
- * ( x -- )
- *
- * @param ctx -
- */
-export const print = (ctx) => ($(ctx[0], 1), console.log(ctx[0].pop()), ctx);
-export const printds = (ctx) => (console.log(ctx[0]), ctx);
-export const printrs = (ctx) => (console.log(ctx[1]), ctx);
+const print = (ctx) => ($(ctx[0], 1), console.log(ctx[0].pop()), ctx);
+const printds = (ctx) => (console.log(ctx[0]), ctx);
+const printrs = (ctx) => (console.log(ctx[1]), ctx);
+export {
+  print,
+  printds,
+  printrs
+};

package/logic.js

@@ -1,87 +1,32 @@
 import { equiv as _equiv } from "@thi.ng/equiv";
 import { defOp1, defOp2 } from "./ops.js";
-//////////////////// Logic ops ////////////////////
-/**
- * ( x y -- x===y )
- *
- * @param ctx -
- */
-export const eq = defOp2((b, a) => a === b);
-/**
- * ( x y -- equiv(x,y) )
- *
- * @param ctx -
- */
-export const equiv = defOp2(_equiv);
-/**
- * ( x y -- x!==y )
- *
- * @param ctx -
- */
-export const neq = defOp2((b, a) => a !== b);
-/**
- * ( x y -- x&&y )
- *
- * @param ctx -
- */
-export const and = defOp2((b, a) => !!a && !!b);
-/**
- * ( x y -- x||y )
- *
- * @param ctx -
- */
-export const or = defOp2((b, a) => !!a || !!b);
-/**
- * ( x -- !x )
- *
- * @param ctx -
- */
-export const not = defOp1((x) => !x);
-/**
- * ( x y -- x<y )
- *
- * @param ctx -
- */
-export const lt = defOp2((b, a) => a < b);
-/**
- * ( x y -- x>y )
- *
- * @param ctx -
- */
-export const gt = defOp2((b, a) => a > b);
-/**
- * ( x y -- x<=y )
- *
- * @param ctx -
- */
-export const lteq = defOp2((b, a) => a <= b);
-/**
- * ( x y -- x>=y )
- *
- * @param ctx -
- */
-export const gteq = defOp2((b, a) => a >= b);
-/**
- * ( x -- x===0 )
- *
- * @param ctx -
- */
-export const iszero = defOp1((x) => x === 0);
-/**
- * ( x -- x>0 )
- *
- * @param ctx -
- */
-export const ispos = defOp1((x) => x > 0);
-/**
- * ( x -- x<0 )
- *
- * @param ctx -
- */
-export const isneg = defOp1((x) => x < 0);
-/**
- * ( x -- x==null )
- *
- * @param ctx -
- */
-export const isnull = defOp1((x) => x == null);
+const eq = defOp2((b, a) => a === b);
+const equiv = defOp2(_equiv);
+const neq = defOp2((b, a) => a !== b);
+const and = defOp2((b, a) => !!a && !!b);
+const or = defOp2((b, a) => !!a || !!b);
+const not = defOp1((x) => !x);
+const lt = defOp2((b, a) => a < b);
+const gt = defOp2((b, a) => a > b);
+const lteq = defOp2((b, a) => a <= b);
+const gteq = defOp2((b, a) => a >= b);
+const iszero = defOp1((x) => x === 0);
+const ispos = defOp1((x) => x > 0);
+const isneg = defOp1((x) => x < 0);
+const isnull = defOp1((x) => x == null);
+export {
+  and,
+  eq,
+  equiv,
+  gt,
+  gteq,
+  isneg,
+  isnull,
+  ispos,
+  iszero,
+  lt,
+  lteq,
+  neq,
+  not,
+  or
+};