From 69ff4a8b2554f4113b759a7935cb611aa13ab9ad Mon Sep 17 00:00:00 2001 From: olivia Date: Tue, 22 May 2018 22:23:22 +0200 Subject: [PATCH] replace macros with more general methods --- src/about_variables.rs | 53 +++++++++++++++++++++--------------------- src/macros.rs | 17 ++++++++++---- src/main.rs | 36 +++++++++++++++++++++++++--- 3 files changed, 72 insertions(+), 34 deletions(-) diff --git a/src/about_variables.rs b/src/about_variables.rs index 6ae4124..b4ebda0 100644 --- a/src/about_variables.rs +++ b/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(); } diff --git a/src/macros.rs b/src/macros.rs index 4bc0871..22c8783 100644 --- a/src/macros.rs +++ b/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!"); } }; } diff --git a/src/main.rs b/src/main.rs index 68b8c9e..133bdf4 100644 --- a/src/main.rs +++ b/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(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(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)]