fez-lisp 1.6.76 → 1.6.80

package/src/types.js

@@ -58,6 +58,9 @@ export class SubType {
   has(type) {
     return this.types[0] === type
   }
+  nestedLevels() {
+    return this.types.length - 1
+  }
   isMatching(b) {
     for (let i = 0; i < this.types.length; ++i) {
       if (
@@ -66,7 +69,9 @@ export class SubType {
         this.types[i] === UNKNOWN ||
         b.types[i] === UNKNOWN ||
         this.types[i] === ANY ||
-        b.types[i] === ANY
+        b.types[i] === ANY ||
+        this.types[i] === GENERIC ||
+        b.types[i] === GENERIC
       )
         return true
       if (this.types[i] !== b.types[i]) return false
@@ -83,6 +88,7 @@ export class SubType {
 export const BOOLEAN_SUBTYPE = () => new SubType([BOOLEAN])
 export const COLLECTION_SUBTYPE = () => new SubType([COLLECTION])
 export const NUMBER_SUBTYPE = () => new SubType([NUMBER])
+export const GENERIC_SUBTYPE = () => new SubType([GENERIC])
 export const ABSTRACTION_SUBTYPE = () => new SubType([APPLY])
 export const UNKNOWN_SUBTYPE = () => new SubType([UNKNOWN])
 
@@ -106,6 +112,8 @@ export const toTypeNames = (type) => {
       return 'Unknown[]'
     case ANY:
       return 'Any'
+    case GENERIC:
+    // return 'T'
     default:
       return 'Unknown'
   }
@@ -113,10 +121,10 @@ export const toTypeNames = (type) => {
 
 export const extractArrayType = (type) => {
   const arr = [...type].filter((x) => x === '[')
-  return [type.split('[')[0], arr.length]
+  return [type.replaceAll('[]', ''), arr.length]
 }
 const fillArrayType = (n) => Array.from({ length: n - 1 }).fill(COLLECTION)
-export const toTypeCodes = (type) => {
+export const toTypeCodes = (type, i) => {
   const [t, n] = extractArrayType(type)
   switch (t) {
     case 'Abstraction':
@@ -136,8 +144,16 @@ export const toTypeCodes = (type) => {
       return [UNKNOWN]
     case 'Any':
       return [ANY]
-    default:
-      break
+    default: {
+      const d = type[0] === '[' ? -1 : 1
+      if (n)
+        return [
+          COLLECTION,
+          new SubType(fillArrayType(n).concat(UNKNOWN)),
+          [i, d]
+        ]
+      return [UNKNOWN, undefined, [i, d]]
+    }
   }
 }
 export const toTypeNamesAnyToUknown = (type) => {
@@ -1492,7 +1508,7 @@ export const toArgType = (A, i) => {
         [IS_ARGUMENT]: true,
         [SIGNATURE]: PLACEHOLDER,
         [TYPE_PROP]: [APPLY],
-        [RETURNS]: toTypeCodes(returns[VALUE]),
+        [RETURNS]: toTypeCodes(returns[VALUE], i),
         [ARGUMENTS]: args.map(toArgType).flat(1),
         [ARG_COUNT]: args.length
       }
@@ -1504,8 +1520,8 @@ export const toArgType = (A, i) => {
         retried: Infinity,
         [IS_ARGUMENT]: true,
         [SIGNATURE]: PLACEHOLDER,
-        [TYPE_PROP]: toTypeCodes(arg[VALUE]),
-        [RETURNS]: toTypeCodes(arg[VALUE]),
+        [TYPE_PROP]: toTypeCodes(arg[VALUE], i),
+        [RETURNS]: toTypeCodes(arg[VALUE], i),
         [ARGUMENTS]: [],
         [ARG_COUNT]: 0
       }
@@ -1525,7 +1541,15 @@ export const fromSourceToType = (T) => {
         [SIGNATURE]: name,
         [ARG_COUNT]: args.length,
         [ARGUMENTS]: args.map(toArgType).flat(1),
-        [RETURNS]: toTypeCodes(returns[VALUE])
+        [RETURNS]: toTypeCodes(
+          returns[VALUE],
+          args.findIndex(
+            (x) =>
+              !Array.isArray(x[VALUE]) &&
+              x[VALUE] ===
+                returns[VALUE].replaceAll('[', '').replaceAll(']', '')
+          )
+        )
       }
     }
   }
@@ -1541,9 +1565,9 @@ export const withStdDefinedTypes = (ast) =>
   withCtxTypes(definedTypes(filteredDefinedTypes(ast, std, stdT)))
 
 export const extractTypes = (source) => {
-  let types
+  let types = ''
   const src = source.replaceAll(/\(the.+\)/g, (match, token) => {
-    types = match
+    types += match + '\n'
     return ''
   })
   return [src, types]

package/src/utils.js

@@ -389,42 +389,63 @@ export const init = () => {
     // console.log('Added file types.lisp in src')
     writeFileSync(
       'index.js',
-      `import { compile, enhance, parse, LISP, UTILS } from "fez-lisp";
-import { readFileSync, writeFileSync } from "fs";
-export const dev = (source, types) => {
-  try {
-    const parsed = parse(source);
-    const { evaluated, type, error } = UTILS.debug(
-      parsed,
-      true,
-      types ? types : undefined
-    );
-    if (error == null) {
-      if (type) {
-        UTILS.logType(type);
+      `import { compile, enhance, parse, LISP, UTILS, verify } from '../index.js'
+      import { readFileSync, writeFileSync } from 'fs'
+      export const dev = (source, types) => {
+        try {
+          const parsed = parse(source)
+          const { evaluated, type, error } = UTILS.debug(parsed, true, types)
+          if (error == null) {
+            if (type) {
+              UTILS.logType(type)
+            }
+            UTILS.logResult(LISP.serialise(evaluated))
+          } else UTILS.logError(error.message)
+        } catch (error) {
+          UTILS.logError(error.message)
+        }
       }
-      UTILS.logResult(LISP.serialise(evaluated));
-    } else UTILS.logError(error.message);
-  } catch (error) {
-    UTILS.logError(error.message);
-  }
-};
-export const comp = (source) => compile(enhance(parse(source)));
-const file = readFileSync("./src/main.lisp", "utf-8");
-const [src, typ] = UTILS.extractTypes(file);
-switch (process.argv[2]) {
-  case "comp":
-    writeFileSync(
-      "./src/main.js",
-      "var _ = " + comp(src) + "; console.log(_)"
-    );
-    break;
-  case "dev":
-  default:
-    dev(src, typ);
-    break;
-}
-`
+      export const run = (source) => {
+        try {
+          const parsed = parse(source)
+          const { evaluated, error } = UTILS.debug(parsed, false)
+          if (error == null) {
+            UTILS.logResult(LISP.serialise(evaluated))
+          } else UTILS.logError(error.message)
+        } catch (error) {
+          UTILS.logError(error.message)
+        }
+      }
+      export const check = (source, types) => {
+        try {
+          const parsed = parse(source)
+          const error = verify(parsed, types)
+          if (error != null) UTILS.logError(error)
+        } catch (error) {
+          UTILS.logError(error.message)
+        }
+      }
+      export const comp = (source) => compile(enhance(parse(source)))
+      const file = readFileSync('./src/main.lisp', 'utf-8')
+      const [src, typ] = UTILS.extractTypes(file)
+      switch (process.argv[2]) {
+        case 'check':
+          check(src, typ)
+          break
+        case 'run':
+          run(src, typ)
+          break
+        case 'comp':
+          writeFileSync(
+            './src/main.js',
+            'var _ = ' + comp(src) + '; console.log(_)'
+          )
+          break
+        case 'dev':
+        default:
+          dev(src, typ)
+          break
+      }`
     )
     console.log('Added file index.js in root')
     console.log(
@@ -432,6 +453,8 @@ switch (process.argv[2]) {
 
 Write code in main.lisp
 Run node index.js with the following flags:
+- check (static type check)
+- run (run time validations)
 - dev (static type check and run time validations)
 - comp (compile Fez to JavaScript file main.js)
 
@@ -645,3 +668,23 @@ export const toTypedAst = (ast, userDefinedTypes) => {
   }
 }
 export const atst = (ast, ctx) => toTypedAst(ast, ctx)[0]
+
+export const verify = (ast, userDefinedTypes) => {
+  try {
+    typeCheck(
+      ast,
+      withCtxTypes(
+        userDefinedTypes
+          ? {
+              ...definedTypes(filteredDefinedTypes(ast, std, stdT)),
+              ...definedTypes(LISP.parse(removeNoCode(userDefinedTypes)))
+            }
+          : definedTypes(filteredDefinedTypes(ast, std, stdT))
+      )
+    )
+    return null
+  } catch (error) {
+    // console.log(error)
+    return error.message
+  }
+}