read-line function, and print function

Author: erkkikeranen

src/clojure/core.clj

@@ -8,9 +8,12 @@
 (defn apply [f args]
   (lexical-eval (concat (list f) args)))
 
-(defn println [& more]
+(defn print [& more]
   (print-string (apply str more)))
 
+(defn println [& more]
+  (println-string (apply str more)))
+
 (defn inc [x]
   (+ x 1))
 

src/environment.rs

@@ -199,6 +199,8 @@ impl Environment {
         let do_macro = rust_core::DoMacro {};
         let concat_fn = rust_core::ConcatFn {};
         let print_string_fn = rust_core::PrintStringFn {};
+        let println_string_fn = rust_core::PrintlnStringFn {};
+        let read_line_fn = rust_core::ReadLineFn {};
         let assoc_fn = rust_core::AssocFn {};
 
         // rust implementations of core functions
@@ -277,6 +279,11 @@ impl Environment {
             Symbol::intern("print-string"),
             print_string_fn.to_rc_value(),
         );
+        environment.insert(
+            Symbol::intern("println-string"),
+            println_string_fn.to_rc_value(),
+        );
+        environment.insert(Symbol::intern("read-line"), read_line_fn.to_rc_value());
 
         //
         // Read in clojure.core

src/repl.rs

@@ -36,9 +36,15 @@ impl Repl {
         loop {
             print!("{}=> ",self.environment.get_current_namespace_name());
             let _ = io::stdout().flush();
+            let mut next = Value::Nil;
+
+            // a scope for stdin to be released for providing input for function
+            {
+                let mut stdin_reader = stdin.lock();
+                // Read
+                next = Repl::read(&mut stdin_reader);
+            }
 
-            // Read
-            let next = Repl::read(&mut stdin_reader);
             // Eval
             let evaled_next = self.eval(&next);
             // Print

src/rust_core.rs

@@ -48,6 +48,8 @@ pub(crate) mod print_string;
 pub use self::print_string::*;
 pub(crate) mod string_print;
 pub use self::string_print::*;
+pub(crate) mod read_line;
+pub use self::read_line::*;
 
 // other
 pub(crate) mod slurp;

src/rust_core/print_string.rs

@@ -5,7 +5,26 @@ use std::rc::Rc;
 use crate::error_message;
 
 /// Primitive printing function;
-/// (defn print-string [string] .. prints single string .. )
+/// (defn println-string [string] .. prints single string with linebreak.. )
+#[derive(Debug, Clone)]
+pub struct PrintlnStringFn {}
+impl ToValue for PrintlnStringFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for PrintlnStringFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 1 {
+            return error_message::wrong_arg_count(1, args.len())
+        }
+        println!("{}", args.get(0).unwrap().to_string());
+        Value::Nil
+    }
+}
+
+/// Primitive printing function;
+/// (defn print-string [string] .. prints single string without linebreak.. )
 #[derive(Debug, Clone)]
 pub struct PrintStringFn {}
 impl ToValue for PrintStringFn {
@@ -18,7 +37,7 @@ impl IFn for PrintStringFn {
         if args.len() != 1 {
             return error_message::wrong_arg_count(1, args.len());
         }
-        println!("{}", args.get(0).unwrap().to_string());
+        print!("{}", args.get(0).unwrap().to_string());
         Value::Nil
     }
 }

src/rust_core/read_line.rs

@@ -0,0 +1,34 @@
+use crate::ifn::IFn;
+use crate::value::{Value, ToValue, Evaluable};
+use std::rc::Rc;
+
+use std::io;
+
+use crate::error_message;
+use nom::lib::std::convert::TryFrom;
+use std::io::{Read, Write};
+
+/// Read a line from stdin
+/// (defn read-line [])
+#[derive(Debug, Clone)]
+pub struct ReadLineFn {}
+impl ToValue for ReadLineFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for ReadLineFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 0 {
+            return error_message::wrong_arg_count(0, args.len())
+        }
+
+        //io::stdout().flush();
+        let mut input = String::new();
+        io::stdout().flush();
+        match io::stdin().read_line(&mut input) {
+            Ok(_) => Value::String(input),
+            Err(error) => error_message::generic_err(Box::try_from(error).unwrap())
+        }
+    }
+}