Removed unused imports

Author: arbroween

src/clojure_std/thread.rs

@@ -2,12 +2,8 @@ use crate::error_message;
 use crate::ifn::IFn;
 use crate::type_tag::TypeTag;
 use crate::value::{ToValue, Value};
-use nom::lib::std::convert::TryFrom;
-use std::error::Error;
-use std::io::Read;
 use std::rc::Rc;
 
-use std::thread;
 use std::time;
 
 /// provides a sleep function to sleep for given amount of ms

src/clojure_std/time.rs

@@ -1,13 +1,8 @@
 use crate::error_message;
 use crate::ifn::IFn;
-use crate::type_tag::TypeTag;
 use crate::value::{ToValue, Value};
-use nom::lib::std::convert::TryFrom;
-use std::error::Error;
-use std::io::Read;
 use std::rc::Rc;
 
-use std::thread;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 /// provides a function to return current time in nanoseconds

src/environment.rs

@@ -1,8 +1,7 @@
+use crate::clojure_std;
 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};
 
@@ -118,12 +117,15 @@ impl Environment {
         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("Thread_sleep"),
+            thread_sleep_fn.to_rc_value(),
+        );
 
         environment.insert(Symbol::intern("System_nanotime"), nanotime_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 
+        // @TODO add this to clojure.rs.core namespace as clojure.rs.core/slurp
         environment.insert(Symbol::intern("rust-slurp"), slurp_fn.to_rc_value());
 
         environment.insert(Symbol::intern("+"), add_fn.to_rc_value());
@@ -141,7 +143,7 @@ impl Environment {
             lexical_eval_fn.to_rc_value(),
         );
         environment.insert(Symbol::intern("nth"), nth_fn.to_rc_value());
-	environment.insert(Symbol::intern("assoc"), assoc_fn.to_rc_value());
+        environment.insert(Symbol::intern("assoc"), assoc_fn.to_rc_value());
         environment.insert(Symbol::intern("concat"), concat_fn.to_rc_value());
         environment.insert(
             Symbol::intern("print-string"),

src/error_message.rs

@@ -1,7 +1,5 @@
 use crate::type_tag::TypeTag;
 use crate::value::Value;
-use nom::error::ErrorKind;
-use nom::Err;
 use std::error::Error;
 
 pub fn type_mismatch(expected: TypeTag, got: &Value) -> Value {

src/reader.rs

@@ -10,21 +10,19 @@
 
 use nom::{
     branch::alt, bytes::complete::tag, map, sequence::preceded, take_until, terminated,
-    Err::Incomplete, IResult, Needed,
+    Err::Incomplete, IResult,
 };
 
+use crate::keyword::Keyword;
 use crate::maps::MapEntry;
 use crate::persistent_list::ToPersistentList;
 use crate::persistent_list_map::ToPersistentListMap;
 use crate::persistent_vector::ToPersistentVector;
 use crate::symbol::Symbol;
-use crate::keyword::Keyword;
 use crate::value::{ToValue, Value};
 use std::rc::Rc;
 
 use std::io::BufRead;
-use nom::Err::Error;
-use nom::error::ErrorKind;
 //
 // Note; the difference between ours 'parsers'
 //   identifier_parser
@@ -78,7 +76,7 @@ fn cons_str(head: char, tail: &str) -> String {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-//       
+//
 //     Predicates
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -150,12 +148,12 @@ fn is_clojure_whitespace(c: char) -> bool {
     c.is_whitespace() || c == ','
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-//     End predicates 
+//     End predicates
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
-//       
-//     Parsers 
+//
+//     Parsers
 //
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -290,32 +288,31 @@ pub fn try_read_i32(input: &str) -> IResult<&str, Value> {
 ///     false => Value::Boolean(false)
 pub fn try_read_bool(input: &str) -> IResult<&str, Value> {
     named!(bool_parser<&str,&str>, alt!( tag!("true") | tag!("false")));
-    let (rest_input,bool) = bool_parser(input)?;
+    let (rest_input, bool) = bool_parser(input)?;
     Ok((rest_input, Value::Boolean(bool.parse().unwrap())))
 }
 
-
 /// Tries to parse &str into Value::double
 ///
 pub fn try_read_f64(input: &str) -> IResult<&str, Value> {
     to_value_parser(double_parser)(input)
 }
 
 // Perhaps generalize this into reader macros
-/// Tries to parse &str into Value::Keyword 
+/// Tries to parse &str into Value::Keyword
 /// Example Successes:
 ///    :a                    => Value::Keyword(Keyword { sym: Symbol { name: "a" })
-///    :cat-dog              => Value::Keyword(Keyword { sym: Symbol { name: "cat-dog" }) 
+///    :cat-dog              => Value::Keyword(Keyword { sym: Symbol { name: "cat-dog" })
 /// Example Failures:
-///    :12 :'a 
+///    :12 :'a
 pub fn try_read_keyword(input: &str) -> IResult<&str, Value> {
     named!(keyword_colon<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!(":")));
 
     let (rest_input, _) = keyword_colon(input)?;
-    let (rest_input,symbol) = symbol_parser(rest_input)?;
+    let (rest_input, symbol) = symbol_parser(rest_input)?;
 
     let keyword_value = Keyword { sym: symbol }.to_value();
-    Ok((rest_input,keyword_value))
+    Ok((rest_input, keyword_value))
 }
 
 /// Tries to parse &str into Value::Symbol
@@ -421,28 +418,34 @@ pub fn try_read_list(input: &str) -> IResult<&str, Value> {
 pub fn try_read_quoted(input: &str) -> IResult<&str, Value> {
     named!(quote<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("'")));
 
-    let (form,_) = quote(input)?;
+    let (form, _) = quote(input)?;
 
-    let (rest_input,quoted_form_value) = try_read(form)?;
+    let (rest_input, quoted_form_value) = try_read(form)?;
 
-    // (quote value) 
-    Ok((rest_input,
-	vec![Symbol::intern("quote").to_rc_value(),
-	     quoted_form_value      .to_rc_value()].into_list().to_value()))
+    // (quote value)
+    Ok((
+        rest_input,
+        vec![
+            Symbol::intern("quote").to_rc_value(),
+            quoted_form_value.to_rc_value(),
+        ]
+        .into_list()
+        .to_value(),
+    ))
 }
 
 pub fn try_read(input: &str) -> IResult<&str, Value> {
     preceded(
         consume_clojure_whitespaces_parser,
         alt((
-	    try_read_quoted,
+            try_read_quoted,
             try_read_map,
             try_read_string,
             try_read_f64,
             try_read_i32,
             try_read_bool,
             try_read_symbol,
-	    try_read_keyword,
+            try_read_keyword,
             try_read_list,
             try_read_vector,
         )),
@@ -454,7 +457,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //
-//      Readers 
+//      Readers
 //
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -471,7 +474,9 @@ pub fn read<R: BufRead>(reader: &mut R) -> Value {
         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(String::from("Tried to read empty stream; unexpected EOF")),
+            None => {
+                return Value::Condition(String::from("Tried to read empty stream; unexpected EOF"))
+            }
         }
 
         let line_read = try_read(&input_buffer);
@@ -594,7 +599,7 @@ mod tests {
     }
 
     mod integer_parser_tests {
-        use crate::reader::{integer_parser};
+        use crate::reader::integer_parser;
 
         #[test]
         fn integer_parser_parses_integer_one() {
@@ -623,8 +628,8 @@ mod tests {
     }
 
     mod try_read_bool_tests {
-        use crate::value::Value;
         use crate::reader::try_read_bool;
+        use crate::value::Value;
 
         #[test]
         fn try_read_boolean_true_test() {
@@ -633,7 +638,10 @@ mod tests {
 
         #[test]
         fn try_read_boolean_false_test() {
-            assert_eq!(Value::Boolean(false), try_read_bool("false ").ok().unwrap().1);
+            assert_eq!(
+                Value::Boolean(false),
+                try_read_bool("false ").ok().unwrap().1
+            );
         }
     }
 
@@ -654,15 +662,13 @@ mod tests {
     }
 
     mod try_read_tests {
-        use crate::maps::MapEntry;
         use crate::persistent_list;
         use crate::persistent_list_map;
         use crate::persistent_vector;
         use crate::reader::try_read;
         use crate::symbol::Symbol;
         use crate::value::Value;
         use crate::value::Value::{PersistentList, PersistentListMap, PersistentVector};
-        use std::rc::Rc;
 
         #[test]
         fn try_read_empty_map_test() {
@@ -743,18 +749,12 @@ mod tests {
 
         #[test]
         fn try_read_bool_true_test() {
-            assert_eq!(
-            Value::Boolean(true),
-            try_read("true ").ok().unwrap().1
-            )
+            assert_eq!(Value::Boolean(true), try_read("true ").ok().unwrap().1)
         }
 
         #[test]
         fn try_read_bool_false_test() {
-            assert_eq!(
-                Value::Boolean(false),
-                try_read("false ").ok().unwrap().1
-            )
+            assert_eq!(Value::Boolean(false), try_read("false ").ok().unwrap().1)
         }
     }
 
@@ -776,7 +776,10 @@ mod tests {
         #[test]
         fn consume_whitespaces_from_input_no_whitespace() {
             let s = "1, 2, 3";
-            assert_eq!(Some(("1, 2, 3", ())), consume_clojure_whitespaces_parser(&s).ok());
+            assert_eq!(
+                Some(("1, 2, 3", ())),
+                consume_clojure_whitespaces_parser(&s).ok()
+            );
         }
     }
 

src/repl.rs

@@ -2,7 +2,6 @@ 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;

src/rust_core/print_string.rs

@@ -1,5 +1,5 @@
 use crate::ifn::IFn;
-use crate::value::{Value, ToValue, Evaluable};
+use crate::value::{ToValue, Value};
 use std::rc::Rc;
 
 use crate::error_message;
@@ -16,9 +16,9 @@ impl ToValue for PrintStringFn {
 impl IFn for PrintStringFn {
     fn invoke(&self, args: Vec<Rc<Value>>) -> Value {
         if args.len() != 1 {
-            return error_message::wrong_arg_count(1, args.len())
+            return error_message::wrong_arg_count(1, args.len());
         }
         println!("{}", args.get(0).unwrap().to_string());
         Value::Nil
     }
-}
+}

src/rust_core/slurp.rs

@@ -10,7 +10,6 @@ use reqwest;
 use url::Url;
 
 use crate::error_message;
-use std::error::Error;
 
 /// (slurp f & opts)
 ///

src/rust_core/string_print.rs

@@ -1,5 +1,5 @@
 use crate::ifn::IFn;
-use crate::value::{Value, ToValue, Evaluable};
+use crate::value::{ToValue, Value};
 use std::rc::Rc;
 
 // Todo: dead code? no usage found