Week 07 Weekly Exercises

As a reminder, there are three Fn traits. To quote from the book

1. FnOnce applies to closures that can be called once. All closures implement at least this trait, because all closures can be called. A closure that moves captured values out of its body will only implement FnOnce and none of the other Fn traits, because it can only be called once.
2. FnMut applies to closures that don’t move captured values out of their body, but that might mutate the captured values. These closures can be called more than once.
3. Fn applies to closures that don’t move captured values out of their body and that don’t mutate captured values, as well as closures that capture nothing from their environment. These closures can be called more than once without mutating their environment, which is important in cases such as calling a closure multiple times concurrently.

1. Implement MyOption::map You've been given a MyOption enum that is similar to the standard library's Option enum. Implement the map method on MyOption that takes a closure as an argument and returns a MyOption with the closure applied to the value inside the Some variant. If the MyOption is None, then return None.

You should not use the standard library's Option::map method in your implementation.

2. Implement MyVec::map You've been given a MyVec struct that is a wrapper over a Vec. Implement the map method on MyVec that takes a closure as an argument, and applies that closure to each element in the Vec. The map method should act "in place", and should not return anything.

You should not use the standard library's Vec::map method in your implementation.

3. Implement MyVec::for_each Implement the for_each method on MyVec that takes a closure as an argument, and runs that closure with each element in the Vec The for_each method should not return anything.

You should not use the standard library's Vec::for_each method in your implementation.

When you think your program is working, you can use autotest to run some simple automated tests:

6991 autotest

When you are finished working on this exercise, you must submit your work by running give:

6991 give-crate

The due date for this exercise is Week 8 Wednesday 21:00:00.

Note that this is an individual exercise; the work you submit with give must be entirely your own.

In this exercise, we will be writing a basic rust macro!

Your task is to create a macro called avg that takes in comma seperated expressions, and returns the average of those expressions.

We will make the assumption that the macro is always called with expressions that are all:

• numeric
• can be converted to a numeric type for addition and division

fn main() {
    let a = avg!(1, 2, 3, 4, 5);
    // might expand to

    /*
    let a = {
        let mut sum = 0;
        let mut len = 0;
        sum += 1;
        len += 1;
        sum += 2;
        len += 1;
        sum += 3;
        len += 1;
        sum += 4;
        len += 1;
        sum += 5;
        len += 1;
        sum / len
    };
    */
}

When you are finished working on this exercise, you must submit your work by running give:

6991 give-crate

The due date for this exercise is Week 8 Wednesday 21:00:00.

Note that this is an individual exercise; the work you submit with give must be entirely your own.

The following activity is taken verbatim from exercise 6 of MakroKata - a set of exercises which you can use as a resource to learn how to write macros in rust.

Consider the below macro:

macro_rules! listing_literals {
    (the $e1:literal) => {
        {
            let mut my_vec = Vec::new();
            my_vec.push($e1);
            my_vec
        }
    };
    (the $e1:literal and the $e2:literal) => {
        {
            let mut my_vec = Vec::new();
            my_vec.push($e1);
            my_vec.push($e2);
            my_vec
        }
    };
    (the $e1:literal and the $e2:literal and the $e3:literal) => {
        {
            let mut my_vec = Vec::new();
            my_vec.push($e1);
            my_vec.push($e2);
            my_vec.push($e3);
            my_vec
        }
    }
}

fn main() {
    let vec: Vec<&str> = listing_literals!(the "lion" and the "witch" and the "wardrobe");
    assert_eq!(vec, vec!["lion", "witch", "wardrobe"]);
    let vec: Vec<i32> = listing_literals!(the 9 and the 5);
    assert_eq!(vec, vec![9, 5]);
}

This is very clunky, and involves a large amount of repeated code. Imagine doing this for 10 arguments! What if we could say that we want a variable number of a particular patterns. That would let us say "give me any number of $e:expr tokens, and I'll tell you what to do with them'".

In this task, you will be creating an if_any! macro. If any of the first arguments are true, it should execute the block which will always be the last argument. You may not edit the main function; but once you have completed the exercise, your if_any! macro should expand to look like the following:

fn main() {
    // your macro call: 
    //
    // if_any!(false, 0 == 1, true; {
    //      print_success();
    // })
    //
    // should expand to:
    if (false || 0 == 1 || true) {
        print_success();
    }
}

You can test this yourself, by running:

6991 cargo expand main
fn main() {
    if (false || 0 == 1 || true) {
        print_success();
    }
}

When you are finished working on this exercise, you must submit your work by running give:

6991 give-crate

The due date for this exercise is Week 8 Wednesday 21:00:00.

Note that this is an individual exercise; the work you submit with give must be entirely your own.