fez-lisp 1.2.58 → 1.2.60

package/package.json

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

package/src/compiler.js

@@ -53,6 +53,8 @@ const keywordToHelper = (name) => {
       return '__add'
     case KEYWORDS.MULTIPLICATION:
       return '__mult'
+    case KEYWORDS.DIVISION:
+      return '__div'
     case KEYWORDS.SUBTRACTION:
       return '__sub'
     case KEYWORDS.GREATHER_THAN:
@@ -83,8 +85,9 @@ const lispToJavaScriptVariableName = (name) =>
   )
 const Helpers = {
   __add: `__add=(...numbers)=>{return numbers.reduce((a,b)=>a+b,0)}`,
-  __sub: `__sub=(...numbers)=>{return numbers.reduce((a,b)=>a-b,0)}`,
+  __sub: `__sub=(...numbers)=>{return numbers.length===1?-numbers[0]:numbers.reduce((a,b)=>a-b,0)}`,
   __mult: `__mult=(...numbers)=>{return numbers.reduce((a,b)=>a*b,1)}`,
+  __div: `__div=(...numbers)=>{return numbers.length===1?1/numbers[0]:numbers.reduce((a, b)=>a/b)}`,
   __gteq: '__gteq=(a,b)=>+(a>=b)',
   __gt: '__gt=(a,b)=>+(a>b)',
   __eq: '__eq=(a,b)=>+(a===b)',

package/src/interpreter.js

@@ -11,7 +11,8 @@ export const keywords = {
           KEYWORDS.REMAINDER_OF_DIVISION
         } ${stringifyArgs(args)})`
       )
-    const [a, b] = args.map((x) => evaluate(x, env))
+    const a = evaluate(args[0], env)
+    const b = evaluate(args[1], env)
     if (typeof a !== 'number' || typeof b !== 'number')
       throw new TypeError(
         `Not all arguments of (${KEYWORDS.REMAINDER_OF_DIVISION}) are (${
@@ -501,7 +502,6 @@ export const keywords = {
     })
     return env[name]
   },
-  [KEYWORDS.NUMBER_TYPE]: () => 0,
   [KEYWORDS.BITWISE_AND]: (args, env) => {
     if (args.length < 2)
       throw new RangeError(

package/src/utils.js

@@ -381,6 +381,38 @@ export const deSuggar = (ast) => {
     if (first != undefined) {
       switch (first[TYPE]) {
         case WORD:
+          {
+            switch (first[VALUE]) {
+              case SUGGAR.POWER:
+                throw new TypeError(
+                  `(${
+                    SUGGAR.POWER
+                  }), can't be used as a word (hint use math:power instead) (${
+                    SUGGAR.POWER
+                  } ${stringifyArgs(rest)})`
+                )
+                break
+              case SUGGAR.INTEGER_DEVISION:
+                exp.length = 0
+                exp.push(
+                  ...[
+                    [APPLY, KEYWORDS.ANONYMOUS_FUNCTION],
+                    [WORD, 'a'],
+                    [WORD, 'b'],
+                    [
+                      [APPLY, KEYWORDS.BITWISE_OR],
+                      [
+                        [APPLY, KEYWORDS.DIVISION],
+                        [WORD, 'a'],
+                        [WORD, 'b']
+                      ],
+                      [ATOM, 0]
+                    ]
+                  ]
+                )
+                break
+            }
+          }
           break
         case ATOM:
           break
@@ -478,7 +510,15 @@ export const deSuggar = (ast) => {
                 break
               case SUGGAR.INTEGER_DEVISION:
                 {
-                  if (rest.some((x) => x[TYPE] === APPLY))
+                  if (rest.length !== 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.INTEGER_DEVISION
+                      }), expected (= 2) but got ${rest.length} (${
+                        SUGGAR.INTEGER_DEVISION
+                      } ${stringifyArgs(rest)})`
+                    )
+                  else if (rest.some((x) => x[TYPE] === APPLY))
                     throw new TypeError(
                       `Arguments of (${
                         SUGGAR.INTEGER_DEVISION
@@ -492,7 +532,7 @@ export const deSuggar = (ast) => {
                     exp.length = 1
                     exp[0] = [APPLY, KEYWORDS.BITWISE_OR]
                     exp.push([[APPLY, KEYWORDS.DIVISION], ...rest])
-                    exp.push([ATOM, FALSE])
+                    exp.push([ATOM, 0])
                   }
                 }
                 break