Reformatted code in src/reader.rs

Author: Leo Pourcelot

src/reader.rs

@@ -1,35 +1,31 @@
 //! The reader.  The part that reads plain text and parses it into Clojure structures, which are
-//! themselves code. 
+//! themselves code.
 //!
 //! Right now there's no sort of data kept track by the reader at any point, so there's no real
 //! reader data structure here -- this is just a plain module, a bag of functions.  However,
 //! I believe this will change -- especially as, for instance, we define the idea of reader conditionals,
 //! or even reader macros,  although the latter will likely be reserved for our interpreter here (but perhaps
 //! not;  since this is about being a 'free-er' Clojure, especially since it can't compete with it in raw
-//! power, neither speed or ecosystem,  it might be worth it to leave in reader macros. 
+//! power, neither speed or ecosystem,  it might be worth it to leave in reader macros.
 
 use nom::{
-    IResult,
     branch::alt,
-    error::convert_error,
+    bytes::complete::{tag, take_while1},
     character::complete::multispace0,
-    bytes::complete::{take_while1,tag},
-    take_until,
-    terminated,
-    map,
     combinator::map_res,
-    sequence::{preceded,terminated}};
+    error::convert_error,
+    map,
+    sequence::{preceded, terminated},
+    take_until, terminated, IResult,
+};
 
-use crate::value::{Value,ToValue};
-use crate::persistent_list::{ToPersistentList};
-use crate::persistent_vector::{ToPersistentVector};
-use crate::persistent_list_map::{PersistentListMap,ToPersistentListMap};
 use crate::maps::MapEntry;
+use crate::persistent_list::ToPersistentList;
+use crate::persistent_list_map::{PersistentListMap, ToPersistentListMap};
+use crate::persistent_vector::ToPersistentVector;
 use crate::symbol::Symbol;
-use std::{
-    iter::FromIterator,
-    rc::Rc,
-};
+use crate::value::{ToValue, Value};
+use std::{iter::FromIterator, rc::Rc};
 
 use std::fs::File;
 
@@ -120,24 +116,22 @@ pub fn identifier_parser(input: &str) -> IResult<&str, String> {
     named!(identifier_tail<&str, &str>, take_while!(is_identifier_char));
 
     named!(identifier_ <&str, String>,
-	    do_parse!(
-		    head: identifier_head >>
-		    rest_input: identifier_tail >>
-		    (cons_str(head, rest_input))
-        )
-   );
+         do_parse!(
+             head: identifier_head >>
+             rest_input: identifier_tail >>
+             (cons_str(head, rest_input))
+         )
+    );
 
     identifier_(input)
 }
 
-/// Parses valid Clojure symbols,  whose name is a valid identifier 
+/// Parses valid Clojure symbols,  whose name is a valid identifier
 pub fn symbol_parser(input: &str) -> IResult<&str, Symbol> {
-    identifier_parser(input).map(|(rest_input,name)| {
-	(rest_input, Symbol::intern(&name))
-    })
+    identifier_parser(input).map(|(rest_input, name)| (rest_input, Symbol::intern(&name)))
 }
 
-// @TODO add negatives 
+// @TODO add negatives
 /// Parses valid integers
 /// Example Successes: 1, 2, 4153,  -12421
 pub fn integer(input: &str) -> IResult<&str, i32> {
@@ -151,13 +145,15 @@ pub fn integer(input: &str) -> IResult<&str, i32> {
 // / reader will wrap.
 /// Takes a parser, such as one that reads a &str and returns an
 /// i32, and creates a new parser that instead returns a valid
-/// ClojureRS Value instead 
-pub fn to_value_parser<I,O: ToValue>(parser: impl Fn(I) -> IResult<I,O>) -> impl Fn(I) -> IResult<I,Value> {
-    move |input: I| parser(input).map(|(rest_input,thing)| (rest_input,thing.to_value()))
+/// ClojureRS Value instead
+pub fn to_value_parser<I, O: ToValue>(
+    parser: impl Fn(I) -> IResult<I, O>,
+) -> impl Fn(I) -> IResult<I, Value> {
+    move |input: I| parser(input).map(|(rest_input, thing)| (rest_input, thing.to_value()))
 }
 
 // @TODO make sure whitespace or 'nothing' is at the end, fail for
-// float like numbers 
+// float like numbers
 /// Tries to parse &str into Value::I32
 /// Expects:
 ///   Integers
@@ -177,19 +173,19 @@ pub fn try_read_i32(input: &str) -> IResult<&str, Value> {
 ///    cat-dog              => Value::Symbol(Symbol { name: "cat-dog" })
 ///    +common-lisp-global+ => Value::Symbol(Symbol { name: "+common-lisp-global+" })
 /// Example Failures:
-///    12cat,  'quoted,  @at-is-for-references 
+///    12cat,  'quoted,  @at-is-for-references
 pub fn try_read_symbol(input: &str) -> IResult<&str, Value> {
     to_value_parser(symbol_parser)(input)
 }
 
-// @TODO allow escaped strings 
+// @TODO allow escaped strings
 /// Tries to parse &str into Value::String
 /// Example Successes:
 ///    "this is pretty straightforward" => Value::String("this is pretty straightforward")
 pub fn try_read_string(input: &str) -> IResult<&str, Value> {
     named!(quotation<&str, &str>, preceded!(consume_clojure_whitespaces, tag!("\"")));
 
-    let (rest_input,_) = quotation(input)?;
+    let (rest_input, _) = quotation(input)?;
     named!(
         string_parser<&str, String>,
         map!(
@@ -201,121 +197,124 @@ pub fn try_read_string(input: &str) -> IResult<&str, Value> {
     to_value_parser(string_parser)(input)
 }
 
-// @TODO Perhaps generalize this, or even generalize it as a reader macro 
+// @TODO Perhaps generalize this, or even generalize it as a reader macro
 /// Tries to parse &str into Value::PersistentListMap, or some other Value::..Map   
 /// Example Successes:
 ///    {:a 1} => Value::PersistentListMap {PersistentListMap { MapEntry { :a, 1} .. ]})
 pub fn try_read_map(input: &str) -> IResult<&str, Value> {
     named!(lbracep<&str, &str>, preceded!(consume_clojure_whitespaces, tag!("{")));
     named!(rbracep<&str, &str>, preceded!(consume_clojure_whitespaces, tag!("}")));
-    let (map_inner_input,_) = lbracep(input)?;
-    let mut map_as_vec : Vec<MapEntry> = vec![];
+    let (map_inner_input, _) = lbracep(input)?;
+    let mut map_as_vec: Vec<MapEntry> = vec![];
     let mut rest_input = map_inner_input;
     loop {
-	let right_brace = rbracep(rest_input);
-	match right_brace {
-	    Ok((after_map_input,_)) => {
-		break Ok((after_map_input,map_as_vec.into_list_map().to_value()));
-	    },
-	    _ => {
-		let (_rest_input,next_key) = try_read(rest_input)?;
-		let (_rest_input,next_val) = try_read(_rest_input)?;
-		map_as_vec.push(MapEntry { key: Rc::new(next_key) , val:Rc::new(next_val)});
-		rest_input = _rest_input;
-	    }
-	}
+        let right_brace = rbracep(rest_input);
+        match right_brace {
+            Ok((after_map_input, _)) => {
+                break Ok((after_map_input, map_as_vec.into_list_map().to_value()));
+            }
+            _ => {
+                let (_rest_input, next_key) = try_read(rest_input)?;
+                let (_rest_input, next_val) = try_read(_rest_input)?;
+                map_as_vec.push(MapEntry {
+                    key: Rc::new(next_key),
+                    val: Rc::new(next_val),
+                });
+                rest_input = _rest_input;
+            }
+        }
     }
 }
 
 // @TODO use nom functions in place of macro
-/// Tries to parse &str into Value::PersistentVector 
+/// Tries to parse &str into Value::PersistentVector
 /// Example Successes:
 ///    [1 2 3] => Value::PersistentVector(PersistentVector { vals: [Rc(Value::I32(1) ... ]})
 ///    [1 2 [5 10 15] 3]
 ///      => Value::PersistentVector(PersistentVector { vals: [Rc(Value::I32(1) .. Rc(Value::PersistentVector..)]})
 pub fn try_read_vector(input: &str) -> IResult<&str, Value> {
     named!(lbracketp<&str, &str>, preceded!(consume_clojure_whitespaces, tag!("[")));
     named!(rbracketp<&str, &str>, preceded!(consume_clojure_whitespaces, tag!("]")));
-    let (vector_inner_input,_) = lbracketp(input)?;
+    let (vector_inner_input, _) = lbracketp(input)?;
     let mut vector_as_vec = vec![];
-    // What's left of our input as we read more of our PersistentVector 
+    // What's left of our input as we read more of our PersistentVector
     let mut rest_input = vector_inner_input;
     loop {
-	// Try parse end of vector
-	let right_paren = rbracketp(rest_input);
-	match right_paren {
-	    // If we succeeded,  we can convert our vector of values into a PersistentVector and return our success
-	    Ok((after_vector_input,_)) => {
-		break Ok((after_vector_input,vector_as_vec.into_vector().to_value()));
-	    },
-	    // Otherwise, we need to keep reading until we get that closing bracket letting us know we're finished
-	    _ => {
-		let next_form_parse = try_read(rest_input);
-		match next_form_parse {
-		    // Normal behavior;  read our next element in the PersistentVector
-		    Ok((_rest_input,form)) => 	{
-			vector_as_vec.push(form.to_rc_value());
-			rest_input = _rest_input;
-		    },
-		    // This parse failed, return overall read failure 
-		    _ => {
-			break next_form_parse;
-		    }
-		}
-
-	    }
-	}
+        // Try parse end of vector
+        let right_paren = rbracketp(rest_input);
+        match right_paren {
+            // If we succeeded,  we can convert our vector of values into a PersistentVector and return our success
+            Ok((after_vector_input, _)) => {
+                break Ok((after_vector_input, vector_as_vec.into_vector().to_value()));
+            }
+            // Otherwise, we need to keep reading until we get that closing bracket letting us know we're finished
+            _ => {
+                let next_form_parse = try_read(rest_input);
+                match next_form_parse {
+                    // Normal behavior;  read our next element in the PersistentVector
+                    Ok((_rest_input, form)) => {
+                        vector_as_vec.push(form.to_rc_value());
+                        rest_input = _rest_input;
+                    }
+                    // This parse failed, return overall read failure
+                    _ => {
+                        break next_form_parse;
+                    }
+                }
+            }
+        }
     }
 }
 
 pub fn try_read_list(input: &str) -> IResult<&str, Value> {
     named!(lparenp<&str, &str>, preceded!(consume_clojure_whitespaces, tag!("(")));
     named!(rparenp<&str, &str>, preceded!(consume_clojure_whitespaces, tag!(")")));
 
-    let (list_inner_input,_) = lparenp(input)?;
+    let (list_inner_input, _) = lparenp(input)?;
     let mut list_as_vec = vec![];
     let mut rest_input = list_inner_input;
     loop {
-	let right_paren = rparenp(rest_input);
-	match right_paren {
-	    Ok((after_list_input,_)) => {
-		break Ok((after_list_input,list_as_vec.into_list().to_value()));
-	    },
-	    _ => {
-		let next_form_parse = try_read(rest_input);
-		match next_form_parse {
-		    Ok((_rest_input,form)) => 	{
-			list_as_vec.push(form.to_rc_value());
-			rest_input = _rest_input;
-		    },
-		    // This parse failed, forward failure 
-		    _ => {
-			break next_form_parse;
-		    }
-		}
-
-	    }
-	}
+        let right_paren = rparenp(rest_input);
+        match right_paren {
+            Ok((after_list_input, _)) => {
+                break Ok((after_list_input, list_as_vec.into_list().to_value()));
+            }
+            _ => {
+                let next_form_parse = try_read(rest_input);
+                match next_form_parse {
+                    Ok((_rest_input, form)) => {
+                        list_as_vec.push(form.to_rc_value());
+                        rest_input = _rest_input;
+                    }
+                    // This parse failed, forward failure
+                    _ => {
+                        break next_form_parse;
+                    }
+                }
+            }
+        }
     }
 }
 
 pub fn try_read(input: &str) -> IResult<&str, Value> {
-    preceded(consume_clojure_whitespaces,alt(
-	(try_read_map,
-	 try_read_string,
-	 try_read_symbol,
-	 try_read_i32,
-	 try_read_list,
-	 try_read_vector
-     )))(input)
+    preceded(
+        consume_clojure_whitespaces,
+        alt((
+            try_read_map,
+            try_read_string,
+            try_read_symbol,
+            try_read_i32,
+            try_read_list,
+            try_read_vector,
+        )),
+    )(input)
 }
 
 pub fn debug_try_read(input: &str) -> IResult<&str, Value> {
-    
     let reading = try_read(input);
     match &reading {
-	Ok((_,value)) => println!("Reading: {}",value),
-	_ => println!("Reading: {:?}",reading)
+        Ok((_, value)) => println!("Reading: {}", value),
+        _ => println!("Reading: {:?}", reading),
     };
     reading
 }