feat: ✨ add _js_ keyword to run js code

Author: maxbarsukov

src/codegen/CompilerJS.js

@@ -46,6 +46,9 @@ export default class CompilerJS {
       case NodeTypes.CALL: {
         return this.jsCall(exp);
       }
+      case NodeTypes._JS_: {
+        return this.jsRaw(exp);
+      }
       default:
         throw new Error(`Cannot compile to JS ${JSON.stringify(exp)} at ${exp.line}:${exp.col}`);
     }
@@ -121,4 +124,8 @@ export default class CompilerJS {
   jsCall(exp) {
     return `${this.js(exp.func)}(${exp.args.map(this.js.bind(this)).join(', ')})`;
   }
+
+  jsRaw(exp) {
+    return `(${exp.code})`;
+  }
 }

src/parser/NodeTypes.js

@@ -12,6 +12,7 @@ const NodeTypes = {
   LET: 'let',
   NOT: 'not',
   DEFINE: 'define',
+  _JS_: '_js_',
 };
 
 export default NodeTypes;

src/parser/Parser.js

@@ -72,9 +72,7 @@ class Parser {
       if (hisPrec > myPrec) {
         this.tokens.next();
         const assigns = ['=', '*=', '**=', '+=', '-=', '/='];
-        const type = assigns.includes(tok.value)
-          ? NodeTypes.ASSIGN
-          : NodeTypes.BINARY;
+        const type = assigns.includes(tok.value) ? NodeTypes.ASSIGN : NodeTypes.BINARY;
         return this.maybeBinary(
           {
             type,
@@ -103,7 +101,8 @@ class Parser {
           col: right.col,
           args: [this.maybePipe(left)],
         };
-      } if (right.type === NodeTypes.CALL) {
+      }
+      if (right.type === NodeTypes.CALL) {
         return {
           type: NodeTypes.CALL,
           func: {
@@ -299,8 +298,10 @@ class Parser {
     if (left) {
       this.skipVar(left.value);
     } else {
-      this.tokens.croak('Parse Error', `Expecting variable name after ${variant === 'immutable'
-        ? 'def' : 'def mut'}`);
+      this.tokens.croak(
+        'Parse Error',
+        `Expecting variable name after ${variant === 'immutable' ? 'def' : 'def mut'}`
+      );
     }
     let right = {
       type: NodeTypes.NUM,
@@ -320,6 +321,20 @@ class Parser {
     };
   }
 
+  parseRaw() {
+    this.skipKeyword(Keywords._JS_);
+    if (this.tokens.peek().type !== NodeTypes.STR) {
+      this.tokens.croak(
+        'Parse Error',
+        '_JS_ raw code must be a plain string'
+      );
+    }
+    return {
+      type: NodeTypes._JS_,
+      code: this.tokens.next().value,
+    };
+  }
+
   parseAtom() {
     return this.maybeCall(() => {
       if (this.isPunc('(')) {
@@ -335,10 +350,13 @@ class Parser {
       if (this.isKeyword(Keywords.FN) || this.isKeyword(Keywords.FN_ARROW)) return this.parseFn();
       if (this.isKeyword(Keywords.DEF)) return this.parseDefine();
       if (this.isKeyword(Keywords.LET)) return this.parseLet();
+      if (this.isKeyword(Keywords._JS_)) return this.parseRaw();
       const tok = this.tokens.next();
-      if (tok.type === TokenTypes.VAR
+      if (
+        tok.type === TokenTypes.VAR
         || tok.type === TokenTypes.NUM
-        || tok.type === TokenTypes.STR) {
+        || tok.type === TokenTypes.STR
+      ) {
         return tok;
       }
       return this.unexpected();

src/runtime/Evaluator.js

@@ -10,6 +10,10 @@ export default function evaluate(exp, env, callback) {
       callback(exp.value);
       return;
     }
+    case NodeTypes._JS_: {
+      callback(eval(exp.code));
+      return;
+    }
     case NodeTypes.VAR: {
       callback(env.get(exp.value), exp);
       return;

src/stdlib/interpreter/StdEnvYAS.js

@@ -7,6 +7,7 @@ export default function stdEnv(ast) {
 def car = fn(cell) -> cell(fn(a, b) -> a);
 def cdr = fn(cell) -> cell(fn(a, b) -> b);
 def NIL = fn(f) -> f(NIL, NIL);
+def not = fn(x) -> if x then false else true;
 
 def foreach = fn(list, f) ->
   if list != NIL {

src/tokenizer/Keywords.js

@@ -11,6 +11,7 @@ const Keywords = {
   MUT: 'mut',
   FN_ARROW: 'fn->',
   DEF: 'def',
+  _JS_: '_js_',
 };
 
 export default Keywords;