refactoring, functions new-line, pr, prn, print, println, flush, getenv

Author: erkkikeranen

src/clojure/core.clj

@@ -1,3 +1,6 @@
+(def *flush-on-newline* true)
+(def *print-readably* true)
+
 (def list (fn [& ls] ls))
 
 (defmacro defn [name args & body]
@@ -8,11 +11,27 @@
 (defn apply [f args]
   (lexical-eval (concat (list f) args)))
 
-(defn print [& more]
+(defn newline
+  []
+  (system-newline))
+
+(defn flush
+  []
+  (flush-stdout))
+
+(defn pr [& more]
   (print-string (apply str more)))
 
+(defn prn [& more]
+  (apply pr more)
+  (newline)
+  (flush))
+
+(defn print [& more]
+  (apply pr more))
+
 (defn println [& more]
-  (println-string (apply str more)))
+  (apply prn more))
 
 (defn inc [x]
   (+ x 1))
@@ -23,7 +42,7 @@
 (defmacro time [expr]
   (list (quote let) [(quote start) (quote (System_nanotime)) (quote ret) expr]
         (quote (do
-        (println (str "Elapsed time: " (_slash_ (- (System_nanotime) start) 1000000.0) " msecs"))
+        (println (str "Elapsed time: " (_slash_ (- (System_nanoTime) start) 1000000.0) " msecs"))
         ret))))
 
 (defn slurp [f & opts]

src/clojure_std.rs

@@ -1,2 +1,3 @@
-pub(crate) mod thread;
-pub(crate) mod time;
+pub (crate) mod thread;
+pub (crate) mod time;
+pub (crate) mod env;

src/clojure_std/env.rs

@@ -0,0 +1,35 @@
+use crate::error_message;
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use std::env;
+use crate::type_tag::TypeTag;
+
+/// provides a function to return env variables
+/// similair to Clojure (System/getenv [key])
+#[derive(Debug, Clone)]
+pub struct GetEnvFn {}
+impl ToValue for GetEnvFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+
+impl IFn for GetEnvFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() == 1 {
+            match args.get(0).unwrap().to_value() {
+                Value::String(key) => {
+                    match env::var(key) {
+                        Ok(val) => Value::String(val),
+                        Err(_) => Value::Nil
+                    }
+                }
+                _a => error_message::type_mismatch(TypeTag::String, &_a)
+            }
+        } else {
+            return error_message::wrong_arg_count(1, args.len());
+        }
+    }
+}

src/environment.rs

@@ -70,7 +70,7 @@ use Environment::*;
 impl Environment {
     pub fn change_namespace(&self,symbol: Symbol) {
 	      let symbol = symbol.unqualified();
-	      
+
 	      match self.get_main_environment() {
 	          MainEnvironment(EnvironmentVal { curr_ns_sym, ..}) => {
 		            curr_ns_sym.replace(symbol);
@@ -162,9 +162,9 @@ impl Environment {
         match self {
             MainEnvironment(env_val) => { 
 		            // If we've recieved a qualified symbol like
-		            // clojure.core/+ 
+		            // clojure.core/+
 		            if sym.ns != "" {
-		                // Use that namespace 
+		                // Use that namespace
 		                env_val.get_from_namespace(&Symbol::intern(&sym.ns),sym)
 		            }
 		            else {
@@ -198,8 +198,9 @@ impl Environment {
         let nth_fn = rust_core::NthFn {};
         let do_macro = rust_core::DoMacro {};
         let concat_fn = rust_core::ConcatFn {};
+        let flush_stdout_fn = rust_core::FlushStdoutFn {};
+        let system_newline_fn = rust_core::SystemNewlineFn {};
         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 {};
 
@@ -209,6 +210,7 @@ impl Environment {
         // clojure.std functions
         let thread_sleep_fn = clojure_std::thread::SleepFn {};
         let nanotime_fn = clojure_std::time::NanoTimeFn {};
+        let get_env_fn = clojure_std::env::GetEnvFn {};
 
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
@@ -248,10 +250,9 @@ impl Environment {
             thread_sleep_fn.to_rc_value(),
         );
 
-        environment.insert(
-	          Symbol::intern("System_nanotime"),
-	          nanotime_fn.to_rc_value()
-	      );
+        environment.insert(Symbol::intern("System_nanoTime"), nanotime_fn.to_rc_value());
+
+        environment.insert(Symbol::intern("System_getenv"), get_env_fn.to_rc_value());
 
         // core.clj wraps calls to the rust implementations
         // @TODO add this to clojure.rs.core namespace as clojure.rs.core/slurp
@@ -275,13 +276,19 @@ impl Environment {
         environment.insert(Symbol::intern("nth"), nth_fn.to_rc_value());
         environment.insert(Symbol::intern("assoc"), assoc_fn.to_rc_value());
         environment.insert(Symbol::intern("concat"), concat_fn.to_rc_value());
+
+        // input and output
         environment.insert(
-            Symbol::intern("print-string"),
-            print_string_fn.to_rc_value(),
+            Symbol::intern("system-newline"),
+            system_newline_fn.to_rc_value(),
         );
         environment.insert(
-            Symbol::intern("println-string"),
-            println_string_fn.to_rc_value(),
+            Symbol::intern("flush-stdout"),
+            flush_stdout_fn.to_rc_value(),
+        );
+        environment.insert(
+            Symbol::intern("print-string"),
+            print_string_fn.to_rc_value(),
         );
         environment.insert(Symbol::intern("read-line"), read_line_fn.to_rc_value());
 
@@ -330,16 +337,16 @@ mod tests {
 	          // env_val.change_namespace(Symbol::intern_with_ns("not-ns","ns"));
 	          // assert_eq!(Symbol::intern("ns"),env_val.get_current_namespace())
 		        ;
-				    
-	          // @TODO add case for local environment 	
+
+	          // @TODO add case for local environment
 	      }
-	      
+
 	      /////////////////////////////////////////////////////////////////////////////
 	      //
 	      //  fn get_from_namespace(&self,namespace: &Symbol,sym: &Symbol) -> Rc<Value>
 	      //
 	      //////////////////////////////////////////////////////////////////////////////
-	      
+
 	      #[test]
         fn test_get_from_namespace() {
 	          let env_val = EnvironmentVal::new_main_val();

src/rust_core.rs

@@ -44,13 +44,18 @@ pub(crate) mod assoc;
 pub use self::assoc::*;
 
 // input and output
+pub(crate) mod system_newline;
+pub use self::system_newline::*;
+pub(crate) mod flush_stdout;
+pub use self::flush_stdout::*;
 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;
 pub use self::slurp::*;

src/rust_core/flush_stdout.rs

@@ -0,0 +1,28 @@
+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 TODO: should be aware of *in*
+/// (defn read-line [])
+#[derive(Debug, Clone)]
+pub struct FlushStdoutFn {}
+impl ToValue for FlushStdoutFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for FlushStdoutFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 0 {
+            return error_message::wrong_arg_count(0, args.len())
+        }
+        io::stdout().flush();
+        Value::Nil
+    }
+}

src/rust_core/print_string.rs

@@ -4,26 +4,7 @@ use std::rc::Rc;
 
 use crate::error_message;
 
-/// Primitive printing function;
-/// (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;
+/// Primitive printing function; TODO: should be aware of *out*
 /// (defn print-string [string] .. prints single string without linebreak.. )
 #[derive(Debug, Clone)]
 pub struct PrintStringFn {}

src/rust_core/read_line.rs

@@ -8,7 +8,7 @@ use crate::error_message;
 use nom::lib::std::convert::TryFrom;
 use std::io::{Read, Write};
 
-/// Read a line from stdin
+/// Read a line from stdin TODO: should be aware of *in*
 /// (defn read-line [])
 #[derive(Debug, Clone)]
 pub struct ReadLineFn {}
@@ -23,7 +23,6 @@ impl IFn for ReadLineFn {
             return error_message::wrong_arg_count(0, args.len())
         }
         let mut input = String::new();
-        io::stdout().flush();
         match io::stdin().read_line(&mut input) {
             Ok(_) => {
                 input.pop();

src/rust_core/system_newline.rs

@@ -0,0 +1,25 @@
+use crate::ifn::IFn;
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+
+use crate::error_message;
+
+/// Prints system newline, `\n` in rust on all platforms to stdout
+/// TODO: should be aware of *out*
+/// (defn print-string [string] .. prints single string without linebreak.. )
+#[derive(Debug, Clone)]
+pub struct SystemNewlineFn {}
+impl ToValue for SystemNewlineFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+impl IFn for SystemNewlineFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() != 0 {
+            return error_message::wrong_arg_count(0, args.len());
+        }
+        print!("\n");
+        Value::Nil
+    }
+}