fez-lisp 1.5.125 → 1.5.128

package/package.json

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

package/src/check.js

@@ -2,7 +2,10 @@ import {
   APPLY,
   ATOM,
   FALSE,
+  GETTERS_SET,
   KEYWORDS,
+  MUTATION_SUFFIX,
+  MUTATORS_SET,
   PLACEHOLDER,
   PREDICATE_SUFFIX,
   PREDICATES_OUTPUT_SET,
@@ -40,13 +43,17 @@ import {
   BOOLEAN_SUBTYPE,
   formatSubType,
   PREDICATE,
-  IS_ARGUMENT
+  IS_ARGUMENT,
+  NUMBER,
+  SETTER
 } from './types.js'
 import {
   Brr,
   getSuffix,
   hasApplyLambdaBlock,
   hasBlock,
+  log,
+  logExp,
   stringifyArgs
 } from './utils.js'
 Set.prototype.union = function (B) {
@@ -107,10 +114,16 @@ export const isUnknownNotAnyType = (stats) =>
 export const isUnknownNotAnyReturn = (stats) =>
   stats && !isAnyReturn(stats) && isUnknownReturn(stats)
 export const castType = (stats, type) => {
-  return (stats[TYPE_PROP][0] = type[RETURNS][0])
+  return (
+    (stats[TYPE_PROP][0] = type[RETURNS][0]),
+    (stats[TYPE_PROP][1] = type[RETURNS][1])
+  )
 }
 export const castReturn = (stats, type) => {
-  return (stats[RETURNS][0] = type[RETURNS][0])
+  return (
+    (stats[RETURNS][0] = type[RETURNS][0]),
+    (stats[RETURNS][1] = type[RETURNS][1])
+  )
 }
 export const isTypeAbstraction = (stats) => stats[TYPE_PROP] === APPLY
 export const setPropToAtom = (stats, prop) => {
@@ -123,7 +136,7 @@ export const setPropToPredicate = (stats, prop) => {
   return (stats[prop][1] = BOOLEAN_SUBTYPE())
 }
 export const setReturnToPredicate = (stats) => {
-  return (stats[RETURNS][1] = BOOLEAN_SUBTYPE())
+  return (stats[RETURNS][0] = BOOLEAN_SUBTYPE())
 }
 export const setTypeToPredicate = (stats) => {
   return (stats[RETURNS][1] = BOOLEAN_SUBTYPE())
@@ -152,6 +165,7 @@ export const setPropToReturn = (stats, prop, value) => {
 }
 export const setPropToReturnRef = (stats, prop, value) => {
   return (
+    stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     value[RETURNS][0] !== UNKNOWN &&
     (stats[prop] = value[RETURNS])
@@ -159,6 +173,7 @@ export const setPropToReturnRef = (stats, prop, value) => {
 }
 export const setPropToType = (stats, prop, value) => {
   return (
+    stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     ((stats[prop][0] = value[TYPE_PROP][0]),
     value[TYPE_PROP][1] && (stats[prop][1] = value[TYPE_PROP][1]))
@@ -166,6 +181,7 @@ export const setPropToType = (stats, prop, value) => {
 }
 export const setPropToTypeRef = (stats, prop, value) => {
   return (
+    stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     (stats[prop] = value[TYPE_PROP])
   )
@@ -177,12 +193,18 @@ export const setReturnToAtom = (stats) => {
 }
 export const setTypeToAtom = (stats) =>
   (isUnknownType(stats) || isAnyType(stats)) && (stats[TYPE_PROP][0] = ATOM)
+export const setTypeToCollection = (stats) =>
+  (isUnknownType(stats) || isAnyType(stats)) &&
+  (stats[TYPE_PROP][0] = COLLECTION)
 export const setReturnToAbbstraction = (stats) =>
   isUnknownReturn(stats) && (stats[RETURNS][0] = APPLY)
 export const setTypeRef = (stats, value) =>
   (isUnknownType(stats) || isAnyType(stats)) &&
   (stats[TYPE_PROP] = value[TYPE_PROP])
 export const setReturnRef = (stats, value) => {
+  if (SPECIAL_FORMS_SET.has(value[SIGNATURE])) {
+    return setReturn(stats, value)
+  }
   return isUnknownReturn(stats) && (stats[RETURNS] = value[RETURNS])
 }
 export const setReturnToTypeRef = (stats, value) => {
@@ -217,6 +239,15 @@ export const setType = (stats, value) =>
   !isUnknownType(value) &&
   ((stats[TYPE_PROP][0] = value[TYPE_PROP][0]),
   value[TYPE_PROP][1] && (stats[TYPE_PROP][1] = value[TYPE_PROP][1]))
+export const setSubType = (stats, value) =>
+  // makes no senseto protect this for now
+  hasSubType(value) && (stats[TYPE_PROP][1] = value[TYPE_PROP][1])
+export const setPropToSubType = (stats, prop, value) =>
+  // makes no senseto protect this for now
+  hasSubType(value) && (stats[prop][1] = value[TYPE_PROP][1])
+export const setPropToSubReturn = (stats, prop, value) =>
+  // makes no senseto protect this for now
+  hasSubReturn(value) && (stats[prop][1] = value[RETURNS][1])
 export const setTypeToReturn = (stats, value) =>
   (isUnknownType(stats) || isAnyType(stats)) &&
   !isUnknownReturn(value) &&
@@ -230,6 +261,10 @@ export const setReturnToType = (stats, value) =>
 export const isAnyReturn = (stats) => stats && stats[RETURNS][0] === ANY
 export const isAnyType = (stats) => stats && stats[TYPE_PROP][0] === ANY
 export const isUnknownType = (stats) => stats && stats[TYPE_PROP][0] === UNKNOWN
+export const isUnknownProp = (stats, prop) => {
+  return stats && stats[prop][0] === UNKNOWN
+}
+
 export const isUnknownReturn = (stats) => stats[RETURNS][0] === UNKNOWN
 export const getType = (stats) => stats && stats[TYPE_PROP][0]
 export const getTypes = (stats) => stats && stats[TYPE_PROP]
@@ -239,12 +274,25 @@ export const getSubType = (stats) => stats && stats[TYPE_PROP][1]
 export const hasSubType = (stats) => stats && stats[TYPE_PROP][1] instanceof Set
 export const getSubReturn = (stats) => stats && stats[RETURNS][1]
 export const hasSubReturn = (stats) => stats && stats[RETURNS][1] instanceof Set
+export const isUknownSubReturn = (stats) =>
+  !hasSubReturn(stats) ||
+  (stats[RETURNS][1].size === 1 && stats[RETURNS][1].has(UNKNOWN))
+export const isUknownSubType = (stats) =>
+  hasSubType(stats) &&
+  stats[TYPE_PROP][1].size === 1 &&
+  stats[TYPE_PROP][1].has(UNKNOWN)
 export const isAtomType = (stats) =>
   isAnyType(stats) || stats[TYPE_PROP][0] === ATOM
 export const isAtomReturn = (stats) =>
   isAnyType(stats) || stats[RETURNS][0] === ATOM
-export const compareTypes = (a, b) =>
-  isAnyType(a) || isAnyType(b) || a[TYPE_PROP][0] === b[TYPE_PROP][0]
+export const compareTypes = (a, b) => {
+  const isAnyAny = isAnyType(a) || isAnyType(b)
+  if (isAnyAny) return true
+  const isSameType = a[TYPE_PROP][0] === b[TYPE_PROP][0]
+  if (!isSameType) return false
+  return true
+}
+
 export const compareReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
 export const compareTypeWithReturn = (a, b) =>
@@ -266,20 +314,28 @@ const notABooleanType = (a, b) => {
     getSubType(a).has(PREDICATE) &&
     !isUnknownType(b) &&
     !isAnyType(b) &&
-    (!isAtomType(b) ||
-      !hasSubType(b) ||
-      getSubType(a).difference(getSubType(b)).size !== 0)
+    (!hasSubType(b) || getSubType(a).difference(getSubType(b)).size !== 0)
   )
 }
+// const notABooleanReturn = (a, b) => {
+//   return (
+//     hasSubType(a) &&
+//     getSubType(a).has(PREDICATE) &&
+//     !isUnknownReturn(b) &&
+//     !isAnyReturn(b) &&
+//     (
+//       !isAtomReturn(b) ||
+//       !hasSubReturn(b) ||
+//       getSubType(a).difference(getSubReturn(b)).size !== 0)
+//   )
+// }
 const notABooleanReturn = (a, b) => {
   return (
     hasSubType(a) &&
     getSubType(a).has(PREDICATE) &&
     !isUnknownReturn(b) &&
     !isAnyReturn(b) &&
-    (!isAtomReturn(b) ||
-      !hasSubReturn(b) ||
-      getSubType(a).difference(getSubReturn(b)).size !== 0)
+    (!hasSubReturn(b) || getSubType(a).difference(getSubReturn(b)).size !== 0)
   )
 }
 const isAtomABoolean = (atom) => atom === TRUE || atom === FALSE
@@ -482,17 +538,154 @@ const resolveCondition = ({ rem, name, env, exp, prop }) => {
       break
   }
 }
+const resolveSetter = (first, rest, env) => {
+  if (
+    getSuffix(first[VALUE]) === MUTATION_SUFFIX &&
+    MUTATORS_SET.has(first[VALUE]) &&
+    rest[0] &&
+    isLeaf(rest[0]) &&
+    rest[0][TYPE] !== ATOM &&
+    env[rest[0][VALUE]]
+  ) {
+    const name = rest[0][VALUE]
+    const current = env[name]
+    const right = isLeaf(rest.at(-1)) ? rest.at(-1) : rest.at(-1)[0]
+    switch (right[TYPE]) {
+      case ATOM:
+        current[STATS][TYPE_PROP][1] = new Set([NUMBER])
+        break
+      case WORD:
+        if (env[right[VALUE]]) {
+          if (hasSubType(env[right[VALUE]][STATS]))
+            current[STATS][TYPE_PROP][1] = new Set(
+              getSubType(env[right[VALUE]][STATS])
+            )
+          else
+            current[STATS][TYPE_PROP][1] = new Set([
+              getType(env[right[VALUE]][STATS])
+            ])
+        }
+        break
+      case APPLY:
+        if (env[right[VALUE]]) {
+          if (right[VALUE] === KEYWORDS.CREATE_ARRAY) {
+            current[STATS][TYPE_PROP][1] = (initArrayType({
+              rem: rest.at(-1),
+              env
+            }) ?? { [RETURNS]: [COLLECTION, new Set([])] })[RETURNS][1]
+            break
+          }
+          if (hasSubReturn(env[right[VALUE]][STATS]))
+            current[STATS][TYPE_PROP][1] = new Set([
+              ...getSubReturn(env[right[VALUE]][STATS])
+            ])
+          else if (!isUnknownReturn(env[right[VALUE]][STATS]))
+            current[STATS][TYPE_PROP][1] = new Set([
+              getReturn(env[right[VALUE]][STATS])
+            ])
+        }
+        break
+    }
+    setTypeToCollection(current[STATS])
+  }
+}
+const resolveGetter = ({ rem, prop, name, env }) => {
+  const array = isLeaf(rem[1]) ? rem[1] : rem[1][0]
+  if (!env[array[VALUE]] || !env[name]) return true
+  switch (array[TYPE]) {
+    case APPLY:
+      if (hasSubType(env[array[VALUE]][STATS])) {
+        const rightSub = getSubReturn(env[array[VALUE]][STATS])
+        const isAtom = rightSub.has(NUMBER) || rightSub.has(PREDICATE)
+        const isCollection = rightSub.has(COLLECTION)
+        if (isAtom && !isCollection) {
+          setPropToAtom(env[name][STATS], prop)
+          setPropToSubReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
+        } else if (!isAtom && isCollection) {
+          setPropToReturn(env[name][STATS], env[array[VALUE]][STATS])
+        }
+      } else return false
+      break
+    case WORD:
+      {
+        if (hasSubType(env[array[VALUE]][STATS])) {
+          const rightSub = getSubType(env[array[VALUE]][STATS])
+          const isAtom =
+            rightSub.has(ATOM) ||
+            rightSub.has(NUMBER) ||
+            rightSub.has(PREDICATE)
+          const isCollection = rightSub.has(COLLECTION)
+          if (isAtom && !isCollection) {
+            setPropToAtom(env[name][STATS], prop)
+            setPropToSubType(env[name][STATS], prop, env[array[VALUE]][STATS])
+          } else if (!isAtom && isCollection) {
+            setPropToType(env[name][STATS], env[array[VALUE]][STATS])
+          }
+        } else return false
+      }
+      break
+  }
+  return true
+}
+const initArrayType = ({ rem, env }) => {
+  const ret = rem
+    .slice(1)
+    .map((x) =>
+      isLeaf(x)
+        ? x[TYPE] === WORD
+          ? env[x[VALUE]]
+            ? getTypes(env[x[VALUE]][STATS])
+            : [UNKNOWN]
+          : [x[TYPE]]
+        : env[x[0][VALUE]]
+        ? getReturns(env[x[0][VALUE]][STATS])
+        : [UNKNOWN]
+    )
+  const known = ret.find((x) => x[0] !== ANY && x[0] !== UNKNOWN)
+  if (
+    known &&
+    ret.length &&
+    !ret.some((x) => known[0] !== x[0] || known.length !== x.length)
+  ) {
+    const [main, sub] = ret[0]
+    return {
+      [TYPE_PROP]: [APPLY],
+      [RETURNS]: [COLLECTION, new Set(sub ? [...sub] : [main])]
+    }
+  }
+}
 const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
   if (returns[TYPE] === ATOM) {
     // ATOM ASSIGMENT
     setPropToAtom(env[name][STATS], prop)
   } else {
     switch (returns[VALUE]) {
+      case KEYWORDS.CREATE_ARRAY:
+        {
+          const r = initArrayType({ rem, env })
+          if (r) setPropToSubReturn(env[name][STATS], prop, r)
+        }
+        break
       case KEYWORDS.IF:
         resolveCondition({ rem, name, env, exp, prop })
         break
       default:
         {
+          if (
+            GETTERS_SET.has(returns[VALUE]) &&
+            !resolveGetter({ rem, prop, name, env })
+          )
+            return retry(env[name][STATS], stack, () => {
+              resolveRetunType({
+                returns,
+                rem,
+                stack,
+                prop,
+                exp,
+                name,
+                env
+              })
+            })
           checkPredicateNameDeep(name, exp, exp.slice(1), returns)
           if (!env[returns[VALUE]]) return false
           else if (getType(env[returns[VALUE]][STATS]) === APPLY) {
@@ -508,11 +701,6 @@ const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
                     env[name][STATS],
                     env[returns[VALUE]][STATS]
                   )
-                  // env[name][STATS][TYPE_PROP][0] =
-                  //   env[returns[VALUE]][STATS][RETURNS][0]
-                  // this seems to be able to be deleted
-                  // env[name][STATS][TYPE_PROP][1] =
-                  //   env[returns[VALUE]][STATS][RETURNS][1]
                 })
               else setReturnRef(env[name][STATS], env[returns[VALUE]][STATS])
             }
@@ -567,6 +755,8 @@ export const typeCheck = (ast) => {
         break
       case APPLY: {
         switch (first[VALUE]) {
+          // Var
+          // ---------------
           case KEYWORDS.DEFINE_VARIABLE:
             if (rest.length !== 2)
               throw new TypeError(
@@ -765,6 +955,7 @@ export const typeCheck = (ast) => {
           case STATIC_TYPES.ATOM:
           case STATIC_TYPES.PREDICATE:
           case STATIC_TYPES.ANY:
+          case STATIC_TYPES.NUMBER:
             {
               const ret = isLeaf(rest[0]) ? rest[0] : rest[0][0]
               const ref = env[ret[VALUE]]
@@ -778,6 +969,12 @@ export const typeCheck = (ast) => {
             }
             break
           default:
+            // Setters are just like DEFINE_VARIABLE as they are essentially the Var case for Collections
+            // So they MUST happen before Judgement
+            resolveSetter(first, rest, env)
+            // end of Var  ---------------
+
+            // Judgement
             stack.append(() => {
               if (!isSpecial && env[first[VALUE]] === undefined)
                 throw new TypeError(
@@ -915,7 +1112,6 @@ export const typeCheck = (ast) => {
                                 setReturnRef(env[name][STATS], args[i][STATS])
                               break
                           }
-
                         // TODO also handle casting
                       }
                     } else {
@@ -950,7 +1146,21 @@ export const typeCheck = (ast) => {
                                   getTypes(env[name][STATS])
                                 )}) (${stringifyArgs(exp)}) (check #202)`
                               )
-                            else setType(env[name][STATS], args[i][STATS])
+                            else {
+                              // TODO the special form will set type first but it
+                              // might be known already
+                              // example
+                              // (let xs [])
+                              // (let x (array:set-and-get! xs 0 100))
+                              // (length x)
+                              //
+                              // if (isUnknownType(env[name][STATS])) {
+                              //   retry(env[name][STATS], stack, () =>
+                              //     check(exp, env, scope)
+                              //   )
+                              // } else
+                              setType(env[name][STATS], args[i][STATS])
+                            }
                           }
                           break
                         case ATOM: {
@@ -1177,7 +1387,11 @@ export const typeCheck = (ast) => {
                     }
                   } else if (env[rest[i][0][VALUE]]) {
                     const match = () => {
-                      const actual = env[rest[i][0][VALUE]][STATS]
+                      const actual =
+                        rest[i][0][VALUE] === KEYWORDS.CREATE_ARRAY
+                          ? initArrayType({ rem: rest[i], env }) ??
+                            env[rest[i][0][VALUE]][STATS]
+                          : env[rest[i][0][VALUE]][STATS]
                       const expected = args[i][STATS]
                       retryArgs(args[i][STATS], stack, () => match())
                       if (!isUnknownType(expected) && !isUnknownReturn(actual))
@@ -1193,13 +1407,13 @@ export const typeCheck = (ast) => {
                           )
                         else if (notABooleanReturn(expected, actual)) {
                           throw new TypeError(
-                            `Incorrect type of argument (${i}) for special form (${
+                            `Incorrect type of argument (${i}) for (${
                               first[VALUE]
                             }). Expected (${formatSubType(
                               getTypes(expected)
                             )}) but got (${formatSubType(
                               getReturns(actual)
-                            )}) (${stringifyArgs(exp)}) (check #204)`
+                            )}) (${stringifyArgs(exp)}) (check #206)`
                           )
                         } else {
                           switch (getType(expected)) {
@@ -1331,47 +1545,6 @@ export const typeCheck = (ast) => {
                     }
                     match()
                   }
-                  // handly typehints for arrays
-                  // if (
-                  //   first[TYPE] === APPLY &&
-                  //   MUTATORS_SET.has(first[VALUE]) &&
-                  //   env[first[VALUE]]
-                  // ) {
-                  //   const current = env[rest[i][VALUE]]
-                  //   if (current) {
-                  //     if (rest[i][TYPE] === WORD) {
-                  //       if (!current[STATS][TYPE_PROP][1]) {
-                  //         current[STATS][TYPE_PROP][1] = new Set()
-                  //       }
-                  //       if (MULTI_DIMENTIONAL_SETTERS.has(first[VALUE])) {
-                  //         current[STATS][TYPE_PROP][1].add(COLLECTION)
-                  //       } else {
-                  //         const right = isLeaf(rest.at(-1))
-                  //           ? rest.at(-1)
-                  //           : rest.at(-1)[0]
-                  //         switch (right[TYPE]) {
-                  //           case ATOM:
-                  //             current[STATS][TYPE_PROP][1].add(ATOM)
-                  //             break
-                  //           case WORD:
-                  //             if (env[right[VALUE]]) {
-                  //               current[STATS][TYPE_PROP][1].add(
-                  //                 ...env[right[VALUE]][STATS][TYPE_PROP]
-                  //               )
-                  //             }
-                  //             break
-                  //           case APPLY:
-                  //             if (env[right[VALUE]])
-                  //               current[STATS][TYPE_PROP][1].add(
-                  //                 ...env[right[VALUE]][STATS][RETURNS]
-                  //               )
-                  //             break
-                  //         }
-                  //       }
-                  //     }
-                  //   }
-                  // }
-                  // handly typehints for arrays
                 }
               }
             })

package/src/compiler.js

@@ -275,6 +275,7 @@ const comp = (tree, Drill) => {
       case STATIC_TYPES.ATOM:
       case STATIC_TYPES.PREDICATE:
       case STATIC_TYPES.ANY:
+      case STATIC_TYPES.NUMBER:
       case DEBUG.ASSERT:
       case DEBUG.LOG:
       case DEBUG.STRING:

package/src/interpreter.js

@@ -837,6 +837,7 @@ export const keywords = {
   [STATIC_TYPES.ATOM]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.COLLECTION]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.PREDICATE]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.NUMBER]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.UNKNOWN]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.ANY]: (args, env) => evaluate(args[0], env)
 }

package/src/keywords.js

@@ -9,6 +9,7 @@ export const PLACEHOLDER = '.'
 export const MUTATION_SUFFIX = '!'
 export const PREDICATE_SUFFIX = '?'
 export const STATIC_TYPES = {
+  NUMBER: 'Number',
   ABSTRACTION: 'Abstraction',
   UNKNOWN: 'Unknown',
   ATOM: 'Atom',
@@ -99,8 +100,6 @@ export const PREDICATES_OUTPUT_SET = new Set([
 ])
 export const MUTATORS_SET = new Set([
   KEYWORDS.SET_ARRAY,
-  'set:with!',
-  'map:with!',
   'matrix:set!',
   'matrix:set-and-get!',
   'array:set-and-get!',
@@ -112,19 +111,19 @@ export const MUTATORS_SET = new Set([
   'array:set!',
   'array:append!',
   'array:push!',
-  'var:set!',
-  'array:merge!',
-  'list:merge!',
-  'list:concat!'
+  'var:set!'
 ])
-export const MULTI_DIMENTIONAL_SETTERS = new Set([
-  'set:with!',
-  'map:with!',
-  'matrix:set!',
+export const GETTERS_SET = new Set([
+  KEYWORDS.GET_ARRAY,
+  'matrix:get',
   'matrix:set-and-get!',
   'array:set-and-get!',
-  'set:add!',
-  'map:set!',
-  'list:merge!',
-  'list:concat!'
+  'var:set-and-get!',
+  'map:set-and-get!',
+  'set:add-and-get!',
+  'set:get',
+  'map:get',
+  'array:get',
+  'array:pop!',
+  'var:get'
 ])

package/src/types.js

@@ -30,6 +30,8 @@ export const NIL = 'nil'
 export const TRUE_WORD = 'true'
 export const FALSE_WORD = 'false'
 export const BOOLEAN_SUBTYPE = () => new Set([PREDICATE])
+export const COLLECTION_SUBTYPE = () => new Set([COLLECTION])
+export const NUMBER_SUBTYPE = () => new Set([NUMBER])
 
 export const toTypeNames = (type) => {
   switch (type) {
@@ -37,15 +39,16 @@ export const toTypeNames = (type) => {
       return 'Abstraction'
     case PREDICATE:
       return 'Boolean'
+    case ATOM:
     case NUMBER:
       return 'Number'
-    case ATOM:
-      return 'Atom'
+    // case ATOM:
+    //   return 'Atom'
     case UNKNOWN:
       return 'Unknown'
     case COLLECTION:
-      return 'Array'
-    // return '[]'
+      // return 'Array'
+      return '[Unknown]'
     case ANY:
       return 'Any'
     default:
@@ -60,6 +63,8 @@ export const toTypeNamesAnyToUknown = (type) => {
       return toTypeNames(type)
   }
 }
+export const GETTER = 1
+export const SETTER = 2
 export const SPECIAL_FORM_TYPES = {
   [SCOPE_NAME]: ';',
   // [ORDER]: 0,
@@ -128,6 +133,27 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
+  [STATIC_TYPES.NUMBER]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.NUMBER,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [UNKNOWN],
+            [RETURNS]: [UNKNOWN],
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
+    }
+  },
   [STATIC_TYPES.COLLECTION]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
@@ -718,6 +744,7 @@ export const SPECIAL_FORM_TYPES = {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.GET_ARRAY,
+      tag: GETTER,
       retried: Infinity,
       [ARG_COUNT]: 2,
       [ARGUMENTS]: [
@@ -750,6 +777,7 @@ export const SPECIAL_FORM_TYPES = {
   [KEYWORDS.SET_ARRAY]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
+      tag: SETTER,
       retried: Infinity,
       [ARG_COUNT]: 3,
       [ARGUMENTS]: [
@@ -1185,18 +1213,18 @@ export const SPECIAL_FORM_TYPES = {
 
 export const formatSubType = (T) => {
   switch (T[0]) {
-    // case COLLECTION:
-    //   return `[${
-    //     T[1] instanceof Set
-    //       ? [...T[1]]
-    //           .map((x) =>
-    //             x === COLLECTION
-    //               ? formatSubType([x])
-    //               : toTypeNamesAnyToUknown(x)
-    //           )
-    //           .join(' ')
-    //       : toTypeNamesAnyToUknown(ANY)
-    //   }]`
+    case COLLECTION:
+      return `[${
+        T[1] instanceof Set
+          ? [...T[1]]
+              .map((x) =>
+                x === COLLECTION
+                  ? formatSubType([x])
+                  : toTypeNamesAnyToUknown(x)
+              )
+              .join(' ')
+          : toTypeNamesAnyToUknown(ANY)
+      }]`
     case ATOM:
       return `${
         T[1] instanceof Set