replace macros with more general methods

src/about_variables.rs

@@ -1,38 +1,39 @@
-// Welcome to Rustlings! If you're here, that means you've either successfully
-// downloaded Rustlings, or are looking at this on GitHub. Either way, let me
-// introduce you to one of the most basic elements of Rust:
-//
-// === VARIABLES ===
-//
-// Variables are essentially little containers that hold, well, something. Think
-// of them as a little cardboard box that you put stuff into. What can you put
-// into a virtual cardboard box in Rust? All kinds of stuff, it turns out!
-// Numbers, words, sequences, and much more. Let's start out simple, though.
-// Here's our first exercise:
+use title;
+use verify;
 
-pub fn exercise_one() {
+// Variables in Rust are defined using the "let" keyword. Like this:
+
+fn exercise_one() {
     let x = 5;
-    verify!(0, x, "Number assignment");
+    verify(5, x);
     //      ^  ^
     //      |  |
     // What's  The variable
     //  in it  name
 }
 
-// Did you get all that? The "let" word basically tells us that we now want to
-// define a variable, and what follows it (the "x") is the name of the variable.
-// Each variable has a name, like a label you put on your cardboard box so you
-// don't confuse it with another, similar looking one.
-// The whole "verify!" deal essentially means that Rustlings is checking if you
-// solved the exercise correctly. It compares the first argument with the
-// second, so in this case "0" with "x", where "x" is the *value* of the variable
-// we called "x". When you write "x", you pull out the cardboard box labelled "x"
-// and take out what's inside of it.
-// Speaking of which, what *is* inside of our "x" cardboard box? I don't think it's
-// "0"... do you know? Replace the "0" with the value of the variable we defined.
-// After that, run "cargo run" in your command line, and see if you put in the
-// right answer.
+// Try to replace the "0" with the value of the variable, then run
+// "cargo run" and see if it was correct!
+
+// Here's a more complicated example:
+
+fn guess_me() -> &'static str {
+    let x = 10;
+    if x == 10 {
+        return "Ten!";
+    } else {
+        return "Not ten!";
+    }
+}
+
+fn exercise_two() {
+    let result = guess_me();
+    verify("REPLACE ME", result);
+}
 
 pub fn exec() {
+    title("Variables: Exercise 1");
     exercise_one();
+    title("Variables: Exercise 2");
+    exercise_two();
 }

src/macros.rs

@@ -1,14 +1,21 @@
+#[macro_export]
+macro_rules! title {
+    ($str:expr) => {
+        println!("{} {}", ansi_term::Color::Yellow.bold().paint("RUN"), $str);
+    }
+}
+
 #[macro_export]
 macro_rules! verify {
-    ($left:expr, $right:expr, $str:expr) => {
+    ($left:expr, $right:expr) => {
         use ansi_term::Color::{Green, Red};
 
         if $left == $right {
-            println!("{} {}", Green.bold().paint("PASS"), $str);
+            println!("{} {} == {}", Green.bold().paint("PASS"), $left, $right);
         } else {
-            println!("{} {}", Red.bold().paint("FAIL"), $str);
-            println!("\tYou submitted {}, but that's not correct!", $left);
-            println!("\tPlease correct your code to make this test pass!");
+            print!("{}", Red.bold().paint("FAIL"));
+            println!(" You submitted {}, but that's not correct!", $left);
+            println!("     Please correct your code to make this test pass!");
         }
     };
 }

src/main.rs

@@ -2,11 +2,41 @@
 extern crate quicli;
 extern crate ansi_term;
 
-use ansi_term::Color::Yellow;
+use ansi_term::Color::{Green, Red, Yellow};
 use quicli::prelude::*;
+use std::fmt::Display;
+
+pub fn verify<T: PartialEq + Display>(left: T, right: T) {
+    if left == right {
+        println!("{} {} == {}", Green.bold().paint("PASS"), left, right);
+    } else {
+        println!(
+            "{} You submitted {}, but that's not correct!",
+            Red.bold().paint("FAIL"),
+            left
+        );
+        println!("     Please correct your code to make this test pass!");
+    }
+}
+
+pub fn verify_easy<T: PartialEq + Display>(left: T, right: T) {
+    if left == right {
+        println!("{} {} == {}", Green.bold().paint("PASS"), left, right);
+    } else {
+        println!(
+            "{} You submitted {}, but that's not correct!",
+            Red.bold().paint("FAIL"),
+            left
+        );
+        println!("     Expected: {}", right);
+        println!("     Please correct your code to make this test pass!");
+    }
+}
+
+pub fn title(s: &str) {
+    println!("{} {}", Yellow.bold().paint("RUN"), s);
+}
 
-#[macro_use]
-mod macros;
 mod about_variables;
 
 #[derive(Debug, StructOpt)]