@thi.ng/pointfree-lang 2.2.36 → 2.2.38

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-04-23T07:02:18Z
+- **Last updated**: 2024-06-21T19:34:38Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,12 @@ 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.
 
+### [2.2.38](https://github.com/thi-ng/umbrella/tree/@thi.ng/pointfree-lang@2.2.38) (2024-06-21)
+
+#### ♻️ Refactoring
+
+- enforce uniform naming convention of internal functions ([56992b2](https://github.com/thi-ng/umbrella/commit/56992b2))
+
 ### [2.2.17](https://github.com/thi-ng/umbrella/tree/@thi.ng/pointfree-lang@2.2.17) (2024-02-22)
 
 #### ♻️ 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 192 standalone projects, maintained as part
+> This is one of 193 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -97,7 +97,7 @@ For Node.js REPL:
 const pfl = await import("@thi.ng/pointfree-lang");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 4.73 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 4.71 KB
 
 ## Dependencies
 

package/cli.js

@@ -98,8 +98,7 @@ Usage: pointfree [opts] [file]
     paramWidth: 24
   },
   ctx: async (ctx) => {
-    if (ctx.opts.debug)
-      ctx.logger.level = LogLevel.DEBUG;
+    if (ctx.opts.debug) ctx.logger.level = LogLevel.DEBUG;
     return ctx;
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/pointfree-lang",
-  "version": "2.2.36",
+  "version": "2.2.38",
   "description": "Forth style syntax layer/compiler & CLI for the @thi.ng/pointfree DSL",
   "type": "module",
   "module": "./index.js",
@@ -13,7 +13,7 @@
     "type": "git",
     "url": "https://github.com/thi-ng/umbrella.git"
   },
-  "homepage": "https://github.com/thi-ng/umbrella/tree/develop/packages/pointfree-lang#readme",
+  "homepage": "https://thi.ng/pointfree-lang",
   "funding": [
     {
       "type": "github",
@@ -40,20 +40,20 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.11.1",
-    "@thi.ng/args": "^2.3.32",
-    "@thi.ng/bench": "^3.5.5",
-    "@thi.ng/errors": "^2.5.6",
-    "@thi.ng/file-io": "^2.1.1",
-    "@thi.ng/logger": "^3.0.11",
-    "@thi.ng/pointfree": "^3.1.81"
+    "@thi.ng/api": "^8.11.3",
+    "@thi.ng/args": "^2.3.34",
+    "@thi.ng/bench": "^3.5.7",
+    "@thi.ng/errors": "^2.5.8",
+    "@thi.ng/file-io": "^2.1.3",
+    "@thi.ng/logger": "^3.0.13",
+    "@thi.ng/pointfree": "^3.1.83"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.43.0",
-    "esbuild": "^0.20.2",
+    "@microsoft/api-extractor": "^7.47.0",
+    "esbuild": "^0.21.5",
     "pegjs": "0.11.0-master.b7b87ea",
-    "typedoc": "^0.25.12",
-    "typescript": "^5.4.3"
+    "typedoc": "^0.25.13",
+    "typescript": "^5.5.2"
   },
   "keywords": [
     "ast",
@@ -106,5 +106,5 @@
     "parent": "@thi.ng/pointfree",
     "year": 2018
   },
-  "gitHead": "aed3421c21044c005fbcb7cc37965ccf85a870d2\n"
+  "gitHead": "154c95cf9d6bab32174498ec3b5b5d87e42be7f9\n"
 }

package/runtime.js

@@ -4,64 +4,64 @@ import * as pf from "@thi.ng/pointfree";
 import { ALIASES } from "./api.js";
 import { LOGGER } from "./logger.js";
 import { SyntaxError, parse } from "./parser.js";
-const nodeLoc = (node) => node.loc ? `line ${node.loc.join(":")} -` : "";
-const resolveSym = (node, ctx) => {
+const __nodeLoc = (node) => node.loc ? `line ${node.loc.join(":")} -` : "";
+const __resolveSym = (node, ctx) => {
   const id = node.id;
   let w = ctx[2].__words[id] || ALIASES[id] || pf[id];
   if (!w) {
-    illegalArgs(`${nodeLoc(node)} unknown symbol: ${id}`);
+    illegalArgs(`${__nodeLoc(node)} unknown symbol: ${id}`);
   }
   return w;
 };
-const resolveVar = (node, ctx) => {
+const __resolveVar = (node, ctx) => {
   const id = node.id;
   const v = ctx[2].__vars[id];
   if (!v) {
-    illegalArgs(`${nodeLoc(node)} unknown var: ${id}`);
+    illegalArgs(`${__nodeLoc(node)} unknown var: ${id}`);
   }
   if (!v.length) {
-    illegalState(`${nodeLoc(node)} missing bindings for var: ${id}`);
+    illegalState(`${__nodeLoc(node)} missing bindings for var: ${id}`);
   }
   return v[0];
 };
-const resolveNode = (node, ctx) => {
+const __resolveNode = (node, ctx) => {
   switch (node.type) {
     case "sym":
-      return resolveSym(node, ctx);
+      return __resolveSym(node, ctx);
     case "var_deref":
-      return resolveVar(node, ctx);
+      return __resolveVar(node, ctx);
     case "var_store":
-      return storevar(node.id);
+      return __storeVar(node.id);
     case "array":
-      return resolveArray(node, ctx);
+      return __resolveArray(node, ctx);
     case "obj":
-      return resolveObject(node, ctx);
+      return __resolveObject(node, ctx);
     default:
       return node.body;
   }
 };
-const resolveArray = (node, ctx) => {
+const __resolveArray = (node, ctx) => {
   const res = [];
   for (let n of node.body) {
-    res.push(resolveNode(n, ctx));
+    res.push(__resolveNode(n, ctx));
   }
   return res;
 };
-const resolveObject = (node, ctx) => {
+const __resolveObject = (node, ctx) => {
   const res = {};
   for (let [k, v] of node.body) {
-    res[k.type === "sym" ? k.id : resolveNode(k, ctx)] = resolveNode(
+    res[k.type === "sym" ? k.id : __resolveNode(k, ctx)] = __resolveNode(
       v,
       ctx
     );
   }
   return res;
 };
-const loadvar = (node) => (ctx) => {
-  ctx[0].push(resolveVar(node, ctx));
+const __loadVar = (node) => (ctx) => {
+  ctx[0].push(__resolveVar(node, ctx));
   return ctx;
 };
-const storevar = (id) => (ctx) => {
+const __storeVar = (id) => (ctx) => {
   pf.ensureStack(ctx[0], 1);
   const v = ctx[2].__vars[id];
   if (v === void 0) {
@@ -71,7 +71,7 @@ const storevar = (id) => (ctx) => {
   }
   return ctx;
 };
-const beginvar = (id) => (ctx) => {
+const __beginvar = (id) => (ctx) => {
   pf.ensureStack(ctx[0], 1);
   const v = ctx[2].__vars[id];
   if (v === void 0) {
@@ -81,7 +81,7 @@ const beginvar = (id) => (ctx) => {
   }
   return ctx;
 };
-const endvar = (id) => (ctx) => {
+const __endvar = (id) => (ctx) => {
   const v = ctx[2].__vars[id];
   if (v === void 0 || v.length === 0) {
     illegalState(`can't end scope for var: ${id}`);
@@ -92,11 +92,11 @@ const endvar = (id) => (ctx) => {
   }
   return ctx;
 };
-const visit = (node, ctx, state) => {
+const __visit = (node, ctx, state) => {
   LOGGER.fine("visit", node.type, node, ctx[0].toString());
   switch (node.type) {
     case "sym":
-      return visitSym(node, ctx, state);
+      return __visitSym(node, ctx, state);
     case "number":
     case "boolean":
     case "string":
@@ -104,24 +104,24 @@ const visit = (node, ctx, state) => {
       ctx[0].push(node.body);
       return ctx;
     case "array":
-      return visitArray(node, ctx, state);
+      return __visitArray(node, ctx, state);
     case "obj":
-      return visitObject(node, ctx, state);
+      return __visitObject(node, ctx, state);
     case "var_deref":
-      return visitDeref(node, ctx, state);
+      return __visitDeref(node, ctx, state);
     case "var_store":
-      return visitStore(node, ctx, state);
+      return __visitStore(node, ctx, state);
     case "word":
-      return visitWord(node, ctx, state);
+      return __visitWord(node, ctx, state);
     case "stack_comment":
-      visitStackComment(node, state);
+      __visitStackComment(node, state);
     default:
       LOGGER.fine("skipping node...");
   }
   return ctx;
 };
-const visitSym = (node, ctx, state) => {
-  const w = resolveSym(node, ctx);
+const __visitSym = (node, ctx, state) => {
+  const w = __resolveSym(node, ctx);
   if (state.word) {
     ctx[0].push(w);
     return ctx;
@@ -129,40 +129,40 @@ const visitSym = (node, ctx, state) => {
     return w(ctx);
   }
 };
-const visitDeref = (node, ctx, state) => (ctx[0].push(state.word ? loadvar(node) : resolveVar(node, ctx)), ctx);
-const visitStore = (node, ctx, state) => {
-  const store = storevar(node.id);
+const __visitDeref = (node, ctx, state) => (ctx[0].push(state.word ? __loadVar(node) : __resolveVar(node, ctx)), ctx);
+const __visitStore = (node, ctx, state) => {
+  const store = __storeVar(node.id);
   return state.word ? (ctx[0].push(store), ctx) : store(ctx);
 };
-const pushLocals = (fn, wctx, locals) => {
+const __pushLocals = (fn, wctx, locals) => {
   if (locals) {
     for (let stack = wctx[0], i = locals.length; i-- > 0; ) {
       stack.push(fn(locals[i]));
     }
   }
 };
-const visitWord = (node, ctx, state) => {
+const __visitWord = (node, ctx, state) => {
   const id = node.id;
   if (state.word) {
     illegalState(
-      `${nodeLoc(node)}: can't define words inside quotations (${id})`
+      `${__nodeLoc(node)}: can't define words inside quotations (${id})`
     );
   }
   let wctx = pf.ctx([], ctx[2]);
   state.word = { name: id, loc: node.loc };
   const locals = node.locals;
-  pushLocals(beginvar, wctx, locals);
+  __pushLocals(__beginvar, wctx, locals);
   for (let n of node.body) {
-    wctx = visit(n, wctx, state);
+    wctx = __visit(n, wctx, state);
   }
-  pushLocals(endvar, wctx, locals);
+  __pushLocals(__endvar, wctx, locals);
   const w = pf.defWord(wctx[0]);
   w.__meta = state.word;
   ctx[2].__words[id] = w;
   state.word = void 0;
   return ctx;
 };
-const visitStackComment = (node, state) => {
+const __visitStackComment = (node, state) => {
   const word = state.word;
   if (word && !word.stack) {
     word.stack = node.body.join(" -- ");
@@ -172,15 +172,15 @@ const visitStackComment = (node, state) => {
     });
   }
 };
-const visitWithResolver = (resolve) => (node, ctx, state) => {
+const __visitWithResolver = (resolve) => (node, ctx, state) => {
   ctx[0].push(
     state.word ? (_ctx) => (_ctx[0].push(resolve(node, _ctx)), _ctx) : resolve(node, ctx)
   );
   return ctx;
 };
-const visitArray = visitWithResolver(resolveArray);
-const visitObject = visitWithResolver(resolveObject);
-const ensureEnv = (env) => {
+const __visitArray = __visitWithResolver(__resolveArray);
+const __visitObject = __visitWithResolver(__resolveObject);
+const __ensureEnv = (env) => {
   env = env || {};
   if (!env.__words) {
     env.__words = {};
@@ -196,7 +196,7 @@ const ensureEnv = (env) => {
   }
   return env;
 };
-const finalizeEnv = (ctx) => {
+const __finalizeEnv = (ctx) => {
   const env = ctx[2];
   const vars = env.__vars;
   delete env.__vars;
@@ -210,13 +210,13 @@ const finalizeEnv = (ctx) => {
   return ctx;
 };
 const run = (src, env, stack = []) => {
-  let ctx = pf.ctx(stack, ensureEnv(env));
+  let ctx = pf.ctx(stack, __ensureEnv(env));
   const state = {};
   try {
     for (let node of parse(src)) {
-      ctx = visit(node, ctx, state);
+      ctx = __visit(node, ctx, state);
     }
-    return finalizeEnv(ctx);
+    return __finalizeEnv(ctx);
   } catch (e) {
     if (e instanceof SyntaxError) {
       throw new Error(
@@ -229,11 +229,14 @@ const run = (src, env, stack = []) => {
 };
 const runU = (src, env, stack, n = 1) => pf.unwrap(run(src, env, stack), n);
 const runE = (src, env, stack) => run(src, env, stack)[2];
-const runWord = (id, env, stack = []) => finalizeEnv(env.__words[id](pf.ctx(stack, ensureEnv(env))));
-const runWordU = (id, env, stack = [], n = 1) => pf.unwrap(finalizeEnv(env.__words[id](pf.ctx(stack, ensureEnv(env)))), n);
-const runWordE = (id, env, stack = []) => finalizeEnv(env.__words[id](pf.ctx(stack, ensureEnv(env))))[2];
+const runWord = (id, env, stack = []) => __finalizeEnv(env.__words[id](pf.ctx(stack, __ensureEnv(env))));
+const runWordU = (id, env, stack = [], n = 1) => pf.unwrap(
+  __finalizeEnv(env.__words[id](pf.ctx(stack, __ensureEnv(env)))),
+  n
+);
+const runWordE = (id, env, stack = []) => __finalizeEnv(env.__words[id](pf.ctx(stack, __ensureEnv(env))))[2];
 const ffi = (env, words) => {
-  env = ensureEnv(env);
+  env = __ensureEnv(env);
   env.__words = { ...env.__words, ...words };
   return env;
 };