rustfmt

Author: Tko1

src/environment.rs

@@ -1,44 +1,46 @@
-use crate::protocol::Protocol;
-use crate::value::Value;
-use crate::value::ToValue;
-use crate::persistent_list_map::PersistentListMapIter;
-use crate::persistent_vector::PersistentVectorIter;
 use crate::persistent_list::PersistentListIter;
-use crate::persistent_list_map::ToPersistentListMapIter;
-use crate::persistent_vector::ToPersistentVectorIter;
 use crate::persistent_list::ToPersistentListIter;
+use crate::persistent_list_map::PersistentListMapIter;
+use crate::persistent_list_map::ToPersistentListMapIter;
+use crate::persistent_vector::PersistentVectorIter;
 use crate::persistent_vector::ToPersistentVector;
-use std::rc::Rc;
+use crate::persistent_vector::ToPersistentVectorIter;
+use crate::protocol::Protocol;
+use crate::value::ToValue;
+use crate::value::Value;
 use std::iter::FromIterator;
+use std::rc::Rc;
 
 //
 // This Protocol lives inside of Clojure RS
 //
-#[derive(Debug, Clone)] 
+#[derive(Debug, Clone)]
 pub struct Iterable {
-    value: Rc<Value>
+    value: Rc<Value>,
 }
 impl Protocol for Iterable {
     fn try_as_protocol(val: &Rc<Value>) -> Option<Self> {
         match &**val {
-            Value::PersistentList(_) =>
-                Some(Iterable { value: Rc::clone(val)}),
-            Value::PersistentVector(_) =>
-                Some(Iterable { value: Rc::clone(val)}),
-            Value::PersistentListMap(_) =>
-                Some(Iterable { value: Rc::clone(val)}),
-            _ =>
-                None
+            Value::PersistentList(_) => Some(Iterable {
+                value: Rc::clone(val),
+            }),
+            Value::PersistentVector(_) => Some(Iterable {
+                value: Rc::clone(val),
+            }),
+            Value::PersistentListMap(_) => Some(Iterable {
+                value: Rc::clone(val),
+            }),
+            _ => None,
         }
     }
     fn try_unwrap(&self) -> Option<Rc<Value>> {
         match &*self.value {
             Value::PersistentList(_) => Some(Rc::clone(&self.value)),
             Value::PersistentVector(_) => Some(Rc::clone(&self.value)),
             Value::PersistentListMap(_) => Some(Rc::clone(&self.value)),
-            _ => None 
+            _ => None,
         }
-    } 
+    }
 }
 pub enum IterableIter {
     PersistentList(PersistentListIter),
@@ -55,24 +57,32 @@ impl Iterator for IterableIter {
                 let maybe_map_entry = plist_map_iter.next();
                 if let Some(map_entry) = maybe_map_entry {
                     // In Clojure: [key val]
-                    return Some(vec![map_entry.key.clone(), map_entry.val.clone()].into_vector().to_rc_value());
+                    return Some(
+                        vec![map_entry.key.clone(), map_entry.val.clone()]
+                            .into_vector()
+                            .to_rc_value(),
+                    );
                 }
-                None 
+                None
             }
         }
     }
 }
 impl Iterable {
-    pub fn iter(&self) -> IterableIter
-    {
-        match &*self.value  {
-            Value::PersistentList(plist) => IterableIter::PersistentList(Rc::new(plist.clone()).iter()),
-            Value::PersistentVector(pvector) => IterableIter::PersistentVector(Rc::new(pvector.clone()).iter()),
-            Value::PersistentListMap(pmap) => IterableIter::PersistentListMap(Rc::new(pmap.clone()).iter()),
+    pub fn iter(&self) -> IterableIter {
+        match &*self.value {
+            Value::PersistentList(plist) => {
+                IterableIter::PersistentList(Rc::new(plist.clone()).iter())
+            }
+            Value::PersistentVector(pvector) => {
+                IterableIter::PersistentVector(Rc::new(pvector.clone()).iter())
+            }
+            Value::PersistentListMap(pmap) => {
+                IterableIter::PersistentListMap(Rc::new(pmap.clone()).iter())
+            }
             // We are ok panicking in this case because an invariant on the type is the assumption
-            // that we only have an Iterable if we were able to convert 
-            _ => panic!("Called Iterable iter on non-iterable")
+            // that we only have an Iterable if we were able to convert
+            _ => panic!("Called Iterable iter on non-iterable"),
         }
-        
     }
 }

src/iterable.rs

@@ -10,26 +10,24 @@ pub struct Keyword {
 impl Keyword {
     pub fn intern(name: &str) -> Keyword {
         Keyword {
-	    sym: Symbol::intern(name)
+            sym: Symbol::intern(name),
         }
     }
     // Note; normally 'with_x' would imply x is the second argument
     // here, but we are keeping the semantics of interning that
     // Clojure proper has
     pub fn intern_with_ns(ns: &str, name: &str) -> Keyword {
         Keyword {
-	    sym: Symbol::intern_with_ns(name,ns)
+            sym: Symbol::intern_with_ns(name, ns),
         }
     }
 }
 impl fmt::Display for Keyword {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-	if self.sym.ns != "" {
-	    write!(f, ":{}/{}", self.sym.ns,self.sym.name)
-	}
-	else {
-	    write!(f, ":{}", self.sym.name)
-	}
-        
+        if self.sym.ns != "" {
+            write!(f, ":{}/{}", self.sym.ns, self.sym.name)
+        } else {
+            write!(f, ":{}", self.sym.name)
+        }
     }
 }

src/keyword.rs

@@ -6,22 +6,22 @@ mod clojure_std;
 mod environment;
 mod error_message;
 mod ifn;
+mod iterable;
 mod keyword;
 mod lambda;
 mod maps;
 mod namespace;
 mod persistent_list;
 mod persistent_list_map;
 mod persistent_vector;
+mod protocol;
 mod reader;
 mod repl;
 mod rust_core;
 mod symbol;
 mod type_tag;
 mod util;
 mod value;
-mod protocol;
-mod iterable;
 
 fn main() {
     //