regex type

Author: erkkikeranen

Cargo.toml

@@ -12,4 +12,5 @@ nom = "5.1"
 rand = "0.7"
 itertools= "0.9"
 url = "2.1.1"
+regex = "1.3.7"
 reqwest = { version = "0.10.4", features = ["blocking"] }

src/reader.rs

@@ -364,8 +364,8 @@ pub fn try_read_symbol(input: &str) -> IResult<&str, Value> {
 /// Example Successes:
 ///    nil => Value::Nil
 pub fn try_read_nil(input: &str) -> IResult<&str, Value> {
-    let (rest_input, _) = verify(identifier_parser,|ident: &str| ident == "nil")(input)?;
-    Ok((rest_input,Value::Nil))
+    let (rest_input, _) = verify(identifier_parser, |ident: &str| ident == "nil")(input)?;
+    Ok((rest_input, Value::Nil))
 }
 
 // @TODO allow escaped strings
@@ -388,6 +388,23 @@ pub fn try_read_string(input: &str) -> IResult<&str, Value> {
     to_value_parser(string_parser)(rest_input)
 }
 
+/// Tries to parse &str into Value::Pattern
+/// Example Successes:
+///    #"this is pretty straightforward" => Value::Pattern("this is pretty straightforward")
+pub fn try_read_pattern(input: &str) -> IResult<&str, Value> {
+    named!(hash_quotation<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("#\"")));
+
+    let (rest_input, _) = hash_quotation(input)?;
+    named!(
+        pattern_parser<&str, regex::Regex>,
+        map!(
+            terminated!(take_until!("\""), tag("\"")),
+            |v| regex::Regex::new(v).unwrap()
+        )
+    );
+    to_value_parser(pattern_parser)(rest_input)
+}
+
 // @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:
@@ -492,6 +509,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
             try_read_keyword,
             try_read_list,
             try_read_vector,
+            try_read_pattern,
         )),
     )(input)
 }
@@ -726,8 +744,8 @@ mod tests {
         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 crate::value::{ToValue, Value};
 
         #[test]
         fn try_read_empty_map_test() {
@@ -809,6 +827,14 @@ mod tests {
         fn try_read_bool_false_test() {
             assert_eq!(Value::Boolean(false), try_read("false ").ok().unwrap().1)
         }
+
+        #[test]
+        fn try_read_regex_pattern_test() {
+            assert_eq!(
+                Value::Pattern(regex::Regex::new("hello").unwrap()),
+                try_read("#\"hello\" ").ok().unwrap().1
+            );
+        }
     }
 
     mod consume_clojure_whitespaces_tests {

src/type_tag.rs

@@ -18,6 +18,7 @@ pub enum TypeTag {
     Integer,
     ISeq,
     Nil,
+    Pattern,
 }
 
 use TypeTag::*;
@@ -40,6 +41,7 @@ impl fmt::Display for TypeTag {
             TypeTag::Integer => std::string::String::from("clojure.lang.Integer"),
             ISeq => std::string::String::from("clojure.lang.ISeq"),
             Nil => std::string::String::from("clojure.lang.Nil"),
+            Pattern => std::string::String::from("rust.regex"),
         };
         write!(f, "{}", str)
     }

src/value.rs

@@ -60,6 +60,7 @@ pub enum Value {
 
     String(std::string::String),
     Nil,
+    Pattern(regex::Regex),
 }
 use crate::value::Value::*;
 
@@ -89,6 +90,7 @@ impl PartialEq for Value {
             (LetMacro, LetMacro) => true,
             (String(string), String(string2)) => string == string2,
             (Nil, Nil) => true,
+            (Pattern(p1), Pattern(p2)) => p1.as_str() == p2.as_str(),
             _ => false,
         }
     }
@@ -141,6 +143,7 @@ impl Hash for Value {
             IfMacro => ValueHash::IfMacro.hash(state),
 
             String(string) => string.hash(state),
+            Pattern(p) => p.as_str().hash(state),
             Nil => ValueHash::Nil.hash(state),
         }
         // self.id.hash(state);
@@ -169,6 +172,9 @@ impl fmt::Display for Value {
             IfMacro => std::string::String::from("#macro[if*]"),
             LetMacro => std::string::String::from("#macro[let*]"),
             Value::String(string) => string.clone(),
+            Pattern(pattern) => {
+                std::string::String::from("#\"".to_owned() + pattern.as_str().clone() + "\"")
+            }
             Nil => std::string::String::from("nil"),
         };
         write!(f, "{}", str)
@@ -213,6 +219,7 @@ impl Value {
             Value::IfMacro => TypeTag::Macro,
             Value::String(_) => TypeTag::String,
             Value::Nil => TypeTag::Nil,
+            Value::Pattern(_) => TypeTag::Pattern,
         }
     }
 
@@ -581,6 +588,11 @@ impl ToValue for str {
         Value::String(std::string::String::from(self))
     }
 }
+impl ToValue for regex::Regex {
+    fn to_value(&self) -> Value {
+        Value::Pattern(self.clone())
+    }
+}
 impl ToValue for Symbol {
     fn to_value(&self) -> Value {
         Value::Symbol(self.clone())