Add namespaces to symbol / keyword, add namespace qualified symbols to reader

Author: Tko1

src/keyword.rs

@@ -10,14 +10,26 @@ pub struct Keyword {
 impl Keyword {
     pub fn intern(name: &str) -> Keyword {
         Keyword {
-            sym: Symbol {
-                name: String::from(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)
         }
     }
 }
 impl fmt::Display for Keyword {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, ":{}", self.sym.name)
+	if self.sym.ns != "" {
+	    write!(f, ":{}/{}", self.sym.ns,self.sym.name)
+	}
+	else {
+	    write!(f, ":{}", self.sym.name)
+	}
+        
     }
 }

src/reader.rs

@@ -10,7 +10,7 @@
 
 use nom::{
     branch::alt, bytes::complete::tag, map, sequence::preceded, take_until, terminated,
-    Err::Incomplete, IResult, Needed,
+    combinator::opt, Err::Incomplete, IResult, Needed,
 };
 
 use crate::keyword::Keyword;
@@ -104,7 +104,7 @@ fn cons_str(head: char, tail: &str) -> String {
 ///   - `*`,
 ///   - `!`,
 fn is_identifier_char(chr: char) -> bool {
-    chr.is_alphanumeric() || "|?<>+-_=^%&$*!".contains(chr)
+    chr.is_alphanumeric() || "|?<>+-_=^%&$*!.".contains(chr)
 }
 
 /// Returns whether if a character can be in the head of an identifier.
@@ -128,7 +128,7 @@ fn is_identifier_char(chr: char) -> bool {
 ///   - `*`,
 ///   - `!`,
 fn is_non_numeric_identifier_char(chr: char) -> bool {
-    chr.is_alphabetic() || "|?<>+-_=^%&$*!".contains(chr)
+    chr.is_alphabetic() || "|?<>+-_=^%&$*!.".contains(chr)
 }
 
 /// Returns true if given character is a minus character
@@ -192,9 +192,22 @@ pub fn identifier_parser(input: &str) -> IResult<&str, String> {
     identifier(input)
 }
 
-/// Parses valid Clojure symbols,  whose name is a valid identifier
+/// Parses valid Clojure symbol
+/// Example Successes: a , b , |ab123|
+///                    namespace.subnamespace/a    cat/b   a.b.c/|ab123| 
 pub fn symbol_parser(input: &str) -> IResult<&str, Symbol> {
-    identifier_parser(input).map(|(rest_input, name)| (rest_input, Symbol::intern(&name)))
+    named!(namespace_parser <&str,String>,
+	   do_parse!(
+	       ns: identifier_parser >>
+	       tag!("/") >>
+	       (ns)));
+    
+    let (rest_input,ns)   = opt(namespace_parser)(input)?;
+    let (rest_input,name) = identifier_parser(rest_input)?; 
+    match ns {
+	Some(ns) => Ok((rest_input,Symbol::intern_with_ns(&ns,&name))),
+	None     => Ok((rest_input,Symbol::intern(&name)))   
+    }
 }
 
 /// Parses valid integers
@@ -549,6 +562,7 @@ mod tests {
     }
 
     mod symbol_parser_tests {
+	use crate::reader::try_read_symbol;
         use crate::reader::symbol_parser;
         use crate::symbol::Symbol;
 
@@ -557,9 +571,7 @@ mod tests {
             assert_eq!(
                 Some((
                     " this",
-                    Symbol {
-                        name: String::from("input->output?")
-                    }
+                    Symbol::intern("input->output?")
                 )),
                 symbol_parser("input->output? this").ok()
             );
@@ -574,6 +586,21 @@ mod tests {
         fn identifier_parser_does_not_parse_empty_input() {
             assert_eq!(None, symbol_parser("").ok());
         }
+
+	#[test]
+        fn symbol_parser_normal_symbol_test() {
+            assert_eq!(
+                Symbol::intern("a"),
+                symbol_parser("a ").ok().unwrap().1
+            );
+        }
+	#[test]
+	fn symbol_parser_namespace_qualified_symbol_test() {
+            assert_eq!(
+                Symbol::intern_with_ns("clojure.core","a"),
+                symbol_parser("clojure.core/a ").ok().unwrap().1
+            );
+        }
     }
 
     mod double_parser_tests {
@@ -653,9 +680,7 @@ mod tests {
         #[test]
         fn try_read_minus_as_valid_symbol_test() {
             assert_eq!(
-                Value::Symbol(Symbol {
-                    name: String::from("-")
-                }),
+                Value::Symbol(Symbol::intern("-")),
                 try_read_symbol("- ").unwrap().1
             );
         }
@@ -671,7 +696,7 @@ mod tests {
         use crate::value::Value;
         use crate::value::Value::{PersistentList, PersistentListMap, PersistentVector};
         use std::rc::Rc;
-
+	
         #[test]
         fn try_read_empty_map_test() {
             assert_eq!(
@@ -706,29 +731,23 @@ mod tests {
         #[test]
         fn try_read_valid_symbol_test() {
             assert_eq!(
-                Value::Symbol(Symbol {
-                    name: String::from("my-symbol")
-                }),
+                Value::Symbol(Symbol::intern("my-symbol")),
                 try_read("my-symbol ").ok().unwrap().1
             );
         }
 
         #[test]
         fn try_read_minus_as_valid_symbol_test() {
             assert_eq!(
-                Value::Symbol(Symbol {
-                    name: String::from("-")
-                }),
+                Value::Symbol(Symbol::intern("-")),
                 try_read("- ").ok().unwrap().1
             );
         }
 
         #[test]
         fn try_read_minus_prefixed_as_valid_symbol_test() {
             assert_eq!(
-                Value::Symbol(Symbol {
-                    name: String::from("-prefixed")
-                }),
+                Value::Symbol(Symbol::intern("-prefixed")),
                 try_read("-prefixed ").ok().unwrap().1
             );
         }

src/symbol.rs

@@ -4,16 +4,81 @@ use std::hash::Hash;
 #[derive(Hash, PartialEq, Eq, Clone, Debug)]
 pub struct Symbol {
     pub name: String,
+    // @TODO Should this be an optional string?
+    //       on one hand, playing with this is closer to the original,
+    //       and slightly easier to read and understand (for me).
+    //       But you might say it doesn't force you to cover the None
+    //       route, the sort of invariants ADTs are good at.
+    //       Most likely, we will reimplement this as Option<String>
+    pub ns: String
 }
 impl Symbol {
     pub fn intern(name: &str) -> Symbol {
+	let mut ns = "";
+	let mut name = name;
+	// @TODO See if we will have any problems with manipulating
+	//       text in other languages
+	//       I think we will be ok here though
+	if let Some(ind) = name.chars().position(|c| c == '/') {
+	    // @TODO Make sure that the index given by ^ 
+	    //       has the same meaning as the index
+	    //       we are giving to this range
+	    //       Ie,  if the 6 in a[..6] refers to the 6th byte
+	    //       and  if the 6 in Some(6) means the 6th character,
+	    //       we need to make sure each 'character' in this case
+	    //       is 1 byte, and not some other grapheme abstraction
+	    //       else,these are two different indexes
+	    ns = &name[..ind];
+	    name = &name[ind+1..];
+	}
+	Symbol::intern_with_ns(ns,name)
+    }
+    pub fn intern_with_ns(ns: &str,name: &str) -> Symbol {
         Symbol {
             name: String::from(name),
+	    ns: String::from(ns)
         }
     }
+    pub fn unqualified(&self) -> Symbol {
+	Symbol::intern(&self.name)
+    }
 }
 impl fmt::Display for Symbol {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.name)
     }
 }
+mod tests {
+
+    mod symbol_tests {
+        use crate::symbol::Symbol;
+	use std::cell::RefCell;
+	use std::collections::HashMap;
+	use std::rc::Rc;
+	
+        #[test]
+        fn test_intern() {
+	    assert_eq!(Symbol::intern("a"), Symbol { ns: String::from(""), name: String::from("a")});
+        }
+
+	#[test]
+        fn test_intern_with_ns() {
+	    assert_eq!(Symbol::intern_with_ns("clojure.core","a"), Symbol { ns: String::from("clojure.core"), name: String::from("a")});
+	    assert_eq!(Symbol::intern_with_ns("","a"), Symbol { ns: String::from(""), name: String::from("a")});
+	    assert_eq!(Symbol::intern("a"), Symbol { ns: String::from(""), name: String::from("a")});
+	    assert_eq!(Symbol::intern("clojure.core/a"), Symbol { ns: String::from("clojure.core"), name: String::from("a")});
+	    assert_eq!(Symbol::intern("clojure/a"), Symbol { ns: String::from("clojure"), name: String::from("a")});
+	    assert_eq!(Symbol::intern("/a"), Symbol { ns: String::from(""), name: String::from("a")});
+        }
+	fn test_work_with_hashmap() {
+	    let mut hashmap = HashMap::new();
+	    hashmap.insert(Symbol::intern("+"),1_i32);
+	    hashmap.insert(Symbol::intern("-"),2_i32);
+
+	    assert_eq!(1_i32,*hashmap.get(&Symbol::intern("+")).unwrap());
+	    assert_eq!(2_i32,*hashmap.get(&Symbol::intern("-")).unwrap());
+	    assert_eq!(None,hashmap.get(&Symbol::intern("*")));
+	    	    
+	}
+    }
+}