error messages

proposal for discussion

Author: erkkikeranen

src/error_message.rs

@@ -0,0 +1,38 @@
+use crate::type_tag::TypeTag;
+use crate::value::Value;
+
+pub fn type_mismatch(expected: TypeTag, got: Option<&&Value>) -> Value {
+    let received_type = if got.is_some() { got.unwrap().type_tag() } else { TypeTag::Nil };
+    Value::Condition(format!(
+        "Type mismatch; Expected instance of {},  Recieved type {}",
+        TypeTag::Integer,
+        received_type
+    ))
+}
+
+pub fn wrong_arg_count(expected: usize, got: usize) -> Value {
+    Value::Condition(format!(
+        "Wrong number of arguments given to function (Given: {}, Expected: {})",
+        got,
+        expected
+    ))
+}
+
+pub fn wrong_varg_count(expected: &[usize], got: usize) -> Value {
+    Value::Condition(format!(
+        "Wrong number of arguments given to function (Given: {}, Expected: {:?})",
+        got,
+        expected
+    ))
+}
+
+pub fn index_out_of_bounds(ind: usize, count: usize) -> Value {
+    Value::Condition(format!(
+        "Index out of bounds: Index ({}), Length: ({})",
+        ind, count
+    ))
+}
+
+pub fn index_cannot_be_negative(ind: usize) -> Value {
+    Value::Condition(format!("Index cannot be negative; Index ({})", ind))
+}

src/main.rs

@@ -15,6 +15,7 @@ mod rust_core;
 mod symbol;
 mod type_tag;
 mod value;
+mod error_message;
 
 fn main() {
     //

src/rust_core.rs

@@ -12,6 +12,9 @@ use crate::persistent_vector::{PersistentVector, ToPersistentVectorIter};
 use crate::symbol::Symbol;
 use crate::value::{Evaluable, ToValue};
 
+use crate::error_message;
+use crate::type_tag::TypeTag;
+
 //
 // This module will hold the core functions and macros that Clojure will
 // hook into; Functions / Macros like "+", "fn*", "let", "cond", etc
@@ -72,12 +75,12 @@ impl IFn for AddFn {
         args.into_iter().fold(0_i32.to_value(), |a, b| match a {
             Value::I32(a_) => match b {
                 Value::I32(b_) => Value::I32(a_ + b_),
-                _ => Value::Condition(format!(
+                _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
                     "Type mismatch; Expecting: (i32 | i64 | f32 | f64), Found: {}",
                     b.type_tag()
                 )),
             },
-            _ => Value::Condition(format!(
+            _ => Value::Condition(format!( // TODO: what error message should be returned regarding using typetags?
                 "Type mismatch: Expecting: (i32 | i64 | f32 | f64), Found: {}",
                 a.type_tag()
             )),
@@ -105,11 +108,7 @@ impl IFn for EvalFn {
     fn invoke(&self, args: Vec<&Value>) -> Value {
         // @TODO generalize arity exceptions, and other exceptions
         if args.len() != 1 {
-            return Value::Condition(format!(
-                "Wrong number of arguments given to function (Given: {}, Expected: {})",
-                args.len(),
-                args.len()
-            ));
+            return error_message::wrong_arg_count(1, args.len())
         }
         let arg = args.get(0).unwrap();
         arg.eval(Rc::clone(&self.enclosing_environment))
@@ -178,58 +177,39 @@ impl IFn for NthFn {
     fn invoke(&self, args: Vec<&Value>) -> Value {
         // @TODO generalize arity exceptions, and other exceptions
         if args.len() != 2 {
-            return Value::Condition(format!(
-                "Wrong number of arguments (Given: {}, Expected: 1-2)",
-                args.len()
-            ));
+            return error_message::wrong_arg_count(2, args.len())
         }
         // @TODO change iteration to work with Value references, or even change invoke to work on Rc<..>
         //       as we do everything else; surely we don't want to clone just to read from a collection
         if let Some(Value::I32(ind)) = args.get(1) {
             if *ind < 0 {
-                return Value::Condition(format!("Index cannot be negative; Index ({})", ind));
+                return error_message::index_cannot_be_negative(*ind as usize)
             }
             let ind = *ind as usize;
 
             match args.get(0).unwrap() {
                 Value::PersistentList(Cons(head, tail, count)) => {
                     let count = *count as usize;
                     if ind >= count {
-                        Value::Condition(format!(
-                            "Index out of bounds: Index ({}), Length: ({})",
-                            ind, count
-                        ))
+                        error_message::index_out_of_bounds(ind, count)
                     } else if ind == 0 {
                         head.to_value()
                     } else {
                         tail.iter().nth(ind - 1).unwrap().to_value()
                     }
                 }
-                Value::PersistentList(Empty) => Value::Condition(format!(
-                    "Index out of bounds: Index ({}), Length: ({})",
-                    ind, 0
-                )),
+                Value::PersistentList(Empty) => error_message::index_out_of_bounds(ind, 0),
                 Value::PersistentVector(PersistentVector { vals }) => {
                     if ind >= vals.len() {
-                        Value::Condition(format!(
-                            "Index out of bounds: Index ({}), Length: ({})",
-                            ind,
-                            vals.len()
-                        ))
+                        error_message::index_out_of_bounds(ind, vals.len())
                     } else {
                         vals.get(ind).unwrap().to_value()
                     }
                 }
-                _ => Value::Condition(format!(
-                    "Type mismatch; Expected instance of clojure.lang.ISeq, Recieved type {}",
-                    args.get(0).unwrap().type_tag()
-                )),
+                _ => error_message::type_mismatch(TypeTag::ISeq, args.get(0)),
             }
         } else {
-            Value::Condition(format!(
-                "Type mismatch; Expected instance of clojure.lang.Integer,  Recieved type {}",
-                args.get(1).unwrap().type_tag()
-            ))
+            error_message::type_mismatch(TypeTag::Integer, args.get(0))
         }
     }
 }
@@ -273,11 +253,7 @@ impl ToValue for PrintStringFn {
 impl IFn for PrintStringFn {
     fn invoke(&self, args: Vec<&Value>) -> Value {
         if args.len() != 1 {
-            return Value::Condition(format!(
-                "Wrong number of arguments given to function (Given: {}, Expected: {})",
-                args.len(),
-                args.len()
-            ));
+            return error_message::wrong_arg_count(1, args.len())
         }
         println!("{}", args.get(0).unwrap().to_string());
         Value::Nil

src/type_tag.rs

@@ -12,7 +12,9 @@ pub enum TypeTag {
     // Experimental; may make no sense at runtime, as we will likely be unable to take the value of a macro
     Macro,
     String,
-    Nil,
+    Integer,
+    ISeq,
+    Nil
 }
 use TypeTag::*;
 impl fmt::Display for TypeTag {
@@ -28,6 +30,8 @@ impl fmt::Display for TypeTag {
             PersistentListMap => std::string::String::from("clojure.lang.PersistentListMap"),
             Macro => std::string::String::from("clojure.lang.Macro"),
             TypeTag::String => std::string::String::from("rust.std.string.String"),
+            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"),
         };
         write!(f, "{}", str)