Week 05 Weekly Exercises

Objectives

Use and understand the strength of Traits for defining common behaviours
Investigate the smart pointers Cell, and RefCell
Introduction to generic programming, trait bounds, and trait objects

Activities To Be Completed

The following is a list of all the markedactivities available to complete this week...

Pointy
Dungeons and Dragons!
Languages!

The following practice activities are optional and are not marked, or required to be completed for the week.

Mitochondria (Investigating the Cell smart pointer)

Preparation

Before attempting the weekly exercises you should re-read the relevant lecture slides and their accompanying examples.

Getting Started

Create a new directory for this week's exercises called lab05, change to this directory, and fetch the provided code for this week by running these commands:

mkdir lab05
cd lab05
6991 fetch lab 05

Or, if you're not working on CSE, you can download the provided code as a tar file.

Exercise:
Pointy

So far in our Rust journey, we've always had to write our types, functions, and methods for a specific type.

For example, we would write a struct that would store two `i32` values, and then we would write a function that would take two `i32` values and return an `i32` value (maybe doing some sort of addition).

This is fine for simple programs, but what if we wanted to write a function that would take two `\text{f32}` values, perform some operation, and then return an `f32` value? We would have to write a new function for that. What if we wanted to write a function that would take two `\text{String}` values, perform the same operation, and then return a `\text{String}` value? We would have to write a new function for that, even though the only thing that changed were the types inputted and outputted to the function!

Suddenly, we have multiple functions that all do the same thing - resulting in a lot of duplicated code, more code to maintain, test and write! There are many ways we could make writing this code easier; we can use generics to solve this problem!

In this exercise you will be writing a generic function, a generic type, and a method on a generic type. You should complete the below tasks in src/lib.rs

First - implement a generic function called first that takes a slice of some type `T`, and returns a shared borrow of first value in the slice. Be sure to use the provided doctests to help you write your function.
Second - modify the given Point struct to be generic. It should be able to store two values of one type T. Be sure to use the provided doctests to help you write your struct.
Third - modify the existing method on the Point struct called distance that takes a second Point and returns the distance between the two points. Modify this method to be only be implemented for Point instances where the type of the x and y values are f32
Finally - create a generic method on the Point struct called new that creates a new Point. This method should take two values of type `T` and return a new Point instance with the given values.
Ideally, your method should return Self, and construct a Self.

The documentation for the traits chapter of the book may be useful.

The documentation for the generics chapter of the book may be useful.

The documentation for the methods chapter of the book may be useful.

The documentation for the slices chapter of the book may be useful.

The documentation for the self keyword may be useful.

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 7 Wednesday 21:00:00.

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

lib.rs

/// Returns the first element of a slice.
/// ```
/// use pointy::first;
/// let list = vec![1, 2, 3];
/// assert_eq!(&1, first(&list));
/// ```
/// 
/// ```
/// use pointy::first;
/// let list = vec!["a", "b", "c"];
/// assert_eq!(&"a", first(&list));
/// ``` 
pub fn first<T>(value: &[T]) -> &T {
    &value[0]
}

/// A generic point struct.
/// 
/// ```
/// use pointy::Point;
/// let point = Point { x: 1, y: 2 };
/// assert_eq!(1, point.x);
/// assert_eq!(2, point.y);
/// ```
/// 
/// ```
/// use pointy::Point;
/// let point = Point { x: 1.0, y: 2.0 };
/// assert_eq!(1.0, point.x);
/// assert_eq!(2.0, point.y);
/// ```
pub struct Point<T> {
    pub x: T,
    pub y: T,
}

impl Point<f32> {
    /// Returns the distance between two points.
    /// ```
    /// use pointy::Point;
    /// let point1 = Point { x: 1.0, y: 2.0 };
    /// let point2 = Point { x: 3.0, y: 4.0 };
    /// assert_eq!(2.828427, point1.distance(&point2));
    /// ```
    /// 
    /// ```
    /// use pointy::Point;
    /// let point1 = Point::new(1.0, 2.0);
    /// assert_eq!(1.0, point1.x);
    /// ```
    pub fn distance(&self, second: &Point<f32>) -> f32 {
        let x = self.x - second.x;
        let y = self.y - second.y;
        (x * x + y * y).sqrt()
    }
} 

impl<T> Point<T> {
    /// Returns a new point.
    /// ```
    /// use pointy::Point;
    /// let point = Point::new(1, 2);
    /// assert_eq!(1, point.x);
    /// assert_eq!(2, point.y);
    /// ```
    pub fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

Exercise:
Dungeons and Dragons!

In this exercise, you will be harnessing the power of traits, in order to emulate a subset of a role playing game (RPG) inspired by dungeons and dragons - dice rolling!

The provided code will handle all of the input parsing using the awesome rustyline crate. You will be modifying the code in die.rs

In this exercise, you will need to complete the following tasks, by modifying the code in die.rs ONLY.

Create a Trait with a single function , that describes the behaviour of getting the value of a roll of a dice/coin.
Implement the trait for Coin (a coin "roll" will either be `1` or `2`).
Implement the trait for Dice (each dice will be a number between 1 and the number of sides on the dice (inclusive) - a D4 for example, has 4 sides).
Add a generic trait bound for the roll function - such that your function accepts any type `T` - where `T` implements your trait!

In order to pass the autotests, you must use the given get_random_value function to generate random values (why might this be?).
You should not touch the code inside main.rs

6991 cargo run
  Finished dev [unoptimized + debuginfo] target(s) in 0.02s
    Running `target/debug/dungeons_and_dragons`
>> d20
You rolled a d20: 7
>> d2
You rolled a d2: 1
>> d10
You rolled a d10: 4
>> d8
You rolled a d8: 3
>> 
Goodbye!

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 7 Wednesday 21:00:00.

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

die.rs

use rand::prelude::*;
use rand_chacha::ChaCha20Rng;
pub enum Die {
    D4,
    D6,
    D8,
    D10,
    D12,
    D20,
}

pub struct Coin;

pub trait Roll {
    fn roll(&self) -> u8;
}

/// Takes in a max value and returns a random number between 1 and max
fn get_random_value(max: u8) -> u8 {
    let mut rng = ChaCha20Rng::seed_from_u64(2);
    rng.gen_range(1..=max)
}


impl Roll for Die {
    fn roll(&self) -> u8 {
        let value = match self {
            Die::D4 => get_random_value(4),
            Die::D6 => get_random_value(6),
            Die::D8 => get_random_value(8),
            Die::D10 => get_random_value(10),
            Die::D12 => get_random_value(12),
            Die::D20 => get_random_value(20),
        };
        value
    }
} 

impl Roll for Coin {
    fn roll(&self) -> u8 {
        let mut rng = ChaCha20Rng::seed_from_u64(2);
        rng.gen_range(1..=2)
    }
} 

//TODO - create a trait that can be used for both die and coin
//      and implement the trait for both die and coin
pub fn roll<T: Roll>(item: T) -> u8 {
    item.roll()
}

main.rs


use rustyline::error::ReadlineError;
use rustyline::{Editor, Result};

mod die;
use die::{Die, roll, Coin};

fn main() -> Result<()> {
    let mut rl = Editor::<()>::new()?;
    loop {
        let readline = rl.readline(">> ");
        match readline {
            Ok(line) => {
                match line.as_str() {
                    "quit" => break Ok(()),
                    // match different die rolls
                    "d2" => println!("You rolled a d2: {}", roll(Coin)),
                    "d4" => println!("You rolled a d4: {}", roll(Die::D4)),
                    "d6" => println!("You rolled a d6: {}", roll(Die::D6)),
                    "d8" => println!("You rolled a d8: {}", roll(Die::D8)),
                    "d10" => println!("You rolled a d10: {}", roll(Die::D10)),
                    "d12" => println!("You rolled a d12: {}", roll(Die::D12)),
                    "d20" => println!("You rolled a d20: {}", roll(Die::D20)),
                    _ => println!("Invalid: '{}'", line),
                }
            },
            Err(ReadlineError::Interrupted) => {
                println!("Goodbye!");
                break Ok(())
            },
            Err(ReadlineError::Eof) => {
                println!("Goodbye!");
                break Ok(())
            },
            Err(err) => {
                println!("Error: {:?}", err);
                break Ok(())
            }
        }
    }
}

Exercise:
Languages!

Objectives

Trait objects
The From trait
Interaction with associate trait types impl Add<Foo> for Bar

Understanding of the above is super useful for the assignment! For example, you might want something like impl Add<Direction> for Player

In this exercise, you will be finishing a quick implementation of a program that uses some basic operations using trait objects.

You've been given a starter crate languages, which consists of the Greeting trait, and three implementations of it for the English, French and Spanish structs.

Your task is to complete the following tasks in main.rs such that it compiles and prints some basic output.

First, implement the From trait, such that you can convert a &str into a Box<dyn Greeting>. You can assume that only valid strings will be given. In a real codebase, you would want to handle errors (maybe by using the TryFrom trait), but for this exercise, you can assume that the input is valid.
Second, finish the implementation of the speak_all_greetings function, such that it prints out the greetings.

    6991 cargo run
    Compiling languages v0.1.0
    Finished dev [unoptimized + debuginfo] target(s) in 0.21s
     Running `target/debug/languages`
John says:
Hello!
Hola!
Jane says:
Bonjour!

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 7 Wednesday 21:00:00.

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

main.rs

struct English;
struct Spanish;
struct French;

trait Greeting {
    fn greet(&self);
}

impl Greeting for English {
    fn greet(&self) {
        println!("Hello!");
    }
}

impl Greeting for Spanish {
    fn greet(&self) {
        println!("Hola!");
    }
}

impl Greeting for French {
    fn greet(&self) {
        println!("Bonjour!");
    }
}

impl From<&str> for Box<dyn Greeting> {
    fn from(language: &str) -> Self {
        match language {
            "English" => Box::new(English),
            "Spanish" => Box::new(Spanish),
            "French" => Box::new(French),
            _ => panic!("Unknown language"),
        }
    }
}

struct Person {
    name: String,
    greetings: Vec<Box<dyn Greeting>>,
}


fn main() {
    // john can speak English and Spanish
    let person = Person {
        name: "John".to_string(),
        greetings: vec!["English".into(), "Spanish".into()],
    };

    speak_all_greetings(&person);

    // jane can speak French
    let person = Person {
        name: "Jane".to_string(),
        greetings: vec!["French".into()],
    };

    speak_all_greetings(&person);
}

fn speak_all_greetings(person: &Person) {
    println!("{} says:", person.name);
    for greeting in &person.greetings {
        greeting.greet();
    }
}

(Optional) Challenge Exercise:
Mitochondria (Investigating the Cell smart pointer)

In the field of biology, the mitochondria is often labelled as the "powerhouse of the cell", that is, it is the organelle that is responsible for how/why the Cell is able to work!
This exercise name hence is mitochondria, as we investigate how rust's std::cell::Cell smart pointer (and it's close relatives) work, and what powers them!

This exercise is a theory exercise, aimed to explore the smart pointers Cell and RefCell. The exercise consists of 10 prompts/questions, in order for you to investigate Cell. Your task is to answer each question!

If you wish to discuss your solution/ask questions - do so on the course forum!

main.rs

fn main() {
    println!("Hello, world!");
}

Submission

When you are finished each exercise make sure you submit your work by running give.

You can run give multiple times.

Don't submit any exercises you haven't attempted.

If you are working at home, you may find it more convenient to upload your work via give's web interface.

The due date for this week's exercises is Week 7 Wednesday 21:00:00.

You cannot obtain marks by e-mailing your code to tutors or lecturers.

Automarking will be run continuously throughout the term, using test cases different to those autotest runs for you. (Hint: do your own testing as well as running autotest.)

After automarking is run you can view your results here or by running this command on a CSE machine:

6991 classrun -sturec