updated exercise files for Rust

Author: vyaspranjal33

rustlings/.gitignore

@@ -1 +1,2 @@
 *.swp
+target/

rustlings/README.md

@@ -1,3 +1,4 @@
+// errors1.rs
 // This function refuses to generate text to be printed on a nametag if
 // you pass it an empty string. It'd be nicer if it explained what the problem
 // was, instead of just sometimes returning `None`. The 2nd test currently

rustlings/error_handling/errors1.rs

@@ -1,3 +1,4 @@
+// errors2.rs
 // Say we're writing a game where you can buy items with tokens. All items cost
 // 5 tokens, and whenever you purchase items there is a processing fee of 1
 // token. A player of the game will type in how many items they want to buy,
@@ -65,7 +66,7 @@ mod tests {
 // One way to handle this is using a `match` statement on
 // `item_quantity.parse::<i32>()` where the cases are `Ok(something)` and
 // `Err(something)`. This pattern is very common in Rust, though, so there's
-// a `try!` macro that does pretty much what you would make that match statement
+// a `?` operator that does pretty much what you would make that match statement
 // do for you! Take a look at this section of the Error Handling chapter:
-// https://doc.rust-lang.org/stable/book/error-handling.html#the-try-macro
-// and give it a `try!`
+// https://doc.rust-lang.org/stable/book/second-edition/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator
+// and give it a try!

rustlings/error_handling/errors2.rs

@@ -1,6 +1,7 @@
+// errors3.rs
 // This is a program that is trying to use a completed version of the
 // `total_cost` function from the previous exercise. It's not working though--
-// we can't call the `try!` macro in the `main()` function! Why not?
+// we can't use the `?` operator in the `main()` function! Why not?
 // What should we do instead? Scroll for hints!
 
 use std::num::ParseIntError;
@@ -9,7 +10,7 @@ fn main() {
     let mut tokens = 100;
     let pretend_user_input = "8";
 
-    let cost = try!(total_cost(pretend_user_input));
+    let cost = total_cost(pretend_user_input)?;
 
     if cost > tokens {
         println!("You can't afford that many!");
@@ -22,7 +23,7 @@ fn main() {
 pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
     let processing_fee = 1;
     let cost_per_item = 5;
-    let qty = try!(item_quantity.parse::<i32>());
+    let qty = item_quantity.parse::<i32>()?;
 
     Ok(qty * cost_per_item + processing_fee)
 }
@@ -44,23 +45,18 @@ pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
 
 
 
-// Since the `try!` macro returns an `Err` early if the thing it's trying to
-// do fails, you can only use the `try!` macro in functions that have a
+// Since the `?` operator returns an `Err` early if the thing it's trying to
+// do fails, you can only use the `?` operator in functions that have a
 // `Result` as their return type.
 
-// The error that you get if you run this code is:
+// Hence the error that you get if you run this code is:
 
 // ```
-// error: mismatched types:
-// expected `()`,
-// found `std::result::Result<_, _>`
+// error[E0277]: the `?` operator can only be used in a function that returns `Result` (or another type that implements `std::ops::Try`)
 // ```
 
-// which is saying that the expected return type of the `main` function is
-// the empty tuple, but we tried to return a `Result`-- and that's happening
-// in the implementation of `try!`. The `main` function never has a return type,
-// so we have to use another way of handling a `Result` within `main`.
+// So we have to use another way of handling a `Result` within `main`.
 
 // Decide what we should do if `pretend_user_input` has a string value that does
-// not parse to an integer, and implement that instead of calling the `try!`
-// macro.
+// not parse to an integer, and implement that instead of using the `?`
+// operator.

rustlings/error_handling/errors3.rs

@@ -1,5 +1,6 @@
+// errorsn.rs
 // This is a bigger error exercise than the previous ones!
-// You can do it!
+// You can do it! :)
 //
 // Edit the `read_and_validate` function so that it compiles and
 // passes the tests... so many things could go wrong!
@@ -114,21 +115,21 @@ impl error::Error for CreationError {
 
 // Next hint: There are three places in `read_and_validate` that we call a
 // function that returns a `Result` (that is, the functions might fail).
-// Wrap those calls in a `try!` macro call so that we return immediately from
+// Apply the `?` operator on those calls so that we return immediately from
 // `read_and_validate` if those function calls fail.
 
-// Another hint: under the hood, the `try!` macro calls `From::from`
+// Another hint: under the hood, the `?` operator calls `From::from`
 // on the error value to convert it to a boxed trait object, a Box<error::Error>,
 // which is polymorphic-- that means that lots of different kinds of errors
 // can be returned from the same function because all errors act the same
 // since they all implement the `error::Error` trait.
 // Check out this section of the book:
-// https://doc.rust-lang.org/stable/book/error-handling.html#standard-library-traits-used-for-error-handling
+// https://doc.rust-lang.org/stable/book/second-edition/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator
 
-// Another another hint: Note that because the `try!` macro returns
+// Another another hint: Note that because the `?` operator returns
 // the *unwrapped* value in the `Ok` case, if we want to return a `Result` from
 // `read_and_validate` for *its* success case, we'll have to rewrap a value
-// that we got from the return value of a `try!` call in an `Ok`-- this will
+// that we got from the return value of a `?`ed call in an `Ok`-- this will
 // look like `Ok(something)`.
 
 // Another another another hint: `Result`s must be "used", that is, you'll

rustlings/error_handling/errorsn.rs

@@ -1,3 +1,4 @@
+// option1.rs
 // This example panics because the second time it calls `pop`, the `vec`
 // is empty, so `pop` returns `None`, and `unwrap` panics if it's called
 // on `None`. Handle this in a more graceful way than calling `unwrap`!

rustlings/error_handling/option1.rs

@@ -1,3 +1,4 @@
+// result1.rs
 // Make this test pass! Scroll down for hints :)
 
 #[derive(PartialEq,Debug)]

rustlings/error_handling/result1.rs

@@ -1,4 +1,5 @@
-// Make me compile!
+// ex1.rs
+// Make me compile! :)
 
 fn main() {
     println();

rustlings/ex1.rs

@@ -1,3 +1,4 @@
+// ex2.rs
 // Make me compile!
 
 fn something() -> String {

rustlings/ex2.rs

@@ -1,3 +1,4 @@
+// ex3.rs
 // Make me compile!
 
 struct Foo {

rustlings/ex3.rs

@@ -1,3 +1,4 @@
+// ex4.rs
 // Make me compile!
 
 fn something() -> Result<i32, std::num::ParseIntError> {

rustlings/ex4.rs

@@ -1,3 +1,4 @@
+// ex5.rs
 // Make me compile!
 
 enum Reaction<'a> {

rustlings/ex5.rs

@@ -0,0 +1,47 @@
+// ex6.rs
+// Make me compile! Scroll down for hints :)
+
+fn main() {
+    let robot_name = Some(String::from("Bors"));
+
+    match robot_name {
+        Some(name) => println!("Found a name: {}", name),
+        None => (),
+    }
+
+    println!("robot_name is: {:?}", robot_name);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Hint: The following two statements are equivalent:
+// let x = &y;
+// let ref x = y;

rustlings/ex6.rs

@@ -1,3 +1,4 @@
+// functions1.rs
 // Make me compile! Scroll down for hints :)
 
 fn main() {

rustlings/functions/functions1.rs

@@ -1,3 +1,4 @@
+// functions2.rs
 // Make me compile! Scroll down for hints :)
 
 fn main() {

rustlings/functions/functions2.rs

@@ -1,3 +1,4 @@
+// functions3.rs
 // Make me compile! Scroll down for hints :)
 
 fn main() {

rustlings/functions/functions3.rs

@@ -1,3 +1,4 @@
+// functions4.rs
 // Make me compile! Scroll down for hints :)
 
 // This store is having a sale where if the price is an even number, you get
@@ -38,6 +39,6 @@ fn is_even(num: i32) -> bool {
 
 
 
-// The error message points to line 10 and says it expects a type after the
+// The error message points to line 12 and says it expects a type after the
 // `->`. This is where the function's return type should be-- take a look at
 // the `is_even` function for an example!

rustlings/functions/functions4.rs

@@ -1,3 +1,4 @@
+// functions5.rs
 // Make me compile! Scroll down for hints :)
 
 fn main() {
@@ -39,5 +40,8 @@ fn square(num: i32) -> i32 {
 
 // This is a really common error that can be fixed by removing one character.
 // It happens because Rust distinguishes between expressions and statements: expressions return
-// a value and statements don't. We want to return a value from the `square` function, but it
-// isn't returning one right now...
+// a value based on its operand, and statements simply return a () type which behaves just like `void` in C/C++ language. 
+// We want to return a value of `i32` type from the `square` function, but it is returning a `()` type...
+// They are not the same. There are two solutions:
+// 1. Add a `return` ahead of `num * num;`
+// 2. remove `;`, make it to be `num * num`

rustlings/functions/functions5.rs

@@ -1,3 +1,5 @@
+// if1.rs
+
 pub fn bigger(a: i32, b:i32) -> i32 {
     // Complete this function to return the bigger number!
     // Do not use:

rustlings/if/if1.rs

@@ -1,3 +1,4 @@
+// macros1.rs
 // Make me compile! Scroll down for hints :)
 
 macro_rules! my_macro {

rustlings/macros/macros1.rs

@@ -1,3 +1,4 @@
+// macros2.rs
 // Make me compile! Scroll down for hints :)
 
 fn main() {

rustlings/macros/macros2.rs

@@ -1,3 +1,4 @@
+// macros3.rs
 // Make me compile, without taking the macro out of the module! Scroll down for hints :)
 
 mod macros {

rustlings/macros/macros3.rs

@@ -1,3 +1,4 @@
+// macros4.rs
 // Make me compile! Scroll down for hints :)
 
 macro_rules! my_macro {

rustlings/macros/macros4.rs

@@ -1,3 +1,4 @@
+// modules1.rs
 // Make me compile! Scroll down for hints :)
 
 mod sausage_factory {

rustlings/modules/modules1.rs

@@ -1,3 +1,4 @@
+// modules2.rs
 // Make me compile! Scroll down for hints :)
 
 mod us_presidential_frontrunners {
@@ -42,6 +43,3 @@ fn main() {
 // its internal structure (the `democrats` and `republicans` modules and
 // associated constants). It's almost there except for one keyword missing for
 // each constant.
-// One more hint: I wish the compiler error, instead of saying "unresolved name
-// `us_presidential_frontrunners::democrat`", could say  "constant
-// `us_presidential_frontrunners::democrat` is private"!

rustlings/modules/modules2.rs

@@ -1,6 +1,7 @@
+// move_semantics1.rs
 // Make me compile! Scroll down for hints :)
 
-pub fn main() {
+fn main() {
     let vec0 = Vec::new();
 
     let vec1 = fill_vec(vec0);
@@ -37,6 +38,6 @@ fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
 
 
 
-// So you've got the "cannot borrow immutable local variable `vec1` as mutable" error on line 10,
-// right? The fix for this is going to be adding one keyword, and the addition is NOT on line 10
+// So you've got the "cannot borrow immutable local variable `vec1` as mutable" error on line 11,
+// right? The fix for this is going to be adding one keyword, and the addition is NOT on line 11
 // where the error is.

rustlings/move_semantics/move_semantics1.rs

@@ -1,6 +1,7 @@
-// Make me compile without changing line 9! Scroll down for hints :)
+// move_semantics2.rs
+// Make me compile without changing line 10! Scroll down for hints :)
 
-pub fn main() {
+fn main() {
     let vec0 = Vec::new();
 
     let mut vec1 = fill_vec(vec0);
@@ -38,8 +39,8 @@ fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
 
 
 // So `vec0` is being *moved* into the function `fill_vec` when we call it on
-// line 6, which means it gets dropped at the end of `fill_vec`, which means we
-// can't use `vec0` again on line 9 (or anywhere else in `main` after the
+// line 7, which means it gets dropped at the end of `fill_vec`, which means we
+// can't use `vec0` again on line 10 (or anywhere else in `main` after the
 // `fill_vec` call for that matter). We could fix this in a few ways, try them
 // all!
 // 1. Make another, separate version of the data that's in `vec0` and pass that

rustlings/move_semantics/move_semantics2.rs

@@ -1,8 +1,9 @@
+// move_semantics3.rs
 // Make me compile without adding new lines-- just changing existing lines!
 // (no lines with multiple semicolons necessary!)
 // Scroll down for hints :)
 
-pub fn main() {
+fn main() {
     let vec0 = Vec::new();
 
     let mut vec1 = fill_vec(vec0);

rustlings/move_semantics/move_semantics3.rs

@@ -1,8 +1,9 @@
+// move_semantics4.rs
 // Refactor this code so that instead of having `vec0` and creating the vector
 // in `fn main`, we instead create it within `fn fill_vec` and transfer the
 // freshly created vector from fill_vec to its caller. Scroll for hints!
 
-pub fn main() {
+fn main() {
     let vec0 = Vec::new();
 
     let mut vec1 = fill_vec(vec0);

rustlings/move_semantics/move_semantics4.rs

@@ -1,3 +1,4 @@
+// primitive_types1.rs
 // Fill in the rest of the line that has code missing!
 // No hints, there's no tricks, just get used to typing these :)
 

rustlings/primitive_types/primitive_types1.rs

@@ -1,3 +1,4 @@
+// primitive_types2.rs
 // Fill in the rest of the line that has code missing!
 // No hints, there's no tricks, just get used to typing these :)
 

rustlings/primitive_types/primitive_types2.rs

@@ -1,3 +1,4 @@
+// primitive_types3.rs
 // Create an array with at least 100 elements in it where the ??? is. 
 // Scroll down for hints!
 
@@ -38,8 +39,9 @@ fn main() {
 
 
 // There's a shorthand to initialize Arrays with a certain size that does not 
-// require you to type in 100 items (but you certainly can if you want!)
-// Check out the Primitive Types -> Arrays section of the book:
-// http://doc.rust-lang.org/stable/book/primitive-types.html#arrays
+// require you to type in 100 items (but you certainly can if you want!).
+// For example, you can do:
+// let array = ["Are we there yet?"; 10];
+
 // Bonus: what are some other things you could have that would return true
 // for `a.len() >= 100`?