Added if built-in macro and the ability to read nil

Author: Tko1

src/environment.rs

@@ -85,6 +85,7 @@ impl Environment {
         let def_macro = Value::DefMacro {};
         let fn_macro = Value::FnMacro {};
         let defmacro_macro = Value::DefmacroMacro {};
+	let if_macro = Value::IfMacro {};
         let environment = Rc::new(Environment::new_main_environment());
 
         let eval_fn = rust_core::EvalFn::new(Rc::clone(&environment));
@@ -106,6 +107,7 @@ impl Environment {
         environment.insert(Symbol::intern("do"), do_macro.to_rc_value());
         environment.insert(Symbol::intern("def"), def_macro.to_rc_value());
         environment.insert(Symbol::intern("fn"), fn_macro.to_rc_value());
+	environment.insert(Symbol::intern("if"), if_macro.to_rc_value());
         environment.insert(Symbol::intern("defmacro"), defmacro_macro.to_rc_value());
         environment.insert(Symbol::intern("eval"), eval_fn.to_rc_value());
         environment.insert(

src/reader.rs

@@ -227,6 +227,18 @@ pub fn try_read_symbol(input: &str) -> IResult<&str, Value> {
     to_value_parser(symbol_parser)(input)
 }
 
+
+/// Tries to parse a &str that says 'nil' into Value::Nil
+/// Example Successes:
+///    nil => Value::Nil
+pub fn try_read_nil(input: &str) -> IResult<&str, Value> {
+    named!(nil<&str, &str>, preceded!(consume_clojure_whitespaces, tag!("nil")));
+
+    let (rest_input, _) = nil(input)?;
+    
+    Ok((rest_input,Value::Nil))
+}
+
 // @TODO allow escaped strings
 /// Tries to parse &str into Value::String
 /// Example Successes:
@@ -320,6 +332,7 @@ pub fn try_read(input: &str) -> IResult<&str, Value> {
     preceded(
         consume_clojure_whitespaces,
         alt((
+	    try_read_nil,
             try_read_map,
             try_read_string,
             try_read_i32,

src/rust_core.rs

@@ -281,7 +281,6 @@ impl IFn for AssocFn {
             for (key_value, val_value) in args.into_iter().skip(1).tuples() {
                 let key = key_value.to_rc_value();
                 let val = val_value.to_rc_value();
-                println!("key: {:?}, val: {:?}", key, val);
                 retval = pmap.assoc(key, val);
             }
             return Value::PersistentListMap(retval);

src/value.rs

@@ -54,18 +54,16 @@ pub enum Value {
     DefMacro,
     FnMacro,
     LetMacro,
+    IfMacro,
 
     String(std::string::String),
     Nil,
 }
 use crate::value::Value::*;
 
-// @TODO since I have already manually defined hash,  surely this should just be defined
-//       in terms of that?
 impl PartialEq for Value {
-    // @TODO derive from Hash in some way?  Note; can't derive with derive because of
-    //       our trait objects in IFn and Macro
     // @TODO implement our generic IFns some other way? After all, again, this isn't Java
+    // @TODO improve this? This is a hack 
     fn eq(&self, other: &Value) -> bool {
         //
         if let I32(i) = self {
@@ -146,6 +144,11 @@ impl PartialEq for Value {
                 return true;
             }
         }
+	if let IfMacro = self {
+	    if let IfMacro = other {
+		return true;
+	    }
+	}
 
         if let String(string) = self {
             if let String(string2) = other {
@@ -172,6 +175,7 @@ enum ValueHash {
     DefmacroMacro,
     DefMacro,
     FnMacro,
+    IfMacro,
     LetMacro,
     Nil,
 }
@@ -204,6 +208,7 @@ impl Hash for Value {
             DefMacro => ValueHash::DefMacro.hash(state),
             FnMacro => ValueHash::FnMacro.hash(state),
             LetMacro => ValueHash::LetMacro.hash(state),
+	    IfMacro => ValueHash::IfMacro.hash(state),
 
             String(string) => string.hash(state),
             Nil => ValueHash::Nil.hash(state),
@@ -229,6 +234,7 @@ impl fmt::Display for Value {
             DefMacro => std::string::String::from("#macro[def*]"),
             DefmacroMacro => std::string::String::from("#macro[defmacro*]"),
             FnMacro => std::string::String::from("#macro[fn*]"),
+	    IfMacro => std::string::String::from("#macro[if*]"),
             LetMacro => std::string::String::from("#macro[let*]"),
             Value::String(string) => string.clone(),
             Nil => std::string::String::from("nil"),
@@ -270,6 +276,7 @@ impl Value {
             Value::DefmacroMacro => TypeTag::Macro,
             Value::LetMacro => TypeTag::Macro,
             Value::FnMacro => TypeTag::Macro,
+	    Value::IfMacro => TypeTag::Macro,
             Value::String(_) => TypeTag::String,
             Value::Nil => TypeTag::Nil,
         }
@@ -558,7 +565,23 @@ impl Value {
                     )))),
                     Ordering::Equal => Some(args.nth(0)),
                 }
-            }
+            },
+	    IfMacro => {
+		if args.len() != 2 && args.len() != 3 {
+		    return Some(Rc::new(Value::Condition(format!(
+			"Wrong number of arguments (Given: {}, Expected: 2 or 3)",
+			args.len()
+                    ))))
+		}
+		let arg_refs = PersistentList::iter(args).collect::<Vec<Rc<Value>>>();
+		let condition = arg_refs.get(0).unwrap().eval(Rc::clone(environment));
+
+		if condition.is_truthy() {
+		    Some(arg_refs.get(1).unwrap().eval_to_rc(Rc::clone(environment)))
+		} else {
+		    Some(arg_refs.get(2).unwrap_or(&Rc::new(Value::Nil)).eval_to_rc(Rc::clone(environment)))
+		} 
+	    }
             //
             // If we're not a valid IFn
             //
@@ -568,6 +591,12 @@ impl Value {
     ////////////////////////////////////////////////////////////////////////////////////////////////////
     // Eval Helper
     ////////////////////////////////////////////////////////////////////////////////////////////////////
+    fn is_truthy(&self) -> bool {
+        if let Value::Nil = self {
+            return false;
+        }
+        true
+    }
 }
 pub trait ToValue {
     fn to_value(&self) -> Value;