funcity 0.1.0 → 0.2.0

package/README.md

@@ -2,6 +2,8 @@
 
 A functional language interpreter with text processing.
 
+![funcity](./images/funcity.120.png)
+
 [![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
@@ -43,7 +45,7 @@ The following code may further interest you:
 
 ```funcity
 {{
-set printWeather (fun w cond w.sunny 'nice' 'bad')
+set printWeather (fun w (cond w.sunny 'nice' 'bad'))
 }}
 Today is {{printWeather weather}} weather.
 ```
@@ -75,6 +77,8 @@ In other words, funcity is an interpreter that brings the power of functional pr
 
 ## Installation (CLI)
 
+TODO:
+
 ```bash
 npm install -D funcity-cli
 ```

package/dist/index.cjs

@@ -1,114 +1,5 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const emptyLocation = {
-  line: 0,
-  column: 0
-};
-const emptyRange = {
-  start: emptyLocation,
-  end: emptyLocation
-};
-const specialFunctionMarker = /* @__PURE__ */ Symbol("$$special$$");
-const makeSpecialFunction = (f) => {
-  f[specialFunctionMarker] = true;
-  return f;
-};
-const isSpecialFunction = (f) => {
-  var _a;
-  return (_a = f[specialFunctionMarker]) != null ? _a : false;
-};
-const isConditionalTrue = (v) => {
-  if (v === void 0 || v === null) {
-    return false;
-  }
-  switch (typeof v) {
-    case "boolean":
-      return v;
-    case "number":
-    case "bigint":
-      return v !== 0;
-    default:
-      return true;
-  }
-};
-const asIterable = (v) => {
-  if (typeof v[Symbol.iterator] === "function") {
-    return v;
-  } else {
-    return void 0;
-  }
-};
-const combineVariables = (...variablesList) => {
-  const variables = /* @__PURE__ */ new Map();
-  const appendVariables = (vs) => vs.forEach((v, k) => variables.set(k, v));
-  const appendRecord = (vs) => Object.keys(vs).forEach((k) => variables.set(k, vs[k]));
-  variablesList.forEach((vs) => {
-    if (vs["forEach"] !== void 0) {
-      appendVariables(vs);
-    } else {
-      appendRecord(vs);
-    }
-  });
-  return variables;
-};
-const fromError = (error) => {
-  var _a;
-  if (error.message) {
-    return error.message;
-  } else if (typeof error.toString === "function") {
-    return (_a = error.toString()) != null ? _a : "unknown";
-  } else {
-    return "unknown";
-  }
-};
-const widerRange = (...ranges) => {
-  let start = emptyRange.start;
-  let end = emptyRange.end;
-  for (const range of ranges) {
-    if (range.start.line >= 1 && range.start.column >= 1) {
-      if (start.line === 0 || start.column === 0) {
-        start = range.start;
-      } else if (range.start.line < start.line) {
-        start = range.start;
-      } else if (range.start.line === start.line && range.start.column < start.column) {
-        start = range.start;
-      }
-      if (end.line === 0 || end.column === 0) {
-        end = range.end;
-      } else if (range.end.line > end.line) {
-        end = range.end;
-      } else if (range.end.line === end.line && range.end.column > end.column) {
-        end = range.end;
-      }
-    }
-  }
-  return { start, end };
-};
-const locationEquals = (lhs, rhs) => lhs.line === rhs.line && lhs.column === rhs.column;
-const getLocationString = (range) => locationEquals(range.start, range.end) ? `${range.start.line}:${range.start.column}` : `${range.start.line}:${range.start.column}:${range.end.line}:${range.end.column}`;
-const printErrorString = (path, error) => {
-  switch (error.type) {
-    case "warning":
-      console.warn(
-        `${path}:${getLocationString(error.range)}: warning: ${error.description}`
-      );
-      break;
-    case "error":
-      console.error(
-        `${path}:${getLocationString(error.range)}: error: ${error.description}`
-      );
-      return true;
-  }
-  return false;
-};
-const outputErrors = (path, errors) => {
-  let isError = false;
-  for (const error of errors) {
-    const result = printErrorString(path, error);
-    isError || (isError = result);
-  }
-  return isError;
-};
 const tokenizeString = (context) => {
   const start = context.cursor.location("start");
   context.cursor.skip(1);
@@ -320,20 +211,20 @@ const tokenizeCodeBlock = (context) => {
   });
   return tokens;
 };
-const createTokenizerCursor = (text) => {
+const createTokenizerCursor = (script) => {
   let currentIndex = 0;
   let rawLine = 0;
   let rawColumn = 0;
   let lastLine = 0;
   let lastColumn = 0;
-  const eot = () => currentIndex >= text.length;
-  const getChar = (index) => text[(index != null ? index : 0) + currentIndex];
+  const eot = () => currentIndex >= script.length;
+  const getChar = (index) => script[(index != null ? index : 0) + currentIndex];
   const skip = (length) => {
     let lastch = "\0";
     while (length > 0) {
       lastColumn = rawColumn;
       lastLine = rawLine;
-      const ch = text[currentIndex];
+      const ch = script[currentIndex];
       if (ch === "\r") {
         rawColumn = 0;
       } else if (ch === "\n" && lastch !== "\r") {
@@ -358,7 +249,7 @@ const createTokenizerCursor = (text) => {
   };
   const skipUntil = (word) => {
     while (!eot()) {
-      const index = text.indexOf(word, currentIndex);
+      const index = script.indexOf(word, currentIndex);
       if (index === currentIndex) {
         skip(word.length);
         return true;
@@ -368,31 +259,31 @@ const createTokenizerCursor = (text) => {
     return false;
   };
   const assert = (word) => {
-    if (text.length - currentIndex < word.length) {
+    if (script.length - currentIndex < word.length) {
       return false;
     }
-    if (text.substring(currentIndex, currentIndex + word.length) === word) {
+    if (script.substring(currentIndex, currentIndex + word.length) === word) {
       return true;
     }
     return false;
   };
   const getRangeAndSkip = (length) => {
-    const result = text.substring(currentIndex, currentIndex + length);
+    const result = script.substring(currentIndex, currentIndex + length);
     skip(result.length);
     return result;
   };
   const getUntil = (word) => {
-    if (currentIndex >= text.length) {
+    if (currentIndex >= script.length) {
       return void 0;
     }
-    const index = text.indexOf(word, currentIndex);
+    const index = script.indexOf(word, currentIndex);
     if (index >= 0) {
-      const result = text.substring(currentIndex, index);
+      const result = script.substring(currentIndex, index);
       skip(index - currentIndex);
       return result;
     } else {
-      const result = text.substring(currentIndex, text.length);
-      skip(text.length - currentIndex);
+      const result = script.substring(currentIndex, script.length);
+      skip(script.length - currentIndex);
       return result;
     }
   };
@@ -459,6 +350,115 @@ const runTokenizer = (script, errors) => {
   }
   return tokens;
 };
+const emptyLocation = {
+  line: 0,
+  column: 0
+};
+const emptyRange = {
+  start: emptyLocation,
+  end: emptyLocation
+};
+const specialFunctionMarker = /* @__PURE__ */ Symbol("$$special$$");
+const makeSpecialFunction = (f) => {
+  f[specialFunctionMarker] = true;
+  return f;
+};
+const isSpecialFunction = (f) => {
+  var _a;
+  return (_a = f[specialFunctionMarker]) != null ? _a : false;
+};
+const isConditionalTrue = (v) => {
+  if (v === void 0 || v === null) {
+    return false;
+  }
+  switch (typeof v) {
+    case "boolean":
+      return v;
+    case "number":
+    case "bigint":
+      return v !== 0;
+    default:
+      return true;
+  }
+};
+const asIterable = (v) => {
+  if (typeof v[Symbol.iterator] === "function") {
+    return v;
+  } else {
+    return void 0;
+  }
+};
+const combineVariables = (...variablesList) => {
+  const variables = /* @__PURE__ */ new Map();
+  const appendVariables = (vs) => vs.forEach((v, k) => variables.set(k, v));
+  const appendRecord = (vs) => Object.keys(vs).forEach((k) => variables.set(k, vs[k]));
+  variablesList.forEach((vs) => {
+    if (vs["forEach"] !== void 0) {
+      appendVariables(vs);
+    } else {
+      appendRecord(vs);
+    }
+  });
+  return variables;
+};
+const fromError = (error) => {
+  var _a;
+  if (error.message) {
+    return error.message;
+  } else if (typeof error.toString === "function") {
+    return (_a = error.toString()) != null ? _a : "unknown";
+  } else {
+    return "unknown";
+  }
+};
+const widerRange = (...ranges) => {
+  let start = emptyRange.start;
+  let end = emptyRange.end;
+  for (const range of ranges) {
+    if (range.start.line >= 1 && range.start.column >= 1) {
+      if (start.line === 0 || start.column === 0) {
+        start = range.start;
+      } else if (range.start.line < start.line) {
+        start = range.start;
+      } else if (range.start.line === start.line && range.start.column < start.column) {
+        start = range.start;
+      }
+      if (end.line === 0 || end.column === 0) {
+        end = range.end;
+      } else if (range.end.line > end.line) {
+        end = range.end;
+      } else if (range.end.line === end.line && range.end.column > end.column) {
+        end = range.end;
+      }
+    }
+  }
+  return { start, end };
+};
+const locationEquals = (lhs, rhs) => lhs.line === rhs.line && lhs.column === rhs.column;
+const getLocationString = (range) => locationEquals(range.start, range.end) ? `${range.start.line}:${range.start.column}` : `${range.start.line}:${range.start.column}:${range.end.line}:${range.end.column}`;
+const printErrorString = (path, error) => {
+  switch (error.type) {
+    case "warning":
+      console.warn(
+        `${path}:${getLocationString(error.range)}: warning: ${error.description}`
+      );
+      break;
+    case "error":
+      console.error(
+        `${path}:${getLocationString(error.range)}: error: ${error.description}`
+      );
+      return true;
+  }
+  return false;
+};
+const outputErrors = (path, errors) => {
+  let isError = false;
+  for (const error of errors) {
+    const result = printErrorString(path, error);
+    isError || (isError = result);
+  }
+  return isError;
+};
 const parseNumber = (cursor, _errors) => {
   const token = cursor.takeToken();
   return {
@@ -564,7 +564,7 @@ const parsePartialExpression = (cursor, errors) => {
       return node;
     }
     case "open": {
-      cursor.takeToken();
+      cursor.skipToken();
       switch (token.symbol) {
         // Parenthesis surrounding expression list `( ... )` (Scope)
         case "(": {
@@ -588,7 +588,7 @@ const parsePartialExpression = (cursor, errors) => {
               )
             });
           } else {
-            cursor.takeToken();
+            cursor.skipToken();
             range = widerRange(
               token.range,
               ...innerNodes.map((node) => node.range),
@@ -628,7 +628,7 @@ const parsePartialExpression = (cursor, errors) => {
               range
             });
           } else {
-            cursor.takeToken();
+            cursor.skipToken();
             range = widerRange(
               token.range,
               ...itemNodes.map((node) => node.range),
@@ -721,7 +721,7 @@ const parseMultipleApplicationExpressions = (cursor, errors) => {
     }
     switch (token.kind) {
       case "eol": {
-        cursor.takeToken();
+        cursor.skipToken();
         const expr2 = finalizeApplicationException(partialNodes, errors);
         if (expr2) {
           expressionList.push(expr2);
@@ -766,7 +766,7 @@ const drainEndOfLineAndPeek = (cursor) => {
   let token = cursor.peekToken();
   while (token) {
     if (token.kind === "eol") {
-      cursor.takeToken();
+      cursor.skipToken();
     } else {
       break;
     }
@@ -791,7 +791,7 @@ const parseExpression = (cursor, errors) => {
       break;
     }
     if (token.kind === "eol") {
-      cursor.takeToken();
+      cursor.skipToken();
       token = cursor.peekToken();
       break;
     }
@@ -889,7 +889,7 @@ const parseStatementArguments = (cursor, errors) => {
       break;
     }
     if (token.kind === "eol") {
-      cursor.takeToken();
+      cursor.skipToken();
       break;
     }
     const partialNode = parsePartialExpression(cursor, errors);
@@ -945,7 +945,7 @@ const parseBlock = (cursor, errors) => {
     }
     switch (token.kind) {
       case "text": {
-        cursor.takeToken();
+        cursor.skipToken();
         if (isInExpressionBlock) {
           errors.push({
             type: "error",
@@ -963,7 +963,7 @@ const parseBlock = (cursor, errors) => {
       }
       case "open": {
         if (token.symbol === "{{") {
-          cursor.takeToken();
+          cursor.skipToken();
           if (isInExpressionBlock) {
             errors.push({
               type: "error",
@@ -981,7 +981,7 @@ const parseBlock = (cursor, errors) => {
         break;
       }
       case "close": {
-        cursor.takeToken();
+        cursor.skipToken();
         if (!isInExpressionBlock) {
           errors.push({
             type: "error",
@@ -1005,7 +1005,7 @@ const parseBlock = (cursor, errors) => {
         }
         switch (token.name) {
           case "if": {
-            cursor.takeToken();
+            cursor.skipToken();
             const args = parseStatementArguments(cursor, errors);
             if (args.length !== 1) {
               errors.push({
@@ -1030,7 +1030,7 @@ const parseBlock = (cursor, errors) => {
             break;
           }
           case "else": {
-            cursor.takeToken();
+            cursor.skipToken();
             const args = parseStatementArguments(cursor, errors);
             if (args.length !== 0) {
               errors.push({
@@ -1072,7 +1072,7 @@ const parseBlock = (cursor, errors) => {
             break;
           }
           case "while": {
-            cursor.takeToken();
+            cursor.skipToken();
             const args = parseStatementArguments(cursor, errors);
             if (args.length !== 1) {
               errors.push({
@@ -1095,7 +1095,7 @@ const parseBlock = (cursor, errors) => {
             break;
           }
           case "for": {
-            cursor.takeToken();
+            cursor.skipToken();
             const args = parseStatementArguments(cursor, errors);
             if (args.length !== 2) {
               errors.push({
@@ -1128,7 +1128,7 @@ const parseBlock = (cursor, errors) => {
             break;
           }
           case "end": {
-            cursor.takeToken();
+            cursor.skipToken();
             const args = parseStatementArguments(cursor, errors);
             if (args.length !== 0) {
               errors.push({
@@ -1200,7 +1200,7 @@ const parseBlock = (cursor, errors) => {
             break;
           }
           case "set": {
-            cursor.takeToken();
+            cursor.skipToken();
             const args = parseStatementArguments(cursor, errors);
             if (args.length !== 2) {
               errors.push({
@@ -1281,9 +1281,16 @@ const createParserCursor = (tokens) => {
     index++;
     return token;
   };
+  const skipToken = () => {
+    if (index >= tokens.length) {
+      return;
+    }
+    index++;
+  };
   return {
     peekToken,
-    takeToken
+    takeToken,
+    skipToken
   };
 };
 const runParser = (tokens, errors) => {
@@ -1575,28 +1582,18 @@ const createReducerContext = (variables, errors) => {
   };
   return context;
 };
-const unwrap = (results) => {
-  return results.flatMap((result) => {
-    if (result === void 0) {
-      return [];
-    } else {
-      return [result];
-    }
-  });
-};
 async function runReducer(nodes, variables, errors) {
   const context = createReducerContext(variables, errors);
-  if (Array.isArray(nodes)) {
-    const resultList = [];
-    for (const node of nodes) {
-      const results = await reduceNode(context, node);
-      resultList.push(...results);
+  const resultList = [];
+  for (const node of nodes) {
+    const results = await reduceNode(context, node);
+    for (const result of results) {
+      if (result !== void 0) {
+        resultList.push(result);
+      }
     }
-    return unwrap(resultList);
-  } else {
-    const results = await reduceNode(context, nodes);
-    return unwrap(results);
   }
+  return resultList;
 }
 const _cond = makeSpecialFunction(async function(arg0, arg1, arg2) {
   const cond = await this.reduce(arg0);
@@ -1939,7 +1936,7 @@ const _bind = async (arg0, ...args) => {
   const predicate = arg0;
   return predicate.bind(void 0, ...args);
 };
-const standardVariables = {
+const standardVariables = Object.freeze({
   undefined: void 0,
   null: null,
   true: true,
@@ -1978,13 +1975,21 @@ const standardVariables = {
   replace: _replace,
   regex: _regex,
   bind: _bind
-};
+});
 const buildCandidateVariables = (...variablesList) => {
   return combineVariables(standardVariables, ...variablesList);
 };
+const runScriptOnce = async (script, variables, errors = []) => {
+  const blocks = runTokenizer(script, errors);
+  const nodes = runParser(blocks, errors);
+  const results = await runReducer(nodes, variables, errors);
+  const text = results.join("");
+  return text;
+};
 exports.asIterable = asIterable;
 exports.buildCandidateVariables = buildCandidateVariables;
 exports.combineVariables = combineVariables;
+exports.createParserCursor = createParserCursor;
 exports.createReducerContext = createReducerContext;
 exports.emptyLocation = emptyLocation;
 exports.emptyRange = emptyRange;
@@ -1999,6 +2004,7 @@ exports.reduceExpressionNode = reduceExpressionNode;
 exports.reduceNode = reduceNode;
 exports.runParser = runParser;
 exports.runReducer = runReducer;
+exports.runScriptOnce = runScriptOnce;
 exports.runTokenizer = runTokenizer;
 exports.standardVariables = standardVariables;
 exports.widerRange = widerRange;