fez-lisp 1.6.24 → 1.6.26

package/package.json

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

package/src/check.js

@@ -16,7 +16,7 @@ import {
   VALUE,
   WORD
 } from './keywords.js'
-import { isLeaf, LISP } from './parser.js'
+import { isLeaf } from './parser.js'
 import {
   SPECIAL_FORM_TYPES,
   toTypeNames,
@@ -91,6 +91,9 @@ export const identity = (name) => [
     [1, 'x']
   ]
 ]
+export const typeSetDefaultFunction = (Types, name, env, exp) =>
+  Types.set(withScope(name, env), () => formatType(name, env))
+
 const returnType = (rest) => {
   const body = rest.at(-1)
   const rem = hasBlock(body) ? body.at(-1) : body
@@ -459,7 +462,7 @@ const getScopeNames = (scope) => {
   }
   return scopeNames.reverse()
 }
-const withScope = (name, scope) => {
+export const withScope = (name, scope) => {
   const chain = getScopeNames(scope)
   return `${chain.join(' ')} ${name}`
 }
@@ -990,7 +993,11 @@ const checkReturnType = ({ exp, stack, name, env, check }) => {
 const stagger = (stack, method, data, fn) => {
   stack[method]({ data, fn })
 }
-export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
+export const typeCheck = (
+  ast,
+  ctx = SPECIAL_FORM_TYPES,
+  typeSet = typeSetDefaultFunction
+) => {
   const Types = new Map()
   const stack = new Brr()
   const rootScopeIndex = 1
@@ -1204,7 +1211,8 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                 )})`
               )
             if (name in env) {
-              Types.set(withScope(name, env), () => formatType(name, env))
+              typeSet(Types, name, env, exp)
+              // Types.set(withScope(name, env), () => formatType(name, env))
               // If current scope is root then these are user defined types
               if (env[SCOPE_NAME] === rootScopeIndex) break
             }
@@ -1344,7 +1352,8 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
               }
               check(rightHand, env, scope)
             }
-            Types.set(withScope(name, env), () => formatType(name, env))
+            typeSet(Types, name, env, exp)
+            // Types.set(withScope(name, env), () => formatType(name, env))
             break
           case KEYWORDS.ANONYMOUS_FUNCTION:
             {

package/src/macros.js

@@ -39,7 +39,14 @@ export const SUGGAR = {
   NEW_BIG_INTEGER: 'new:big-integer',
   PROMISES: '*DATA*',
   VARIABLE: 'variable',
-  SET_VARIABLE: 'set'
+  SET_VARIABLE: 'set',
+  INCREMENT: '++',
+  DECREMENT: '--',
+  INCREMENT_BY: '+=',
+  DECREMENT_BY: '-=',
+  BOOLEAN_VARIABLE: 'boolean',
+  BOOLEAN_VARIABLE_GET: 'boole',
+  BOOLEAN_VARIABLE_SET: 'boole-set'
 }
 export const deSuggarAst = (ast, scope) => {
   if (scope === undefined) scope = ast
@@ -102,19 +109,44 @@ export const deSuggarAst = (ast, scope) => {
               //       break
               case KEYWORDS.GET_ARRAY:
                 if (rest.length === 1) {
-                  exp.push([ATOM, 0])
+                  exp[0][VALUE] = 'math:var-get'
+                  // exp.push([ATOM, 0])
                 }
                 break
+              case SUGGAR.INCREMENT:
+                exp[0][VALUE] = 'math:var-increment!'
+                break
+              case SUGGAR.DECREMENT:
+                exp[0][VALUE] = 'math:var-decrement!'
+                break
+              case SUGGAR.INCREMENT_BY:
+                exp[0][VALUE] = 'math:var-add!'
+                deSuggarAst(exp.at(-1))
+                break
+              case SUGGAR.DECREMENT_BY:
+                exp[0][VALUE] = 'math:var-subtract!'
+                deSuggarAst(exp.at(-1))
+                break
               case SUGGAR.VARIABLE:
-                {
-                  exp[0][VALUE] = 'let'
-                  const temp = exp.pop()
-                  exp.push([[APPLY, 'var:def'], temp])
-                }
+                exp[0][VALUE] = 'let'
+                exp.push([[APPLY, 'math:var-def'], exp.pop()])
                 deSuggarAst(exp.at(-1))
                 break
               case SUGGAR.SET_VARIABLE:
-                exp[0][VALUE] = 'var:set!'
+                exp[0][VALUE] = 'math:var-set!'
+                deSuggarAst(exp.at(-1))
+                break
+              case SUGGAR.BOOLEAN_VARIABLE:
+                exp[0][VALUE] = 'let'
+                exp.push([[APPLY, 'boole:def-strict'], exp.pop()])
+                deSuggarAst(exp.at(-1))
+                break
+              case SUGGAR.BOOLEAN_VARIABLE_SET:
+                exp[0][VALUE] = 'boole:set!'
+                deSuggarAst(exp.at(-1))
+                break
+              case SUGGAR.BOOLEAN_VARIABLE_GET:
+                exp[0][VALUE] = 'boole:get'
                 deSuggarAst(exp.at(-1))
                 break
               case KEYWORDS.BLOCK:

package/src/types.js

@@ -1368,7 +1368,47 @@ export const formatType = (name, env) => {
       : `(let ${name} ${formatSubType(getTypes(stats))})`
     : name
 }
-
+export const formatInlineType = (name, env) => {
+  const stats = env[name][STATS]
+  return stats
+    ? getType(stats) === APPLY
+      ? `(lambda ${
+          stats[ARG_COUNT] === VARIADIC
+            ? '... '
+            : stats[ARGUMENTS]?.length
+            ? stats[ARGUMENTS].map(
+                (x, i) =>
+                  `${
+                    getType(x[STATS]) === APPLY
+                      ? `${formatType(i, stats[ARGUMENTS])}`
+                      : `${formatSubType(getTypes(x[STATS]))}`
+                  }`
+              ).join(' ') + ' '
+            : ''
+          // TODO format returned functions when type support is added
+        }(${KEYWORDS.BLOCK} ${formatSubType(getReturns(stats))}))`
+      : formatSubType(getTypes(stats))
+    : name
+}
+export const formatAstTypes = (name, env) => {
+  const stats = env[name][STATS]
+  return stats
+    ? getType(stats) === APPLY
+      ? [
+          stats[ARG_COUNT] === VARIADIC
+            ? '...'
+            : stats[ARGUMENTS]?.length
+            ? stats[ARGUMENTS].map((x, i) =>
+                getType(x[STATS]) === APPLY
+                  ? formatType(i, stats[ARGUMENTS])
+                  : formatSubType(getTypes(x[STATS]))
+              )
+            : '',
+          formatSubType(getReturns(stats))
+        ]
+      : formatSubType(getTypes(stats))
+    : name
+}
 export const validateLambda = (exp, name) => {
   if (exp.length === 1)
     throw new TypeError(