fez-lisp 1.1.9 → 1.1.10

package/package.json

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

package/src/compiler.js

@@ -239,7 +239,7 @@ const compile = (tree, Drill) => {
           Drill.Variables.add(name)
           Drill.Variables.add(newName)
           Drill.Helpers.add('__tco')
-          const functionArgs = Arguments[1].slice(1)
+          const functionArgs = val.slice(1)
           const body = functionArgs.pop()
           const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
           deepRename(arg[VALUE], newName, body)
@@ -263,8 +263,6 @@ const compile = (tree, Drill) => {
         return `(${parseArgs(Arguments, Drill, '&&')});`
       case KEYWORDS.OR:
         return `((${parseArgs(Arguments, Drill, '||')}) || 0);`
-      case KEYWORDS.CONCATENATION:
-        return '(' + parseArgs(Arguments, Drill, '+') + ');'
       case KEYWORDS.EQUAL:
         return `+(${parseArgs(Arguments, Drill, '===')});`
       case KEYWORDS.GREATHER_THAN_OR_EQUAL:

package/src/ocaml.js

@@ -0,0 +1,373 @@
+import {
+  APPLY,
+  ATOM,
+  PLACEHOLDER,
+  KEYWORDS,
+  TYPE,
+  VALUE,
+  WORD
+} from './keywords.js'
+import { leaf, isLeaf } from './parser.js'
+import { deepRename } from './utils.js'
+const earMuffsToLodashes = (name) => name.replace(new RegExp(/\*/g), '_')
+const dotNamesToEmpty = (name) => name.replace(new RegExp(/\./g), '')
+const commaToLodash = (name) => name.replace(new RegExp(/\,/g), '_')
+const arrowFromTo = (name) => name.replace(new RegExp(/->/g), '-to-')
+const moduleNameToLodashes = (name) => name.replace(new RegExp(/:/g), '_')
+const questionMarkToPredicate = (name) =>
+  name.replace(new RegExp(/\?/g), 'Predicate')
+const exclamationMarkMarkToEffect = (name) =>
+  name.replace(new RegExp(/\!/g), 'Effect')
+const toCamelCase = (name) => {
+  let out = name[0]
+  for (let i = 1; i < name.length; ++i) {
+    const current = name[i],
+      prev = name[i - 1]
+    if (current === '-') continue
+    else if (prev === '-') out += current.toUpperCase()
+    else out += current
+  }
+  return out
+}
+const keywordToHelper = (name) => {
+  switch (name) {
+    case KEYWORDS.ADDITION:
+      return '__add'
+    case KEYWORDS.MULTIPLICATION:
+      return '__mult'
+    case KEYWORDS.SUBTRACTION:
+      return '__sub'
+    case KEYWORDS.GREATHER_THAN:
+      return '__gt'
+    case KEYWORDS.EQUAL:
+      return '__eq'
+    case KEYWORDS.GREATHER_THAN_OR_EQUAL:
+      return '__gteq'
+    case KEYWORDS.LESS_THAN:
+      return '__lt'
+    case KEYWORDS.LESS_THAN_OR_EQUAL:
+      return '__lteq'
+    default:
+      return name
+  }
+}
+const lispToJavaScriptVariableName = (name) =>
+  toCamelCase(
+    arrowFromTo(
+      dotNamesToEmpty(
+        exclamationMarkMarkToEffect(
+          questionMarkToPredicate(
+            commaToLodash(
+              moduleNameToLodashes(earMuffsToLodashes(keywordToHelper(name)))
+            )
+          )
+        )
+      )
+    )
+  )
+const Helpers = {
+  // __string: `__string=(...args)=>{const str=args.flat();str.isString=true;return str}`,
+  // __add: `__add=(...numbers)=>{return numbers.reduce((a,b)=>a+b,0)}`,
+  // __sub: `__sub=(...numbers)=>{return numbers.reduce((a,b)=>a-b,0)}`,
+  // __mult: `__mult=(...numbers)=>{return numbers.reduce((a,b)=>a*b,1)}`,
+  // __gteq: '__gteq=(a,b)=>+(a>=b)',
+  // __gt: '__gt=(a,b)=>+(a>b)',
+  // __eq: '__eq=(a,b)=>+(a===b)',
+  // __lteq: '__lteq=(a,b)=>+(a<=b)',
+  // __lt: '__lt=(a,b)=>+(a<b)',
+  // not: 'not=(a)=>+!a',
+  // and: `and=(...args)=>{
+  //   let circuit;
+  //   for(let i=0; i<args.length-1;++i){
+  //     circuit=args[i]
+  //     if(circuit) continue
+  //     else return circuit
+  //   }
+  //   return args.at(-1)
+  // }`,
+  // or: `or=(...args)=>{
+  //   let circuit;
+  //   for(let i=0;i<args.length-1;++i) {
+  //     circuit = args[i]
+  //     if(circuit)return circuit
+  //     else continue
+  //   }
+  //   return args.at(-1)
+  // }`,
+  // logEffect: `logEffect=(msg)=>{console.log(msg);return msg}`,
+  // clearEffect: `clearEffect=()=>{console.clear();return 0}`,
+  array_cons: `rec array_cons lists =
+  match lists with
+  | [] -> []
+  | hd::tl -> hd @ array_cons tl`,
+  car: 'car = fun (arr::_) -> arr',
+  cdr: 'cdr = fun (_::arr) -> arr',
+  array_get: `rec array_get = function
+  | [], _ -> raise (Failure "array_get")
+  | list, n when n < 0 -> array_get(list, List.length(list) - n)
+  | x::_, 0 -> x
+  | x::xs, n -> array_get(xs, n - 1)`,
+  length: 'length(arr)=float_of_int(List.length(arr))'
+  // numberPredicate: `numberPredicate=(number)=>+(typeof number==='number')`,
+  // lambdaPredicate: `lambdaPredicate=(lambda)=>+(typeof lambda==='function')`,
+  // arrayPredicate: `arrayPredicate=(array)=>+Array.isArray(array)`,
+  // error: `error=(error)=>{throw new Error(error)}`,
+  // array_setEffect: `array_setEffect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`
+  // array_setEffect: `array_setEffect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`
+}
+const semiColumnEdgeCases = new Set([
+  ';)',
+  ';-',
+  ';+',
+  ';*',
+  ';%',
+  ';&',
+  ';/',
+  ';:',
+  ';.',
+  ';=',
+  ';<',
+  ';>',
+  ';|',
+  ';,',
+  ';?',
+  ',,',
+  // ';;',
+  ';]'
+])
+const parse = (Arguments, Drill) => Arguments.map((x) => compile(x, Drill))
+const parseArgs = (Arguments, Drill, separator = ',') =>
+  parse(Arguments, Drill).join(separator)
+const compile = (tree, Drill) => {
+  if (!tree) return ''
+  const [first, ...Arguments] = !isLeaf(tree) ? tree : [tree]
+  if (first == undefined) return '[];'
+  const token = first[VALUE]
+  if (first[TYPE] === APPLY) {
+    switch (token) {
+      case KEYWORDS.BLOCK: {
+        if (Arguments.length > 1) {
+          return `(${Arguments.map((x) =>
+            (compile(x, Drill) ?? '').toString().trimStart().replace(';;', '')
+          )
+            .filter(Boolean)
+            .join(' in\n')})`
+        } else {
+          const res = compile(Arguments[0], Drill)
+          return res !== undefined ? res.toString().trim() : ''
+        }
+      }
+      case KEYWORDS.CALL_FUNCTION: {
+        const [first, ...rest] = Arguments
+        const apply = compile(first, Drill)
+        return `${
+          apply[apply.length - 1] === ';'
+            ? apply.substring(0, apply.length - 1)
+            : apply
+        }(${parseArgs(rest, Drill)})`
+      }
+      case KEYWORDS.DEFINE_VARIABLE: {
+        let name,
+          out = 'let '
+        if (Arguments[0][TYPE] === WORD) {
+          name = lispToJavaScriptVariableName(Arguments[0][VALUE])
+          Drill.Variables.add(name)
+        }
+        out += `${name} = ${compile(Arguments[1], Drill)}`
+        out += `;;`
+        return out
+      }
+      case KEYWORDS.IS_NUMBER:
+        Drill.Helpers.add('numberPredicate')
+        return `numberPredicate(${compile(Arguments[0], Drill)});`
+      case KEYWORDS.IS_FUNCTION:
+        Drill.Helpers.add('lambdaPredicate')
+        return `lambdaPredicate(${compile(Arguments[0], Drill)});`
+      case KEYWORDS.IS_ARRAY:
+        Drill.Helpers.add('arrayPredicate')
+        return `arrayPredicate(${compile(Arguments[0], Drill)});`
+      case KEYWORDS.NUMBER_TYPE:
+        return '0'
+      case KEYWORDS.BOOLEAN_TYPE:
+        return '1'
+      case KEYWORDS.STRING_TYPE:
+        Drill.Helpers.add('__string')
+        return `__string(${parseArgs(Arguments, Drill)});`
+      case KEYWORDS.ARRAY_TYPE:
+        return Arguments.length === 2 &&
+          Arguments[1][TYPE] === WORD &&
+          Arguments[1][VALUE] === 'length'
+          ? `(List.make ${compile(Arguments[0], Drill)} 0)`
+          : `[${parseArgs(Arguments, Drill, ';')}]`
+      case KEYWORDS.ARRAY_LENGTH:
+        Drill.Helpers.add('length')
+        return `length(${compile(Arguments[0], Drill)})`
+      case KEYWORDS.FIRST_ARRAY:
+        Drill.Helpers.add('car')
+        return `car(${compile(Arguments[0], Drill)})`
+      case KEYWORDS.REST_ARRAY:
+        Drill.Helpers.add('cdr')
+        return `cdr(${compile(Arguments[0], Drill)})`
+      case KEYWORDS.GET_ARRAY:
+        Drill.Helpers.add('array_get')
+        return `array_get(${compile(
+          Arguments[0],
+          Drill
+        )}, int_of_float(${compile(Arguments[1], Drill)}))`
+      case KEYWORDS.CONS:
+        Drill.Helpers.add('array_cons')
+        return `array_cons[${parseArgs(Arguments, Drill, ';')}]`
+      case KEYWORDS.ANONYMOUS_FUNCTION: {
+        const functionArgs = Arguments
+        const body = Arguments.pop()
+        const InnerDrills = { Variables: new Set(), Helpers: Drill.Helpers }
+        const evaluatedBody = compile(body, InnerDrills)
+        // const vars = InnerDrills.Variables.size
+        //   ? `let ${[...InnerDrills.Variables].join(',')};`
+        //   : ''
+        return `(fun (${parseArgs(
+          functionArgs.map((node, index) =>
+            node[VALUE] === PLACEHOLDER
+              ? leaf(node[TYPE], `_${index}`)
+              : leaf(node[TYPE], node[VALUE])
+          ),
+          InnerDrills
+        )}) -> ${evaluatedBody.toString().trimStart()})`
+      }
+      case KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION: {
+        const arg = Arguments[0]
+        const val = Arguments[1]
+        if (val[0][0] === APPLY && val[0][1] === KEYWORDS.ANONYMOUS_FUNCTION) {
+          const name = lispToJavaScriptVariableName(arg[VALUE])
+          const functionArgs = val.slice(1)
+          const body = functionArgs.pop()
+          const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
+          const evaluatedBody = compile(body, FunctionDrill)
+          return `let rec ${name} (${parseArgs(
+            functionArgs.map((node, index) =>
+              node[VALUE] === PLACEHOLDER
+                ? leaf(node[TYPE], `_${index}`)
+                : leaf(node[TYPE], node[VALUE])
+            )
+          )}) = ${evaluatedBody.toString().trimStart()};;`
+        }
+      }
+      case KEYWORDS.AND:
+        return `(${parseArgs(Arguments, Drill, '&&')})`
+      case KEYWORDS.OR:
+        return `((${parseArgs(Arguments, Drill, '||')}) || 0.0)`
+      case KEYWORDS.EQUAL:
+        return `(if ${parseArgs(Arguments, Drill, '==')} then 1.0 else 0.0)`
+      case KEYWORDS.GREATHER_THAN_OR_EQUAL:
+      case KEYWORDS.LESS_THAN_OR_EQUAL:
+      case KEYWORDS.GREATHER_THAN:
+      case KEYWORDS.LESS_THAN:
+        return `(if ${parseArgs(Arguments, Drill, token)} then 1.0 else 0.0)`
+      case KEYWORDS.SUBTRACTION:
+        return Arguments.length === 1
+          ? `(-.${compile(Arguments[0], Drill)})`
+          : `(${parse(Arguments, Drill)
+              // Add space so it doesn't consider it 2--1 but 2- -1
+              .map((x) => (typeof x === 'number' && x < 0 ? ` ${x}` : x))
+              .join(`${token}.`)})`
+      case KEYWORDS.MULTIPLICATION:
+        return Arguments.length
+          ? `(${parseArgs(Arguments, Drill, `${token}.`)})`
+          : `(1.0)`
+      case KEYWORDS.DIVISION:
+        return Arguments.length
+          ? Arguments.length === 1
+            ? `(1.0/.${compile(Arguments[0], Drill)})`
+            : `(${parseArgs(Arguments, Drill, `${token}.`)})`
+          : `(0.0)`
+      case KEYWORDS.ADDITION:
+        return Arguments.length
+          ? `(${parseArgs(Arguments, Drill, `${token}.`)})`
+          : `(0.0)`
+      case KEYWORDS.BITWISE_AND:
+      case KEYWORDS.BITWISE_OR:
+      case KEYWORDS.BITWISE_XOR:
+      case KEYWORDS.BITWISE_LEFT_SHIFT:
+      case KEYWORDS.BITWISE_RIGHT_SHIFT:
+      case KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT:
+        return `(${parseArgs(Arguments, Drill, token)})`
+      case KEYWORDS.REMAINDER_OF_DIVISION:
+        return `(mod_float ${compile(Arguments[0], Drill)} ${compile(
+          Arguments[1],
+          Drill
+        )})`
+      case KEYWORDS.BIT_TYPE:
+        return `(${compile(Arguments[0], Drill)}>>>0).toString(2)`
+      case KEYWORDS.BITWISE_NOT:
+        return `~(${compile(Arguments[0], Drill)})`
+      case KEYWORDS.NOT:
+        return `(if ${compile(Arguments[0], Drill)} == 0.0 then 1.0 else 0.0)`
+      case KEYWORDS.IF: {
+        return `(if ${compile(Arguments[0], Drill)} != 0.0 then ${compile(
+          Arguments[1],
+          Drill
+        )} else ${Arguments.length === 3 ? compile(Arguments[2], Drill) : 0})`
+      }
+      case KEYWORDS.CONDITION: {
+        let out = ''
+        for (let i = 0; i < Arguments.length; i += 2)
+          out += `(if ${compile(Arguments[i], Drill)} != 0.0 then ${compile(
+            Arguments[i + 1],
+            Drill
+          )} else `
+        out += '0.0)'
+        return out
+      }
+      // case KEYWORDS.PIPE: {
+      //   let inp = Arguments[0]
+      //   for (let i = 1; i < Arguments.length; ++i)
+      //     inp = [Arguments[i].shift(), inp, ...Arguments[i]]
+      //   return compile(inp, Drill)
+      // }
+      case KEYWORDS.IMMUTABLE_FUNCTION: {
+        const [first, ...rest] = Arguments
+        return compile([leaf(APPLY, first[VALUE]), ...rest], Drill)
+      }
+      case KEYWORDS.NOT_COMPILED_BLOCK:
+      case KEYWORDS.TEST_CASE:
+      case KEYWORDS.TEST_BED:
+      case KEYWORDS.DOC:
+        return ''
+      default: {
+        const camelCased = lispToJavaScriptVariableName(token)
+        if (camelCased in Helpers) Drill.Helpers.add(camelCased)
+        return `${camelCased}(${parseArgs(Arguments, Drill)})`
+      }
+    }
+  } else if (first[TYPE] === ATOM)
+    return Number.isInteger(first[TYPE])
+      ? `${first[VALUE]}.0`
+      : first[VALUE].toString()
+  else if (first[TYPE] === WORD) {
+    const camelCased = lispToJavaScriptVariableName(token)
+    if (camelCased in Helpers) Drill.Helpers.add(camelCased)
+    return camelCased
+  }
+}
+const HelpersEntries = new Map(Object.entries(Helpers))
+export const comp = (ast) => {
+  const Drill = { Variables: new Set(), Helpers: new Set() }
+  const raw = ast
+    .map((tree) => compile(tree, Drill))
+    .filter(Boolean)
+    .join('\n')
+  let program = ''
+  for (let i = 0; i < raw.length; ++i) {
+    const current = raw[i]
+    const next = raw[i + 1]
+    if (!semiColumnEdgeCases.has(current + next)) program += current
+  }
+  const help = Drill.Helpers.size
+    ? `${[...Drill.Helpers.keys()]
+        .map((x) => `let ${HelpersEntries.get(x)};;`)
+        .join('\n')}\n`
+    : ''
+
+  const top = `${help}`
+  return { top, program }
+}

package/src/utils.js

@@ -1,5 +1,7 @@
 import std from '../lib/baked/std.js'
-import { comp } from './compiler.js'
+import { comp as JavaScript } from './compiler.js'
+import { comp as OCaml } from './ocaml.js'
+
 import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
 import { run } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
@@ -178,8 +180,16 @@ export const fez = (source, options = {}) => {
         )
       const ast = [...treeShake(parsed, std), ...parsed]
       if (options.compile) {
-        const js = Object.values(comp(deepClone(ast))).join('')
-        return options.eval ? eval(js) : js
+        switch (options.compile) {
+          case 1: {
+            const js = Object.values(JavaScript(deepClone(ast))).join('')
+            return options.eval ? eval(js) : js
+          }
+          case 2: {
+            const oCaml = Object.values(OCaml(deepClone(ast))).join('')
+            return oCaml
+          }
+        }
       }
       return run(ast, env)
     } else if (Array.isArray(source)) {
@@ -187,8 +197,16 @@ export const fez = (source, options = {}) => {
         ? AST.parse(AST.stringify(source).replace(new RegExp(/!/g), 'ǃ'))
         : source
       if (options.compile) {
-        const js = Object.values(comp(deepClone(ast))).join('')
-        return options.eval ? eval(js) : js
+        switch (options.compile) {
+          case 1: {
+            const js = Object.values(JavaScript(deepClone(ast))).join('')
+            return options.eval ? eval(js) : js
+          }
+          case 2: {
+            const OCaml = Object.values(OCaml(deepClone(ast))).join('')
+            return OCaml
+          }
+        }
       }
       return run(ast, env)
     } else {