Started a real clojure core, written just in clojure, and now read it

into environment on start

Author: Tko1

src/clojure/core.clj

@@ -0,0 +1,12 @@
+(def list (fn [& ls] ls))
+
+(defmacro defn [name args & body]
+  (list (quote def) name 
+        (list (quote fn) args 
+              (concat (list (quote do)) body))))
+
+(defn apply [f args]
+  (lexical-eval (concat (list f) args)))
+
+(defn println [& more]
+  (print-string (apply str more)))

src/main.rs

@@ -12,6 +12,7 @@ mod lambda;
 mod reader;
 mod persistent_list;
 mod persistent_vector;
+mod repl;
 
 use environment::Environment;
 
@@ -29,15 +30,25 @@ use crate::persistent_list::{PersistentList,ToPersistentList};
 use crate::persistent_vector::{PersistentVector,ToPersistentVector};
 use crate::value::Value;
 
+use nom::Err::Incomplete;
+use nom::error::convert_error;
+use nom::Needed::Size;
+
+
 fn main()
 {
+    println!("Clojure RS 0.0.1");
+    
     // Register our macros / functions ahead of time
     let add_fn = rust_core::AddFn{};
     let str_fn = rust_core::StrFn{};
     let do_fn = rust_core::DoFn{};
     let nth_fn = rust_core::NthFn{};
     let do_macro = rust_core::DoMacro{};
     let concat_fn = rust_core::ConcatFn{};
+    let print_string_fn = rust_core::PrintStringFn{};
+    // Hardcoded fns
+    let lexical_eval_fn = Value::LexicalEvalFn{};
     // Hardcoded macros
     let let_macro = Value::LetMacro{};
     let quote_macro = Value::QuoteMacro{};
@@ -59,24 +70,38 @@ fn main()
     environment.insert(Symbol::intern("fn"),fn_macro.to_rc_value());
     environment.insert(Symbol::intern("defmacro"),defmacro_macro.to_rc_value());
     environment.insert(Symbol::intern("eval"),eval_fn.to_rc_value());
+    environment.insert(Symbol::intern("lexical-eval"),lexical_eval_fn.to_rc_value());
     environment.insert(Symbol::intern("nth"),nth_fn.to_rc_value());
     environment.insert(Symbol::intern("concat"),concat_fn.to_rc_value());
+    environment.insert(Symbol::intern("print-string"),print_string_fn.to_rc_value());
+    //
+    // Read in clojure.core 
+    //
+    repl::try_eval_file(&environment,"./src/clojure/core.clj");
     //
     // Start repl 
     //
     let stdin = io::stdin();
     print!("user=> ");
+    let mut remaining_input_buffer = String::from("");
     for line in stdin.lock().lines() {
 	let line = line.unwrap();
-	let mut remaining_input = line.as_bytes();
+	remaining_input_buffer.push_str(&line);
+	let mut remaining_input_bytes = remaining_input_buffer.as_bytes();
 	loop {
-	    let next_read_parse = reader::try_read(remaining_input);
+	    let next_read_parse = reader::try_read(remaining_input_bytes);
 	    match next_read_parse {
-		Ok((_remaining_input,value)) => {
+		Ok((_remaining_input_bytes,value)) => {
 		    print!("{} ",value.eval(Rc::clone(&environment)).to_string_explicit());
-		    remaining_input = _remaining_input;
+		    remaining_input_bytes = _remaining_input_bytes;
+		},
+		Err(Incomplete(_)) => {
+		    remaining_input_buffer = String::from_utf8(remaining_input_bytes.to_vec()).unwrap();
+		    break;
 		},
-		_ => {
+		err => {
+		    print!("{}",Value::Condition(format!("Reader Error: {:?}",err)));
+		    remaining_input_buffer = String::from("");
 		    break;
 		}
 	    }

src/repl.rs

@@ -0,0 +1,55 @@
+use std::fs::File;
+use std::io::{self,Read};
+use std::str::FromStr;
+use std::io::BufRead;
+use std::io::BufReader;
+
+use crate::reader;
+use crate::environment::Environment;
+use crate::value::Value;
+use crate::value::Evaluable;
+use std::rc::Rc;
+
+use nom::Err::Incomplete;
+use nom::error::convert_error;
+use nom::Needed::Size;
+
+//
+// Will possibly just add this to our environment, or turn this into a parallel of clojure.lang.RT 
+//
+
+pub fn try_eval_file(environment: &Rc<Environment>,filepath: &str) -> Result<(),io::Error>{
+    let core = File::open(filepath)?;
+
+    
+    let reader = BufReader::new(core);
+
+    let mut remaining_input_buffer = String::from("");
+    for line in reader.lines() {
+	let line = line?;
+	remaining_input_buffer.push_str(&line);
+	let mut remaining_input_bytes = remaining_input_buffer.as_bytes();
+	loop {
+	    let next_read_parse = reader::try_read(remaining_input_bytes);
+	    match next_read_parse {
+		Ok((_remaining_input,value)) => {
+		    //print!("{} ",value.eval(Rc::clone(&environment)).to_string_explicit());
+		    value.eval(Rc::clone(&environment));
+		    remaining_input_bytes = _remaining_input;
+		},
+		Err(Incomplete(Size(1))) => {
+		    remaining_input_buffer = String::from_utf8(remaining_input_bytes.to_vec()).unwrap();
+		    break;
+		},
+		err => {
+		    println!("Error evaluating file {}; {}",filepath,Value::Condition(format!("Reader Error: {:?}",err)));
+		    remaining_input_buffer = String::from("");
+		    break;
+		}
+	    }
+	}
+    }
+
+    Ok(())
+    
+}

src/rust_core.rs

@@ -237,3 +237,23 @@ impl IFn for ConcatFn {
 	Value::PersistentList(concatted_vec.into_iter().collect::<PersistentList>())
     }
 }
+
+/// Primitive printing function;
+/// (defn print-string [string] .. prints single string .. ) 
+#[derive(Debug,Clone)]
+pub struct PrintStringFn {
+}
+impl ToValue for PrintStringFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for PrintStringFn {
+    fn invoke(&self,args: Vec<&Value>) -> Value {
+	if args.len() != 1 {
+	    return Value::Condition(format!("Wrong number of arguments given to function (Given: {}, Expected: {})",args.len(),args.len()));
+	}
+	println!("{}",args.get(0).unwrap().to_string());
+	Value::Nil 
+    }
+}