boolean type and unit tests

reader refactoring according to request

Author: erkkikeranen

src/reader.rs

@@ -23,6 +23,8 @@ 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
@@ -170,6 +172,7 @@ pub fn integer_parser(input: &str) -> IResult<&str, i32> {
     );
     integer_lexer(input).map(|(rest, digits)| (rest, digits.parse().unwrap()))
 }
+
 // Currently used to create 'try_readers', which are readers (or
 // reader functions, at least) that are basically composable InputType
 // -> IResult<InputType,Value> parsers, that our normal read function
@@ -199,6 +202,18 @@ pub fn try_read_i32(input: &str) -> IResult<&str, Value> {
     to_value_parser(integer_parser)(input)
 }
 
+/// Tries to parse &str into Value::Boolean
+/// Expects:
+///     Booleans
+/// Example success:
+///     true => Value::Boolean(true)
+///     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)?;
+    Ok((rest_input, Value::Boolean(bool.parse().unwrap())))
+}
+
 // Perhaps generalize this into reader macros 
 /// Tries to parse &str into Value::Keyword 
 /// Example Successes:
@@ -323,6 +338,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
             try_read_map,
             try_read_string,
             try_read_i32,
+            try_read_bool,
             try_read_symbol,
 	    try_read_keyword,
             try_read_list,
@@ -498,6 +514,21 @@ mod tests {
         }
     }
 
+    mod try_read_bool_tests {
+        use crate::value::Value;
+        use crate::reader::try_read_bool;
+
+        #[test]
+        fn try_read_boolean_true_test() {
+            assert_eq!(Value::Boolean(true), try_read_bool("true ").ok().unwrap().1);
+        }
+
+        #[test]
+        fn try_read_boolean_false_test() {
+            assert_eq!(Value::Boolean(false), try_read_bool("false ").ok().unwrap().1);
+        }
+    }
+
     mod try_read_symbol_tests {
         use crate::reader::try_read_symbol;
         use crate::symbol::Symbol;
@@ -601,6 +632,22 @@ mod tests {
                 try_read("[] ").ok().unwrap().1
             );
         }
+
+        #[test]
+        fn try_read_bool_true_test() {
+            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
+            )
+        }
     }
 
     mod consume_clojure_whitespaces_tests {

src/type_tag.rs

@@ -3,6 +3,7 @@ use std::fmt;
 #[derive(Debug, Clone)]
 pub enum TypeTag {
     I32,
+    Boolean,
     Symbol,
     Keyword,
     IFn,
@@ -17,14 +18,16 @@ pub enum TypeTag {
     ISeq,
     Nil
 }
+
 use TypeTag::*;
 impl fmt::Display for TypeTag {
     // This trait requires `fmt` with this exact signature.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let str = match self {
             I32 => std::string::String::from("rust.std.i32"),
+            Boolean => std::string::String::from("rust.std.bool"),
             Symbol => std::string::String::from("clojure.lang.Symbol"),
-	    Keyword => std::string::String::from("clojure.lang.Keyword"),
+	        Keyword => std::string::String::from("clojure.lang.Keyword"),
             IFn => std::string::String::from("clojure.lang.Function"),
             Condition => std::string::String::from("clojure.lang.Condition"),
             PersistentList => std::string::String::from("clojure.lang.PersistentList"),

src/value.rs

@@ -28,6 +28,7 @@ use std::rc::Rc;
 #[derive(Debug, Clone)]
 pub enum Value {
     I32(i32),
+    Boolean(bool),
     Symbol(Symbol),
     Keyword(Keyword),
     IFn(Rc<dyn IFn>),
@@ -74,6 +75,12 @@ impl PartialEq for Value {
             }
         }
 
+        if let Boolean(b) = self {
+            if let Boolean(b2) = other {
+                return b == b2;
+            }
+        }
+
         if let Symbol(sym) = self {
             if let Symbol(sym2) = other {
                 return sym == sym2;
@@ -180,6 +187,7 @@ impl Hash for Value {
     fn hash<H: Hasher>(&self, state: &mut H) {
         match self {
             I32(i) => i.hash(state),
+            Boolean(b) => b.hash(state),
             Symbol(sym) => sym.hash(state),
 	    Keyword(kw) => kw.hash(state),
             IFn(_) => {
@@ -216,6 +224,7 @@ impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let str = match self {
             I32(val) => val.to_string(),
+            Boolean(val) => val.to_string(),
             Symbol(sym) => sym.to_string(),
 	    Keyword(kw) => kw.to_string(),
             IFn(_) => std::string::String::from("#function[]"),
@@ -254,6 +263,7 @@ impl Value {
     pub fn type_tag(&self) -> TypeTag {
         match self {
             Value::I32(_) => TypeTag::I32,
+            Value::Boolean(_) => TypeTag::Boolean,
             Value::Symbol(_) => TypeTag::Symbol,
 	    Value::Keyword(_) => TypeTag::Keyword,
             Value::IFn(_) => TypeTag::IFn,
@@ -590,6 +600,11 @@ impl ToValue for i32 {
         Value::I32(*self)
     }
 }
+impl ToValue for bool {
+    fn to_value(&self) -> Value {
+        Value::Boolean(*self)
+    }
+}
 impl ToValue for std::string::String {
     fn to_value(&self) -> Value {
         Value::String(self.clone())