fez-lisp 1.1.23 → 1.1.24

package/package.json

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

package/src/compiler.js

@@ -223,14 +223,18 @@ const compile = (tree, Drill) => {
         const vars = InnerDrills.Variables.size
           ? `var ${[...InnerDrills.Variables].join(',')};`
           : ''
-        return `((${parseArgs(
+        const args = parseArgs(
           functionArgs.map((node, index) =>
             node[VALUE] === PLACEHOLDER
               ? leaf(node[TYPE], `_${index}`)
               : leaf(node[TYPE], node[VALUE])
           ),
           InnerDrills
-        )})=>{${vars}return ${evaluatedBody.toString().trimStart()}});`
+        )
+        // const $ = [${args}];
+        return `((${args})=>{${vars}return ${evaluatedBody
+          .toString()
+          .trimStart()}});`
       }
       case KEYWORDS.AND:
         return `((${parseArgs(Arguments, Drill, '&&')}) ? 1 : 0);`

package/src/interpreter.js

@@ -317,9 +317,11 @@ const keywords = {
           } ${stringifyArgs(args)})`
         )
       const localEnv = Object.create(env)
+      // localEnv[KEYWORDS.BLOCK] = block[KEYWORDS.BLOCK]
       for (let i = 0; i < props.length; ++i) {
+        const value = evaluate(props[i], scope)
         Object.defineProperty(localEnv, params[i][VALUE], {
-          value: evaluate(props[i], scope),
+          value,
           writable: true
         })
       }
@@ -902,7 +904,16 @@ keywords[KEYWORDS.DOC] = (args, env) => {
         .map((x) => `(${x.join(' ')})`)
   }
 }
+
 export const deSuggar = (ast) => {
+  if (ast.length === 0)
+    throw new SyntaxError(
+      `Top level ${KEYWORDS.NUMBER_TYPE} need to be wrapped in a (${KEYWORDS.IDENTITY})`
+    )
+  // for (const node of ast)
+  //   if (node[0] && node[0][TYPE] === APPLY && node[0][VALUE] === KEYWORDS.BLOCK)
+  //     throw new SyntaxError(`Top level (${KEYWORDS.BLOCK}) is not allowed`)
+  let prev = undefined
   const evaluate = (exp) => {
     const [first, ...rest] = isLeaf(exp) ? [exp] : exp
     if (first != undefined) {
@@ -914,6 +925,33 @@ export const deSuggar = (ast) => {
         case APPLY:
           {
             switch (first[VALUE]) {
+              case KEYWORDS.BLOCK:
+                {
+                  if (
+                    prev == undefined ||
+                    (prev &&
+                      prev[TYPE] === APPLY &&
+                      prev[VALUE] !== KEYWORDS.ANONYMOUS_FUNCTION)
+                  )
+                    throw new SyntaxError(
+                      `Can only use (${KEYWORDS.BLOCK}) as a body of a (${KEYWORDS.ANONYMOUS_FUNCTION})`
+                    )
+                }
+                break
+                // case KEYWORDS.DEFINE_VARIABLE:
+                //   {
+                //     if (
+                //       rest[1] &&
+                //       rest[1][0] &&
+                //       rest[1][0][TYPE] === APPLY &&
+                //       rest[1][0][VALUE] === KEYWORDS.BLOCK
+                //     ) {
+                //       throw new SyntaxError(
+                //         `Can't use (${KEYWORDS.BLOCK}) in (${KEYWORDS.DEFINE_VARIABLE})`
+                //       )
+                //     }
+                //   }
+                break
               case KEYWORDS.PIPE:
                 {
                   if (rest.length < 1)
@@ -957,6 +995,7 @@ export const deSuggar = (ast) => {
                 }
                 break
             }
+            prev = first
           }
           break
         default:

package/src/keywords.js

@@ -5,9 +5,9 @@ export const WORD = 1
 export const ATOM = 2
 export const PLACEHOLDER = '.'
 export const KEYWORDS = {
-  RECURSION: 'rec',
   NUMBER_TYPE: 'number',
   ARRAY_TYPE: 'array',
+  IDENTITY: 'identity',
   ARRAY_LENGTH: 'length',
   IS_ATOM: 'atom?',
   ADDITION: '+',

package/src/utils.js

@@ -233,10 +233,6 @@ export const fez = (source, options = {}) => {
       if (!options.mutation) code = removeMutation(code)
       if (!code.length && options.throw) throw new Error('Nothing to parse!')
       const parsed = deSuggar(LISP.parse(code))
-      if (parsed.length === 0 && options.throw)
-        throw new Error(
-          'Top level expressions need to be wrapped in a (do) block'
-        )
       const ast = [...treeShake(parsed, std), ...parsed]
       // if (options.check) typeCheck(ast)
       if (options.compile) {