fez-lisp 1.5.102 → 1.5.103

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.103",
   "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)`
@@ -1130,7 +1131,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)
+  }
+}