Thread/sleep, System/nanotime functions

Author: erkkikeranen

src/clojure_std.rs

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

src/clojure_std/thread.rs

@@ -0,0 +1,38 @@
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+use crate::ifn::IFn;
+use std::io::Read;
+use std::error::Error;
+use crate::error_message;
+use nom::lib::std::convert::TryFrom;
+use crate::type_tag::TypeTag;
+
+use std::thread;
+use std::time;
+
+/// provides a sleep function to sleep for given amount of ms
+#[derive(Debug, Clone)]
+pub struct SleepFn {}
+impl ToValue for SleepFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+
+impl IFn for SleepFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() == 1 {
+            let arg = &**args.get(0).unwrap();
+            match arg {
+                Value::I32(i) => {
+                    std::thread::sleep(time::Duration::new(0, (*i as u32) * 1000000));
+                    return Value::Nil
+                },
+                _ => error_message::type_mismatch(TypeTag::I32, args.get(0).unwrap())
+            }
+        } else {
+            error_message::wrong_arg_count(1, args.len());
+            return Value::Nil
+        }
+    }
+}

src/clojure_std/time.rs

@@ -0,0 +1,32 @@
+use crate::value::{ToValue, Value};
+use std::rc::Rc;
+use crate::ifn::IFn;
+use std::io::Read;
+use std::error::Error;
+use crate::error_message;
+use nom::lib::std::convert::TryFrom;
+use crate::type_tag::TypeTag;
+
+use std::thread;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// provides a function to return current time in nanoseconds
+#[derive(Debug, Clone)]
+pub struct NanoTimeFn {}
+impl ToValue for NanoTimeFn {
+    fn to_value(&self) -> Value {
+        Value::IFn(Rc::new(self.clone()))
+    }
+}
+
+impl IFn for NanoTimeFn {
+    fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
+        if args.len() == 0 {
+            let ns = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+            return Value::F64(ns as f64)
+        } else {
+            error_message::wrong_arg_count(0, args.len());
+            return Value::Nil
+        }
+    }
+}

src/environment.rs

@@ -2,6 +2,7 @@ use crate::namespace::{Namespace, Namespaces};
 use crate::repl;
 use crate::repl::Repl;
 use crate::rust_core;
+use crate::clojure_std;
 use crate::symbol::Symbol;
 use crate::value::{ToValue, Value};
 
@@ -77,6 +78,9 @@ impl Environment {
         let concat_fn = rust_core::ConcatFn {};
         let print_string_fn = rust_core::PrintStringFn {};
         let assoc_fn = rust_core::AssocFn {};
+        // clojure.std functions
+        let thread_sleep_fn = clojure_std::thread::SleepFn {};
+        let nanotime_fn = clojure_std::time::NanoTimeFn {};
         // Hardcoded fns
         let lexical_eval_fn = Value::LexicalEvalFn {};
         // Hardcoded macros
@@ -98,6 +102,11 @@ impl Environment {
         environment.insert(Symbol::intern("defmacro"), defmacro_macro.to_rc_value());
         environment.insert(Symbol::intern("eval"), eval_fn.to_rc_value());
 
+        // Thread namespace TODO / instead of _
+        environment.insert(Symbol::intern("Thread_sleep"), thread_sleep_fn.to_rc_value());
+
+        environment.insert(Symbol::intern("System_nanotime"), nanotime_fn.to_rc_value());
+
         environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
         environment.insert(Symbol::intern("let"), let_macro.to_rc_value());
         environment.insert(Symbol::intern("str"), str_fn.to_rc_value());

src/main.rs

@@ -13,6 +13,7 @@ mod persistent_vector;
 mod reader;
 mod repl;
 mod rust_core;
+mod clojure_std;
 mod symbol;
 mod keyword;
 mod type_tag;