fez-lisp 1.0.53 → 1.1.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.0.53",
+  "version": "1.1.1",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/compiler.js

@@ -10,6 +10,7 @@ import {
 import { leaf, isLeaf } from './parser.js'
 import { deepRename, lispToJavaScriptVariableName } from './utils.js'
 const Helpers = {
+  __string: `__string=(...args)=>{const str=args.flat();str.isString=true;return str}`,
   __add: `__add=(...numbers)=>{return numbers.reduce((a,b)=>a+b,0)}`,
   __sub: `__sub=(...numbers)=>{return numbers.reduce((a,b)=>a-b,0)}`,
   __mult: `__mult=(...numbers)=>{return numbers.reduce((a,b)=>a*b,1)}`,
@@ -46,13 +47,10 @@ const Helpers = {
   length: 'length=(arr)=>arr.length',
   __tco: `__tco=fn=>(...args)=>{let result=fn(...args);while(typeof result==='function')result=result();return result}`,
   numberPredicate: `numberPredicate=(number)=>+(typeof number==='number')`,
-  stringPredicate: `stringPredicate=(string)=>+(typeof string==='string')`,
   lambdaPredicate: `lambdaPredicate=(lambda)=>+(typeof lambda==='function')`,
   arrayPredicate: `arrayPredicate=(array)=>+Array.isArray(array)`,
-  atomPredicate: `atomPredicate=(value)=>+(typeof value==='number'||typeof value==='string')`,
   error: `error=(error)=>{throw new Error(error)}`,
-  array_setEffect: `array_setEffect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`,
-  cast: `cast=(type,value)=>{switch(type){case '${KEYWORDS.NUMBER_TYPE}':return Number(value);case '${KEYWORDS.STRING_TYPE}':return value.toString();case '${KEYWORDS.ARRAY_TYPE}':return typeof value==='number'?[...Number(value).toString()].map(Number):[...value];case '${KEYWORDS.BOOLEAN_TYPE}':return +!!value;case '${KEYWORDS.ANONYMOUS_FUNCTION}':return ()=>value;case '${KEYWORDS.CHAR_CODE_TYPE}':return value.charCodeAt(0);case '${KEYWORDS.CHAR_TYPE}':return String.fromCharCode(value);default:return 0}}`
+  array_setEffect: `array_setEffect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`
 }
 const semiColumnEdgeCases = new Set([
   ';)',
@@ -116,9 +114,6 @@ const compile = (tree, Drill) => {
         out += `),${name});`
         return out
       }
-      case KEYWORDS.IS_STRING:
-        Drill.Helpers.add('stringPredicate')
-        return `stringPredicate(${compile(Arguments[0], Drill)});`
       case KEYWORDS.IS_NUMBER:
         Drill.Helpers.add('numberPredicate')
         return `numberPredicate(${compile(Arguments[0], Drill)});`
@@ -133,19 +128,17 @@ const compile = (tree, Drill) => {
       case KEYWORDS.BOOLEAN_TYPE:
         return '1'
       case KEYWORDS.STRING_TYPE:
-        return '""'
+        Drill.Helpers.add('__string')
+        return `__string(${parseArgs(Arguments, Drill)});`
       case KEYWORDS.ARRAY_TYPE:
         return Arguments.length === 2 &&
           Arguments[1][TYPE] === WORD &&
           Arguments[1][VALUE] === 'length'
-          ? `(new Array(${compile(Arguments[0], Drill)}).fill(0))`
+          ? `(new Array(${compile(Arguments[0], Drill)}).fill(0));`
           : `[${parseArgs(Arguments, Drill)}];`
-      case KEYWORDS.ARRAY_OR_STRING_LENGTH:
+      case KEYWORDS.ARRAY_LENGTH:
         Drill.Helpers.add('length')
         return `length(${compile(Arguments[0], Drill)})`
-      case KEYWORDS.IS_ATOM:
-        Drill.Helpers.add('atomPredicate')
-        return `atomPredicate(${compile(Arguments[0], Drill)});`
       case KEYWORDS.FIRST_ARRAY:
         Drill.Helpers.add('car')
         return `car(${compile(Arguments[0], Drill)});`
@@ -295,9 +288,6 @@ const compile = (tree, Drill) => {
         out += '0);'
         return out
       }
-      case KEYWORDS.CAST_TYPE:
-        Drill.Helpers.add('cast')
-        return `cast("${Arguments[1][VALUE]}", ${compile(Arguments[0], Drill)})`
       case KEYWORDS.PIPE: {
         let inp = Arguments[0]
         for (let i = 1; i < Arguments.length; ++i)

package/src/evaluator.js

@@ -36,7 +36,7 @@ export const isAtom = (arg, env) => {
   if (arg[TYPE] === ATOM) return 1
   else {
     const atom = evaluate(arg, env)
-    return +(typeof atom === 'number' || typeof atom === 'string')
+    return +(typeof atom === 'number')
   }
 }
 export const run = (tree, env = {}) =>

package/src/interpreter.js

@@ -8,26 +8,7 @@ import {
   isForbiddenVariableName,
   stringifyArgs
 } from './utils.js'
-
 const keywords = {
-  [KEYWORDS.CONCATENATION]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.CONCATENATION
-        }), expected > 1 but got ${args.length}. (${
-          KEYWORDS.CONCATENATION
-        } ${stringifyArgs(args)})`
-      )
-    const operands = args.map((x) => evaluate(x, env))
-    if (operands.some((x) => typeof x !== 'string'))
-      throw new TypeError(
-        `Not all arguments of (${KEYWORDS.CONCATENATION}) are (${
-          KEYWORDS.STRING_TYPE
-        }) (${KEYWORDS.CONCATENATION} ${stringifyArgs(args)})`
-      )
-    return operands.reduce((a, b) => a + b, '')
-  },
   [KEYWORDS.REMAINDER_OF_DIVISION]: (args, env) => {
     if (args.length < 2)
       throw new RangeError(
@@ -92,23 +73,19 @@ const keywords = {
       )
     return operands.reduce((a, b) => a / b)
   },
-  [KEYWORDS.ARRAY_OR_STRING_LENGTH]: (args, env) => {
+  [KEYWORDS.ARRAY_LENGTH]: (args, env) => {
     if (args.length !== 1)
       throw new RangeError(
         `Invalid number of arguments for (${
-          KEYWORDS.ARRAY_OR_STRING_LENGTH
-        }) (= 1 required) (${KEYWORDS.ARRAY_OR_STRING_LENGTH} ${stringifyArgs(
-          args
-        )})`
+          KEYWORDS.ARRAY_LENGTH
+        }) (= 1 required) (${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
       )
     const array = evaluate(args[0], env)
-    if (!(Array.isArray(array) || typeof array === 'string'))
+    if (!Array.isArray(array))
       throw new TypeError(
-        `First argument of (${
-          KEYWORDS.ARRAY_OR_STRING_LENGTH
-        }) must be an (or ${KEYWORDS.ARRAY_TYPE} ${KEYWORDS.STRING_TYPE}) (${
-          KEYWORDS.ARRAY_OR_STRING_LENGTH
-        } ${stringifyArgs(args)})`
+        `First argument of (${KEYWORDS.ARRAY_LENGTH}) must be a ${
+          KEYWORDS.ARRAY_TYPE
+        } (${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
       )
     return array.length
   },
@@ -131,15 +108,6 @@ const keywords = {
       )
     return +(typeof evaluate(args[0], env) === 'number')
   },
-  [KEYWORDS.IS_STRING]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_STRING
-        }) (= 1 required) (${KEYWORDS.IS_STRING} ${stringifyArgs(args)})`
-      )
-    return +(typeof evaluate(args[0], env) === 'string')
-  },
   [KEYWORDS.IS_FUNCTION]: (args, env) => {
     if (args.length !== 1)
       throw new RangeError(
@@ -262,6 +230,11 @@ const keywords = {
       if (evaluate(args[i], env)) return evaluate(args[i + 1], env)
     return 0
   },
+  [KEYWORDS.STRING_TYPE]: (args, env) => {
+    const str = args.flatMap((x) => evaluate(x, env))
+    str.isString = true
+    return str
+  },
   [KEYWORDS.ARRAY_TYPE]: (args, env) => {
     if (!args.length) return []
     const isCapacity =
@@ -284,15 +257,6 @@ const keywords = {
     }
     return args.map((x) => evaluate(x, env))
   },
-  [KEYWORDS.IS_ATOM]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.IS_ATOM
-        }) (= 1 required) (${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
-      )
-    return isAtom(args[0], env)
-  },
   [KEYWORDS.FIRST_ARRAY]: (args, env) => {
     if (args.length !== 1)
       throw new RangeError(
@@ -439,7 +403,7 @@ const keywords = {
     const b = evaluate(args[1], env)
     if (typeof a !== 'number')
       throw new TypeError(
-        `Invalid use of (${KEYWORDS.EQUAL}), first arguments are not an ${
+        `Invalid use of (${KEYWORDS.EQUAL}), first argument is not an ${
           KEYWORDS.NUMBER_TYPE
         } (${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
       )
@@ -462,7 +426,7 @@ const keywords = {
     const b = evaluate(args[1], env)
     if (typeof a !== 'number')
       throw new TypeError(
-        `Invalid use of (${KEYWORDS.LESS_THAN}), first arguments are not an ${
+        `Invalid use of (${KEYWORDS.LESS_THAN}), first argument is not an ${
           KEYWORDS.NUMBER_TYPE
         } (${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
       )
@@ -485,11 +449,9 @@ const keywords = {
     const b = evaluate(args[1], env)
     if (typeof a !== 'number')
       throw new TypeError(
-        `Invalid use of (${
-          KEYWORDS.GREATHER_THAN
-        }), first arguments are not an ${KEYWORDS.NUMBER_TYPE} (${
-          KEYWORDS.GREATHER_THAN
-        } ${stringifyArgs(args)})`
+        `Invalid use of (${KEYWORDS.GREATHER_THAN}), first argument is not an ${
+          KEYWORDS.NUMBER_TYPE
+        } (${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
       )
     if (typeof b !== 'number')
       throw new TypeError(
@@ -516,7 +478,7 @@ const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
-        }), first arguments are not an ${KEYWORDS.NUMBER_TYPE} (${
+        }), first argument is not an ${KEYWORDS.NUMBER_TYPE} (${
           KEYWORDS.GREATHER_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -545,7 +507,7 @@ const keywords = {
       throw new TypeError(
         `Invalid use of (${
           KEYWORDS.LESS_THAN_OR_EQUAL
-        }), first arguments are not an ${KEYWORDS.NUMBER_TYPE} (${
+        }), first argument is not an ${KEYWORDS.NUMBER_TYPE} (${
           KEYWORDS.LESS_THAN_OR_EQUAL
         } ${stringifyArgs(args)})`
       )
@@ -643,7 +605,6 @@ const keywords = {
     })
     return env[name]
   },
-  [KEYWORDS.STRING_TYPE]: () => '',
   [KEYWORDS.NUMBER_TYPE]: () => 0,
   [KEYWORDS.BOOLEAN_TYPE]: () => 1,
   [KEYWORDS.CAST_TYPE]: (args, env) => {
@@ -671,60 +632,13 @@ const keywords = {
             )
           return num
         }
-        case KEYWORDS.STRING_TYPE:
-          return value.toString()
         case KEYWORDS.BOOLEAN_TYPE:
           return +!!value
-        case KEYWORDS.ARRAY_TYPE: {
-          if (typeof value === 'number')
-            return [...Number(value).toString()].map(Number)
-          else if (typeof value[Symbol.iterator] !== 'function')
-            throw new TypeError(
-              `Arguments are not iterable for ${KEYWORDS.ARRAY_TYPE} at (${
-                KEYWORDS.CAST_TYPE
-              }) (${KEYWORDS.CAST_TYPE} ${stringifyArgs(args)})`
-            )
-          return [...value]
-        }
-        case KEYWORDS.CHAR_TYPE: {
-          const index = evaluate(args[0], env)
-          if (!Number.isInteger(index) || index < 0)
-            throw new TypeError(
-              `Arguments are not (+ ${KEYWORDS.NUMBER_TYPE}) for ${
-                KEYWORDS.CHAR_TYPE
-              } at (${KEYWORDS.CAST_TYPE}) (${
-                KEYWORDS.CAST_TYPE
-              } ${stringifyArgs(args)})`
-            )
-          return String.fromCharCode(index)
-        }
-        case KEYWORDS.CHAR_CODE_TYPE: {
-          const string = evaluate(args[0], env)
-          if (typeof string !== 'string')
-            throw new TypeError(
-              `Argument is not (${KEYWORDS.STRING_TYPE}) for ${
-                KEYWORDS.CHAR_CODE_TYPE
-              } at (${KEYWORDS.CAST_TYPE}) (${
-                KEYWORDS.CAST_TYPE
-              } ${stringifyArgs(args)})`
-            )
-          if (string.length !== 1)
-            throw new RangeError(
-              `Argument is not of (= (length ${KEYWORDS.STRING_TYPE}) 1) for ${
-                KEYWORDS.CHAR_CODE_TYPE
-              } at (${KEYWORDS.CAST_TYPE}) (${
-                KEYWORDS.CAST_TYPE
-              } ${stringifyArgs(args)})`
-            )
-          return string.charCodeAt(0)
-        }
         default:
           throw new TypeError(
-            `Can only cast (or ${KEYWORDS.NUMBER_TYPE} ${
-              KEYWORDS.STRING_TYPE
-            } ${KEYWORDS.ARRAY_TYPE} ${KEYWORDS.BOOLEAN_TYPE} ${
-              KEYWORDS.CHAR_TYPE
-            } ${KEYWORDS.CHAR_CODE_TYPE}) at (${KEYWORDS.CAST_TYPE}) (${
+            `Can only cast (or ${KEYWORDS.NUMBER_TYPE} ${KEYWORDS.ARRAY_TYPE} ${
+              KEYWORDS.BOOLEAN_TYPE
+            }) at (${KEYWORDS.CAST_TYPE}) (${
               KEYWORDS.CAST_TYPE
             } ${stringifyArgs(args)})`
           )
@@ -965,18 +879,17 @@ const keywords = {
     return keywords[KEYWORDS.DEFINE_VARIABLE](args, env)
   },
   [KEYWORDS.TEST_CASE]: (args, env) => {
-    if (args.length !== 3)
+    if (args.length !== 2)
       throw new RangeError(
         `Invalid number of arguments to (${
           KEYWORDS.TEST_CASE
-        }) (= 3 required) (${KEYWORDS.TEST_CASE} ${stringifyArgs(args)})`
+        }) (= 2 required) (${KEYWORDS.TEST_CASE} ${stringifyArgs(args)})`
       )
-    const description = evaluate(args[0], env)
-    const a = evaluate(args[1], env)
-    const b = evaluate(args[2], env)
+    const a = evaluate(args[0], env)
+    const b = evaluate(args[1], env)
     return !isEqualTypes(a, b) || !isEqual(a, b)
-      ? [0, description, stringifyArgs([args[1]]), b, a]
-      : [1, description, stringifyArgs([args[1]]), a]
+      ? [0, stringifyArgs([args[0]]), b, a]
+      : [1, stringifyArgs([args[0]]), a]
   },
   [KEYWORDS.TEST_BED]: (args, env) => {
     let tests = []
@@ -994,15 +907,13 @@ const keywords = {
         )
       tests = args.map((x) => evaluate(x, env))
       res = tests.reduce(
-        (acc, [state, describe, ...rest]) =>
+        (acc, [state, ...rest]) =>
           `${acc}${
             !state
-              ? `x ${describe} Failed:\n ${rest[0]}\n + ${LISP.stringify(
+              ? `x ${rest[0]}\n + ${LISP.stringify(
                   rest[1]
                 )}\n - ${LISP.stringify(rest[2])}\n`
-              : `✓ ${describe} Passed:\n ${rest[0]}\n + ${LISP.stringify(
-                  rest[1]
-                )}\n`
+              : `✓ ${rest[0]}\n + ${LISP.stringify(rest[1])}\n`
           }`,
         ''
       )

package/src/keywords.js

@@ -9,20 +9,13 @@ export const ATOM = 2
 export const PLACEHOLDER = '.'
 // keywords aliases
 export const KEYWORDS = {
-  STRING_TYPE: 'string',
   NUMBER_TYPE: 'number',
-  BOOLEAN_TYPE: 'boolean',
+  STRING_TYPE: 'string',
   ARRAY_TYPE: 'array',
-  CHAR_CODE_TYPE: 'char-code',
-  CHAR_TYPE: 'char',
-  CAST_TYPE: 'type',
-  CONCATENATION: 'string:merge',
-  ARRAY_OR_STRING_LENGTH: 'length',
+  ARRAY_LENGTH: 'length',
   IS_ARRAY: 'array?',
   IS_NUMBER: 'number?',
-  IS_STRING: 'string?',
   IS_FUNCTION: 'lambda?',
-  IS_ATOM: 'atom?',
   ADDITION: '+',
   SUBTRACTION: '-',
   MULTIPLICATION: '*',

package/src/parser.js

@@ -1,5 +1,4 @@
 import { APPLY, ATOM, TYPE, WORD, VALUE } from './keywords.js'
-import { escape, preserveEscape } from './utils.js'
 export const leaf = (type, value) => [type, value]
 export const isLeaf = ([car]) => car === APPLY || car === ATOM || car === WORD
 export const LISP = {
@@ -10,15 +9,6 @@ export const LISP = {
       acc = ''
     for (let i = 0; i < source.length; ++i) {
       const cursor = source[i]
-      if (cursor === '"') {
-        acc += '"'
-        ++i
-        while (source[i] !== '"') {
-          if (source[i] === '\\') acc += escape(source[++i])
-          else acc += source[i]
-          ++i
-        }
-      }
       if (cursor === '(') {
         head.push([])
         stack.push(head)
@@ -28,8 +18,6 @@ export const LISP = {
         acc = ''
         if (token) {
           if (!head.length) head.push(leaf(APPLY, token))
-          else if (token.match(/^"([^"]*)"/))
-            head.push(leaf(ATOM, token.substring(1, token.length - 1)))
           else if (token.match(/^-?[0-9]\d*(\.\d+)?$/))
             head.push(leaf(ATOM, Number(token)))
           else head.push(leaf(WORD, token))
@@ -50,7 +38,6 @@ export const LISP = {
         return `(array ${array
           .map(([key, value]) => `("${key}" ${LISP.stringify(value)})`)
           .join(' ')})`
-    else if (typeof array === 'string') return `"${array}"`
     else if (typeof array === 'function') return '()'
     else if (typeof array === 'boolean') return +array
     else return array
@@ -65,10 +52,7 @@ export const LISP = {
           out += first[VALUE]
           break
         case ATOM:
-          out +=
-            typeof first[VALUE] === 'string'
-              ? `"${preserveEscape(first[VALUE])}"`
-              : first[VALUE]
+          out += first[VALUE]
           break
         case APPLY:
           out += `(${first[VALUE]} ${rest.map(dfs).join(' ')})`
@@ -117,6 +101,6 @@ export const AST = {
     typeof ast === 'object'
       ? `[${ast.map(AST.stringify).join(',')}]`
       : typeof ast === 'string'
-      ? `"${preserveEscape(ast)}"`
+      ? `"${ast}"`
       : ast
 }

package/src/utils.js

@@ -5,16 +5,29 @@ import { run } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
 export const logError = (error) => console.log('\x1b[31m', error, '\x1b[0m')
 export const logSuccess = (output) => console.log(output, '\x1b[0m')
+export const replaceStrings = (source) => {
+  const quotes = source.match(/"(.*?)"/g)
+  if (quotes)
+    for (const q of quotes)
+      source = source.replaceAll(
+        q,
+        `(string ${[...q]
+          .slice(1, -1)
+          .map((x) => x.charCodeAt(0))
+          .join(' ')})`
+      )
+  return source
+}
 export const removeNoCode = (source) =>
   source
-    // .replace(/;.+/g, '')
-    .replace(/;(?=(?:(?:[^"]*"){2})*[^"]*$).+/g, '')
-    .replace(/[\s\s]+(?=[^"]*(?:"[^"]*"[^"]*)*$)/g, ' ')
+    .replace(/;.+/g, '')
+    .replace(/[\s\s]/g, ' ')
     .trim()
+
 export const isBalancedParenthesis = (sourceCode) => {
   let count = 0
   const stack = []
-  const str = sourceCode.match(/[/\(|\)](?=[^"]*(?:"[^"]*"[^"]*)*$)/g) ?? []
+  const str = sourceCode.match(/[/\(|\)]/g) ?? []
   for (let i = 0; i < str.length; ++i)
     if (str[i] === '(') stack.push(str[i])
     else if (str[i] === ')') if (stack.pop() !== '(') ++count
@@ -38,15 +51,6 @@ export const escape = (Char) => {
       return ''
   }
 }
-const escapeChars = {
-  '\n': '\\n',
-  '\r': '\\r',
-  '\t': '\\t',
-  s: '\\s',
-  '"': '\\"'
-}
-export const preserveEscape = (str) =>
-  str.replace(/[\n\r\t\s\"]/g, (match) => escapeChars[match] || match)
 export const stringifyType = (type) =>
   !isLeaf(type)
     ? `(array ${type.map((t) => stringifyType(t)).join(' ')})`
@@ -156,9 +160,10 @@ export const dfs = (tree, callback) => {
 }
 export const deepClone = (ast) => AST.parse(AST.stringify(ast))
 export const fez = (source, options = {}) => {
-  const env = options.env ?? {}
+  const env = Object.create(null)
   try {
     if (typeof source === 'string') {
+      if (options.strings) source = replaceStrings(source)
       let code
       if (!options.compile)
         code = handleUnbalancedQuotes(
@@ -172,7 +177,7 @@ export const fez = (source, options = {}) => {
         throw new Error(
           'Top level expressions need to be wrapped in a (do) block'
         )
-      const ast = [...(options.std ? treeShake(parsed, std) : []), ...parsed]
+      const ast = [...treeShake(parsed, std), ...parsed]
       if (options.compile) {
         const js = Object.values(comp(deepClone(ast))).join('')
         return options.eval ? eval(js) : js