build: separate bin/lib targets

src/bin/demo.rs

@@ -0,0 +1,37 @@
+use lispers::lisp::{eval, Environment};
+use lispers::parser::ExpressionStream;
+
+fn main() {
+    let programs = [
+        "((lambda (x y) (+ (if (< x 10) (* x 11) x) y)) 2 20)",
+        "(set 'myvar \"hello world!\")",
+        "(print myvar) (print 'myvar)",
+        "(car (cons 'a 'b)) (cdr (cons 'c 'd)) (cons 'a 'b)",
+        "(eval (car (cons 'myvar 'b)))",
+        "(set 'pow (lambda (a b) (if (= b 0) 1 (* a (pow a (- b 1))))))",
+        "pow",
+        "(pow 2 10)",
+        "(let '((fib . (lambda (n) (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2))))))) (fib 10))",
+        "(let '((a . (vec3 1 2 3)) (b . (vec3 4 5 6))) (vec3-dot (vec3-norm (vec3-add a b)) a))",
+    ];
+
+    let environment = Environment::default();
+
+    for r in ExpressionStream::from_char_stream(programs.iter().map(|p| p.chars()).flatten()) {
+        match r {
+            Err(err) => {
+                println!("ParserError: {:?}", err);
+                break;
+            }
+            Ok(expr) => {
+                println!("Evaluating: {}", expr.clone());
+                match eval(&environment, expr) {
+                    Ok(e) => println!("=> {}", e),
+                    Err(e) => println!("Error: {}", e),
+                }
+            }
+        }
+    }
+
+    println!("Interpreter Done!");
+}

src/bin/repl.rs

@@ -0,0 +1,34 @@
+use lispers::lisp::Expression;
+use lispers::parser::ParserError;
+
+use lispers::{lisp, parser};
+use std::io::Write;
+
+fn main() {
+    let env = lisp::Environment::default();
+
+    loop {
+        print!("> ");
+        std::io::stdout().flush().unwrap();
+
+        let mut input = String::new();
+        if std::io::stdin().read_line(&mut input).unwrap() == 0 {
+            println!("Exiting REPL...");
+            break;
+        }
+
+        match parser::ExpressionStream::from_char_stream(input.chars())
+            .collect::<Result<Vec<Expression>, ParserError>>()
+        {
+            Err(e) => println!("Parser Error: {:?}", e),
+            Ok(exprs) => {
+                for expr in exprs {
+                    match lisp::eval(&env, expr) {
+                        Err(e) => println!("Eval Error: {}", e),
+                        Ok(val) => println!("{}", val),
+                    }
+                }
+            }
+        }
+    }
+}