fez-lisp 1.5.102 → 1.5.104

package/package.json

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

package/src/check.js

@@ -37,6 +37,7 @@ import {
   validateLambda
 } from './types.js'
 import {
+  Brr,
   getSuffix,
   hasApplyLambdaBlock,
   hasBlock,
@@ -240,13 +241,13 @@ const retry = (stats, stack, cb) => {
     stats.retried < MAX_RETRY_DEFINITION
   ) {
     stats.retried += 1
-    stack.unshift(() => cb())
+    stack.prepend(() => cb())
   }
 }
 const retryArgs = (stats, stack, cb) => {
   if (stats.counter < MAX_ARGUMENT_RETRY) {
     stats.counter++
-    stack.unshift(cb)
+    stack.prepend(cb)
   }
 }
 const ifExpression = ({ re, env, ref }) => {
@@ -329,7 +330,7 @@ const resolveCondition = ({ rem, name, env, exp }) => {
     default:
       if (env[ret[VALUE]]) setReturnRef(ref[STATS], env[ret[VALUE]][STATS])
       else
-        stack.push(() => {
+        stack.append(() => {
           if (env[ret[VALUE]]) setReturnRef(ref[STATS], env[ret[VALUE]][STATS])
         })
       break
@@ -355,7 +356,7 @@ const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
             // rest.at(-1)[0][TYPE] === APPLY
             // Here is upon application to store the result in the variable
             if (isUnknownType(env[name][STATS]))
-              stack.unshift(() => {
+              stack.prepend(() => {
                 setTypeToReturn(env[name][STATS], env[returns[VALUE]][STATS])
                 // env[name][STATS][TYPE_PROP][0] =
                 //   env[returns[VALUE]][STATS][RETURNS][0]
@@ -390,7 +391,7 @@ export const typeCheck = (ast, error = true) => {
   let scopeIndex = 0
   const root = structuredClone(SPECIAL_FORM_TYPES)
   const Types = new Map()
-  const stack = []
+  const stack = new Brr()
   const check = (exp, env, scope) => {
     const [first, ...rest] = isLeaf(exp) ? [exp] : exp
     if (first === undefined)
@@ -402,7 +403,7 @@ export const typeCheck = (ast, error = true) => {
     switch (first[TYPE]) {
       case WORD:
         if (!isSpecial)
-          stack.push(() => {
+          stack.append(() => {
             // Figure out how to determine if varible is define after it's used
             if (env[first[VALUE]] === undefined) {
               throw new TypeError(
@@ -567,7 +568,7 @@ export const typeCheck = (ast, error = true) => {
                 // TODO figure out what we do here
                 // this here is a variable WORD
                 // so return type of that function is that varible type
-                stack.push(
+                stack.append(
                   () =>
                     copy[returns[VALUE]] &&
                     setReturnToType(ref[STATS], copy[returns[VALUE]][STATS])
@@ -589,7 +590,7 @@ export const typeCheck = (ast, error = true) => {
                     if (copy[ret[VALUE]])
                       setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
                     else
-                      stack.push(() => {
+                      stack.append(() => {
                         if (copy[ret[VALUE]])
                           setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
                       })
@@ -619,7 +620,7 @@ export const typeCheck = (ast, error = true) => {
             }
             break
           default:
-            stack.push(() => {
+            stack.append(() => {
               if (!isSpecial && env[first[VALUE]] === undefined)
                 throw new TypeError(
                   `Trying to call undefined (lambda) ${first[VALUE]} (check #9)`
@@ -848,7 +849,7 @@ export const typeCheck = (ast, error = true) => {
                       getType(args[i][STATS]) !== ATOM
                     ) {
                       throw new TypeError(
-                        `Incorrect type of arguments ${i} for (${
+                        `Incorrect type of argument (${i}) for (${
                           first[VALUE]
                         }). Expected (${toTypeNames(
                           getType(args[i][STATS])
@@ -862,8 +863,19 @@ export const typeCheck = (ast, error = true) => {
                       !isUnknownType(env[rest[i][VALUE]][STATS]) &&
                       env[rest[i][VALUE]][STATS][ARG_COUNT] !== VARIADIC
                     ) {
+                      if (getType(args[i][STATS]) !== APPLY)
+                        // TODO this should really happen in 10 or 16
+                        throw new TypeError(
+                          `Incorrect type for argument of (${
+                            first[VALUE]
+                          }) at position (${i}). Expected (${
+                            STATIC_TYPES.ABSTRACTION
+                          }) but got (${toTypeNames(
+                            getType(args[i][STATS])
+                          )}) (${stringifyArgs(exp)}) (check #111)`
+                        )
                       // Handles words that are Lambdas
-                      if (
+                      else if (
                         env[rest[i][VALUE]][STATS][ARG_COUNT] !==
                         args[i][STATS][ARG_COUNT]
                       ) {
@@ -936,6 +948,7 @@ export const typeCheck = (ast, error = true) => {
                         }
                       }
                     }
+
                     if (
                       T === COLLECTION &&
                       env[rest[i][VALUE]] &&
@@ -944,7 +957,7 @@ export const typeCheck = (ast, error = true) => {
                       !compareTypes(env[rest[i][VALUE]][STATS], args[i][STATS])
                     ) {
                       throw new TypeError(
-                        `Incorrect type of arguments ${i} for (${
+                        `Incorrect type of argument (${i}) for (${
                           first[VALUE]
                         }). Expected (${toTypeNames(
                           getType(args[i][STATS])
@@ -952,9 +965,9 @@ export const typeCheck = (ast, error = true) => {
                           exp
                         )}) (check #30)`
                       )
-                    } else if (isUnknownType(args[i][STATS]))
+                    } else if (isUnknownType(args[i][STATS])) {
                       retry(args[i][STATS], stack, () => check(exp, env, scope))
-                    else if (
+                    } else if (
                       env[rest[i][VALUE]] &&
                       !isUnknownType(args[i][STATS]) &&
                       isUnknownType(env[rest[i][VALUE]][STATS]) &&
@@ -974,7 +987,7 @@ export const typeCheck = (ast, error = true) => {
                       if (!isUnknownType(expected) && !isUnknownReturn(actual))
                         if (!compareTypeWithReturn(expected, actual))
                           throw new TypeError(
-                            `Incorrect type of arguments ${i} for (${
+                            `Incorrect type of argument (${i}) for (${
                               first[VALUE]
                             }). Expected (${toTypeNames(
                               getType(expected)
@@ -1130,7 +1143,7 @@ export const typeCheck = (ast, error = true) => {
   }
   const copy = JSON.parse(JSON.stringify(ast))
   check(copy, root, copy)
-  while (stack.length) stack.pop()()
+  while (stack.length) stack.cut()()
   return [ast, Types]
 }
 export const type = (ast) => typeCheck(ast)[0]

package/src/utils.js

@@ -347,3 +347,116 @@ export const UTILS = {
   stringifyArgs,
   shake
 }
+export class Brr {
+  constructor(...items) {
+    this._left = [Brr._negativeZeroSymbol]
+    this._right = []
+    if (items.length === 0) return this
+    const half = (items.length / 2) | 0.5
+    for (let i = half - 1; i >= 0; --i) this._left.push(items[i])
+    for (let i = half; i < items.length; ++i) this._right.push(items[i])
+    return this
+  }
+  _addToLeft(item) {
+    this._left.push(item)
+  }
+  _addToRight(item) {
+    this._right.push(item)
+  }
+  _removeFromLeft() {
+    const len = this.length
+    if (len) {
+      if (len === 1) this.clear()
+      else if (this._left.length > 0) this._left.pop()
+    }
+  }
+  _removeFromRight() {
+    const len = this.length
+    if (len) {
+      if (len === 1) this.clear()
+      else if (this._right.length > 0) this._right.pop()
+    }
+  }
+  static _negativeZeroSymbol = Symbol('-0')
+  static isBrr(entity) {
+    return entity instanceof Brr
+  }
+  _offsetLeft() {
+    return (this._left.length - 1) * -1
+  }
+  _offsetRight() {
+    return this._right.length
+  }
+  get length() {
+    return this._left.length + this._right.length - 1
+  }
+  get first() {
+    return this.get(0)
+  }
+  get last() {
+    return this.get(-1)
+  }
+  get(offset) {
+    if (offset < 0) offset = this.length + offset
+    const offsetIndex = offset + this._offsetLeft()
+    const index = offsetIndex < 0 ? offsetIndex * -1 : offsetIndex
+    return offsetIndex >= 0 ? this._right[index] : this._left[index]
+  }
+  set(index, value) {
+    index = index < 0 ? this.length + index : index
+    const offset = index + this._offsetLeft()
+    if (offset >= 0) this._right[offset] = value
+    else this._left[offset * -1] = value
+    return this
+  }
+  append(item) {
+    this._addToRight(item)
+    return this
+  }
+  prepend(item) {
+    this._addToLeft(item)
+    return this
+  }
+  cut() {
+    if (this._offsetRight() === 0) this.balance()
+    const last = this.last
+    this._removeFromRight()
+    return last
+  }
+  chop() {
+    if (this._offsetLeft() === 0) this.balance()
+    const first = this.first
+    this._removeFromLeft()
+    return first
+  }
+  head() {
+    if (this._offsetRight() === 0) this.balance()
+    this._removeFromRight()
+    return this
+  }
+  tail() {
+    if (this._offsetLeft() === 0) this.balance()
+    this._removeFromLeft()
+    return this
+  }
+  clear() {
+    this._left.length = 1
+    this._right.length = 0
+    return this
+  }
+  isBalanced() {
+    return this._offsetRight() + this._offsetLeft() === 0
+  }
+  balance() {
+    if (this.isBalanced()) return this
+    const initial = [...this]
+    this.clear()
+    const half = (initial.length / 2) | 0.5
+    for (let i = half - 1; i >= 0; --i) this._addToLeft(initial[i])
+    for (let i = half; i < initial.length; ++i) this._addToRight(initial[i])
+    return this
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0, len = this.length; i < len; ++i) yield this.get(i)
+  }
+}