Added keywords

Author: Tko1

src/keyword.rs

@@ -0,0 +1,23 @@
+use crate::symbol::Symbol;
+use std::fmt;
+use std::hash::Hash;
+
+#[derive(Hash, PartialEq, Eq, Clone, Debug)]
+pub struct Keyword {
+    // In Clojure proper,  a Keyword wraps a Symbol to share their ..symbolic functionality 
+    pub sym: Symbol,
+}
+impl Keyword {
+    pub fn intern(name: &str) -> Keyword {
+        Keyword {
+	    sym: Symbol {
+		name: String::from(name),
+            }
+	}
+    }
+}
+impl fmt::Display for Keyword {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, ":{}", self.sym.name)
+    }
+}

src/main.rs

@@ -14,6 +14,7 @@ mod reader;
 mod repl;
 mod rust_core;
 mod symbol;
+mod keyword;
 mod type_tag;
 mod util;
 mod value;

src/reader.rs

@@ -18,6 +18,7 @@ use crate::persistent_list::ToPersistentList;
 use crate::persistent_list_map::ToPersistentListMap;
 use crate::persistent_vector::ToPersistentVector;
 use crate::symbol::Symbol;
+use crate::keyword::Keyword;
 use crate::value::{ToValue, Value};
 use std::rc::Rc;
 
@@ -198,6 +199,23 @@ pub fn try_read_i32(input: &str) -> IResult<&str, Value> {
     to_value_parser(integer_parser)(input)
 }
 
+// Perhaps generalize this into reader macros 
+/// Tries to parse &str into Value::Keyword 
+/// Example Successes:
+///    :a                    => Value::Keyword(Keyword { sym: Symbol { name: "a" })
+///    :cat-dog              => Value::Keyword(Keyword { sym: Symbol { name: "cat-dog" }) 
+/// Example Failures:
+///    :12 :'a 
+pub fn try_read_keyword(input: &str) -> IResult<&str, Value> {
+    named!(keyword_colon<&str, &str>, preceded!(consume_clojure_whitespaces, tag!(":")));
+
+    let (rest_input, _) = keyword_colon(input)?;
+    let (rest_input,symbol) = symbol_parser(rest_input)?;
+
+    let keyword_value = Keyword { sym: symbol }.to_value();
+    Ok((rest_input,keyword_value))
+}
+
 /// Tries to parse &str into Value::Symbol
 /// Example Successes:
 ///    a                    => Value::Symbol(Symbol { name: "a" })
@@ -306,6 +324,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
             try_read_string,
             try_read_i32,
             try_read_symbol,
+	    try_read_keyword,
             try_read_list,
             try_read_vector,
         )),

src/type_tag.rs

@@ -4,6 +4,7 @@ use std::fmt;
 pub enum TypeTag {
     I32,
     Symbol,
+    Keyword,
     IFn,
     Condition,
     PersistentList,
@@ -21,6 +22,7 @@ impl fmt::Display for TypeTag {
         let str = match self {
             I32 => std::string::String::from("rust.std.i32"),
             Symbol => std::string::String::from("clojure.lang.Symbol"),
+	    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

@@ -7,6 +7,7 @@ use crate::persistent_list::{PersistentList, ToPersistentList, ToPersistentListI
 use crate::persistent_list_map::{PersistentListMap, ToPersistentListMapIter};
 use crate::persistent_vector::PersistentVector;
 use crate::symbol::Symbol;
+use crate::keyword::Keyword;
 use crate::type_tag::TypeTag;
 
 extern crate rand;
@@ -28,6 +29,7 @@ use std::rc::Rc;
 pub enum Value {
     I32(i32),
     Symbol(Symbol),
+    Keyword(Keyword),
     IFn(Rc<dyn IFn>),
     //
     // Special case functions
@@ -77,6 +79,12 @@ impl PartialEq for Value {
                 return sym == sym2;
             }
         }
+
+	if let Keyword(kw) = self {
+            if let Keyword(kw2) = other {
+                return kw == kw2;
+            }
+        }
         // Equality not defined on functions, similar to Clojure
         // Change this perhaps? Diverge?
         if let IFn(_) = self {
@@ -173,6 +181,7 @@ impl Hash for Value {
         match self {
             I32(i) => i.hash(state),
             Symbol(sym) => sym.hash(state),
+	    Keyword(kw) => kw.hash(state),
             IFn(_) => {
                 let mut rng = rand::thread_rng();
                 let n2: u16 = rng.gen();
@@ -208,6 +217,7 @@ impl fmt::Display for Value {
         let str = match self {
             I32(val) => val.to_string(),
             Symbol(sym) => sym.to_string(),
+	    Keyword(kw) => kw.to_string(),
             IFn(_) => std::string::String::from("#function[]"),
             LexicalEvalFn => std::string::String::from("#function[lexical-eval*]"),
             PersistentList(plist) => plist.to_string(),
@@ -245,6 +255,7 @@ impl Value {
         match self {
             Value::I32(_) => TypeTag::I32,
             Value::Symbol(_) => TypeTag::Symbol,
+	    Value::Keyword(_) => TypeTag::Keyword,
             Value::IFn(_) => TypeTag::IFn,
             Value::LexicalEvalFn => TypeTag::IFn,
             Value::PersistentList(_) => TypeTag::PersistentList,
@@ -594,6 +605,11 @@ impl ToValue for Symbol {
         Value::Symbol(self.clone())
     }
 }
+impl ToValue for Keyword {
+    fn to_value(&self) -> Value {
+        Value::Keyword(self.clone())
+    }
+}
 impl ToValue for Rc<dyn IFn> {
     fn to_value(&self) -> Value {
         Value::IFn(Rc::clone(self))