Refactor repl as proper read / eval / print / loop (and fixed

multiline errors)

Author: Tko1

src/environment.rs

@@ -1,5 +1,6 @@
 use crate::namespace::{Namespace, Namespaces};
 use crate::repl;
+use crate::repl::Repl;
 use crate::rust_core;
 use crate::symbol::Symbol;
 use crate::value::{ToValue, Value};
@@ -121,7 +122,8 @@ impl Environment {
         //
         // Read in clojure.core
         //
-        let _ = repl::try_eval_file(&environment, "./src/clojure/core.clj");
+        // @TODO its time for a RT (runtime), which environment seems to be becoming
+        let _ = Repl::new(Rc::clone(&environment)).try_eval_file("./src/clojure/core.clj");
 
         environment
     }

src/main.rs

@@ -20,5 +20,6 @@ fn main() {
     //
     // Start repl
     //
-    repl::repl();
+    let repl = repl::Repl::default();
+    repl.run();
 }

src/reader.rs

@@ -8,7 +8,10 @@
 //! not;  since this is about being a 'free-er' Clojure, especially since it can't compete with it in raw
 //! power, neither speed or ecosystem,  it might be worth it to leave in reader macros.
 
-use nom::{branch::alt, bytes::complete::tag, map, sequence::preceded, take_until, terminated, IResult, Needed};
+use nom::{
+    branch::alt, bytes::complete::tag, map, sequence::preceded, take_until, terminated,
+    Err::Incomplete, IResult, Needed,
+};
 
 use crate::maps::MapEntry;
 use crate::persistent_list::ToPersistentList;
@@ -18,6 +21,7 @@ use crate::symbol::Symbol;
 use crate::value::{ToValue, Value};
 use std::rc::Rc;
 
+use std::io::BufRead;
 //
 // Note; the difference between ours 'parsers'
 //   identifier_parser
@@ -317,6 +321,37 @@ pub fn debug_try_read(input: &str) -> IResult<&str, Value> {
     reading
 }
 
+// This is the high level read function that Clojure RS wraps
+pub fn read<R: BufRead>(reader: &mut R) -> Value {
+    // This is a buffer that will accumulate if a read requires more
+    // text to make sense, such as trying to read (+ 1
+    let mut input_buffer = String::new();
+
+    // Ask for a line from the reader, try to read, and if unable (because we need more text),
+    // loop over and ask for more lines, accumulating them in input_buffer until we can read
+    loop {
+        let maybe_line = reader.by_ref().lines().next();
+        match maybe_line {
+            Some(Err(e)) => return Value::Condition(format!("Reader error: {}", e)),
+            Some(Ok(line)) => input_buffer.push_str(&line),
+            None => return Value::Condition(format!("Tried to read empty stream; unexpected EOF")),
+        }
+
+        let line_read = try_read(&input_buffer);
+        match line_read {
+            Ok((_, value)) => return value,
+            // Continue accumulating more input
+            Err(Incomplete(_)) => continue,
+            Err(err) => {
+                return Value::Condition(format!(
+                    "Reader Error: could not read next form; {:?}",
+                    err
+                ))
+            }
+        }
+    }
+}
+
 /// Consumes any whitespace from input, if there is any.
 /// Always succeeds.
 ///

src/repl.rs

@@ -2,6 +2,7 @@ use std::fs::File;
 use std::io;
 use std::io::BufRead;
 use std::io::BufReader;
+use std::io::Read;
 use std::io::Write;
 
 use crate::environment::Environment;
@@ -11,86 +12,81 @@ use crate::value::Value;
 use std::rc::Rc;
 
 use nom::Err::Incomplete;
+use nom::IResult;
 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);
+pub struct Repl {
+    environment: Rc<Environment>,
+}
+impl Repl {
+    pub fn new(environment: Rc<Environment>) -> Repl {
+        Repl { environment }
+    }
 
-    let mut input_buffer = String::new();
+    // @TODO reconsider eval's signature;  since Value wraps all evaluables,  it might make more sense
+    // to frame eval as "environment.eval(value)", and then likewise define a
+    // 'repl.eval(value)', rather than 'value.eval(environment)'
+    pub fn eval(&self, value: &Value) -> Value {
+        value.eval(Rc::clone(&self.environment))
+    }
 
-    for line in reader.lines() {
-        let line = line?;
-        input_buffer.push_str(&line);
-        let mut remaining_input = input_buffer.as_str();
-        loop {
-            let next_read_parse = reader::try_read(remaining_input);
-            match next_read_parse {
-                Ok((_remaining_input, value)) => {
-                    //print!("{} ",value.eval(Rc::clone(&environment)).to_string_explicit());
-                    value.eval(Rc::clone(&environment));
-                    remaining_input = _remaining_input;
-                }
-                Err(Incomplete(Size(1))) => {
-                    break;
-                }
-                err => {
-                    println!(
-                        "Error evaluating file {}; {}",
-                        filepath,
-                        Value::Condition(format!("Reader Error: {:?}", err))
-                    );
-                    input_buffer.clear();
-                    // remaining_input = "";
-                    break;
-                }
-            }
-        }
+    // Just wraps reader's read
+    pub fn read<R: BufRead>(reader: &mut R) -> Value {
+        reader::read(reader)
     }
+    pub fn run(&self) {
+        let stdin = io::stdin();
+        let mut stdin_reader = stdin.lock();
 
-    Ok(())
-}
-// @TODO eventually, this will likely be implemented purely in Clojure
-/// Starts an entirely new session of Clojure RS
-pub fn repl() {
-    println!("Clojure RS 0.0.1");
+        loop {
+            print!("user=> ");
+            let _ = io::stdout().flush();
 
-    let environment = Environment::clojure_core_environment();
-    let stdin = io::stdin();
+            // Read
+            let mut next = Repl::read(&mut stdin_reader);
+            // Eval
+            let evaled_next = self.eval(&next);
+            // Print
+            println!("{}", evaled_next);
+            // Loop
+        }
+    }
+    //
+    // Will possibly just add this to our environment, or turn this into a parallel of clojure.lang.RT
+    //
+    /// Reads the code in a file sequentially and evaluates the result
+    pub fn try_eval_file(&self, filepath: &str) -> Result<Value, std::io::Error> {
+        let core = File::open(filepath)?;
+        let mut reader = BufReader::new(core);
 
-    print!("user=> ");
-    let _ = io::stdout().flush();
-    let mut input_buffer = String::new();
-    for line in stdin.lock().lines() {
-        let line = line.unwrap();
-        input_buffer.push_str(&line);
-        let mut remaining_input = input_buffer.as_str();
+        let mut last_val = Repl::read(&mut reader);
         loop {
-            let next_read_parse = reader::try_read(remaining_input);
-            match next_read_parse {
-                Ok((_remaining_input, value)) => {
-                    print!(
-                        "{} ",
-                        value.eval(Rc::clone(&environment)).to_string_explicit()
-                    );
-                    remaining_input = _remaining_input;
-                }
-                Err(Incomplete(_)) => {
-                    break;
-                }
-                err => {
-                    print!("{}", Value::Condition(format!("Reader Error: {:?}", err)));
-                    input_buffer.clear();
-                    break;
+            // @TODO this is hardcoded until we refactor Conditions to have keys, so that
+            //       we can properly identify them
+            // @FIXME
+            if let Value::Condition(cond) = &last_val {
+                if cond != "Tried to read empty stream; unexpected EOF" {
+                    println!("Error reading file: {}", cond);
                 }
+
+                return Ok(last_val);
+            }
+
+            let evaled_last_val = self.eval(&last_val);
+
+            if let Value::Condition(cond) = evaled_last_val {
+                println!("{}", cond);
             }
+
+            last_val = Repl::read(&mut reader);
+        }
+    }
+}
+
+impl Default for Repl {
+    fn default() -> Repl {
+        Repl {
+            environment: Environment::clojure_core_environment(),
         }
-        input_buffer.clear();
-        println!();
-        print!("user=> ");
-        let _ = io::stdout().flush();
     }
 }