# 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

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));

# an implementation for return
foo = lambda(return){
  println("foo");
  return("done");
  println("bar");
};

CallCC(foo);

# wrap CallCC
with-return = lambda(f) lambda()CallCC(f);

foo = with-return(lambda(return){
  println("foo2");
  return("done2");
  println("bar2");
});

foo();