auto update

Author: yjhmelody

bin/commit

@@ -1,4 +1,4 @@
-#!bash
+
 
 git add .
 git commit -m "auto update"

demo

@@ -95,4 +95,13 @@ let (x = 10) {
 };
 
 fib = λ(n) if n < 2 then n else fib(n - 1) + fib(n - 2);
-println(fib(22))
+println(fib(22));
+
+copyFile = lambda(source, dest){
+  writeFile(dest, readFile(source))
+};
+copyFile("demo", "demo2");
+
+
+println(1 + twice(2, 3));
+

demo2

@@ -0,0 +1,107 @@
+# ref: http://lisperator.net/pltut/eval1/play
+
+print_range = λ(a, b) if a <= b {
+                        println(a);
+                        if a + 1 <= b {
+                          print_range(a + 1, b);
+                        } 
+                        else 
+                          println("");
+                      };
+print_range(1, 10);
+
+cons = λ(a, b) λ(f) f(a, b);
+car = λ(cell) cell(λ(a, b) a);
+cdr = λ(cell) cell(λ(a, b) b);
+NIL = λ(f) f(NIL, NIL);
+
+x = cons(1, cons(2, cons(3, cons(4, cons(5, NIL)))));
+println(car(x));                      # 1
+println(car(cdr(x)));                 # 2
+println(car(cdr(cdr(x))));            # 3
+println(car(cdr(cdr(cdr(x)))));       # 4
+println(car(cdr(cdr(cdr(cdr(x))))));  # 5
+
+
+# code = fs-readFileSync("./demo");
+# println(code);
+# println(os-arch());
+
+add = lambda(a, b){
+  1;
+# return the last expression
+  a + b
+};
+println(add(100, 133));
+
+foreach = λ(list, f)
+            if list != NIL {
+              f(car(list));
+              foreach(cdr(list), f);
+            };
+foreach(x, println);
+
+range = λ(a, b)
+          if a <= b then cons(a, range(a + 1, b))
+                    else NIL;
+
+# print the squares of 1..8
+foreach(range(1, 8), λ(x) println(x * x));
+
+
+cons = λ(x, y)
+         λ(a, i, v)
+           if a == "get"
+              then if i == 0 then x else y
+              else if i == 0 then x = v else y = v;
+
+car = λ(cell) cell("get", 0);
+cdr = λ(cell) cell("get", 1);
+set-car! = λ(cell, val) cell("set", 0, val);
+set-cdr! = λ(cell, val) cell("set", 1, val);
+
+# NIL can be a real cons this time
+NIL = cons(0, 0);
+set-car!(NIL, NIL);
+set-cdr!(NIL, NIL);
+
+## test:
+x = cons(1, 2);
+println(car(x));
+println(cdr(x));
+set-car!(x, 10);
+set-cdr!(x, 20);
+println(car(x));
+println(cdr(x));
+
+
+## IIFE
+println(let loop (n = 100)
+          if n > 0 then n + loop(n - 1)
+                   else 0);
+
+let (x = 2, y = x + 1, z = x + y)
+  println(x + y + z);
+
+# errors out, the vars are bound to the let body
+# print(x + y + z);
+
+let (x = 10) {
+  let (x = x * 2, y = x * x) {
+    println(x);  ## 20
+    println(y);  ## 400
+  };
+  println(x);  ## 10
+};
+
+fib = λ(n) if n < 2 then n else fib(n - 1) + fib(n - 2);
+println(fib(22));
+
+copyFile = lambda(source, dest){
+  writeFile(dest, readFile(source))
+};
+copyFile("demo", "demo2");
+
+
+println(1 + twice(2, 3));
+

index.js

@@ -4,6 +4,8 @@ let InputStream = require('./src/InputStream')
 let TokenStream = require('./src/TokenStream')
 let parser = require('./src/parser')
 let Environment = require('./src/Environment')
+let Execute = Environment.Execute
+let evalute = Environment.evalute
 
 const fs = require('fs')
 const util = require('util')
@@ -18,4 +20,33 @@ globalEnv.def('println', (callack, value) => {
     callack(false)
 })
 
+globalEnv.def('sleep', (k, millisenconds) => {
+    setTimeout(() => {
+        Execute(k, [false])
+    }, millisenconds)
+})
+
+globalEnv.def('halt', (k) => {})
+
+globalEnv.def("readFile", function (k, filename) {
+    fs.readFile(filename, function (err, data) {
+        // error handling is a bit more complex, ignoring for now
+        Execute(k, [data]); // hope it's clear why we need the Execute
+    })
+})
+
+globalEnv.def("writeFile", function (k, filename, data) {
+    fs.writeFile(filename, data, function (err) {
+        Execute(k, [false]);
+    })
+})
+
+globalEnv.def("twice", function (k, a, b) {
+    console.log('1!!!!!', a)
+    k(a)
+    console.log('2!!!!!', b)    
+    k(b)
+})
+
+
 module.exports = globalEnv

package.json

@@ -1,6 +1,6 @@
 {
   "name": "implement-a-pl",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "compiler",
   "main": "index.js",
   "scripts": {

src/codeGen.js

@@ -0,0 +1,60 @@
+function makejs(expr) {
+    return js(expr)
+
+    function js(expr) {
+        switch (expr.type) {
+            case 'num':
+            case 'str':
+            case 'bool':
+                return jsAtom(expr)
+            case 'var':
+                return jsVar(expr)
+            case 'binary':
+                return jsBinary(expr)
+            case 'assign':
+                return jsAssign(expr)
+            case 'let':
+                return jsLet(expr)
+            case 'lambda':
+                return jsLambda(expr)
+            case 'if':
+                return jsIf(expr)
+            case 'prog':
+                return jsProg(expr)
+            case 'call':
+                return jsCall(expr)
+            default:
+                throw new SyntaxError('cannot make js for ', JSON.stringify(expr))
+        }
+    }
+
+    function jsAtom(expr){
+        return JSON.stringify(expr.value)
+    }
+
+    function makeVar(name){
+        return name
+    }
+
+    function jsVar(expr){
+        return makeVar(expr.value)
+    }
+
+    function jsBinary(expr){
+        return '(' + js(expr.left) + expr.operator + js(expr.right) + ')'
+    }
+
+    function jsAssign(expr){
+        return jsBinary(expr)
+    }
+
+    function jsLambda(expr){
+        let code = '(function '
+        if(expr.name){
+            code += makeVar(expr.name)
+        }
+        code += '(' + expr.vars.map(makeVar).join(', ') + ') {'
+        code += 'return ' + js(expr.body) + '})'
+        return code
+    }
+}