Ces exercices sont construits comme des "puzzles" donnant du code Rust presque correct, mais qui ne compile pas. Le but de chaque exercice est de faire accepter le code au compilateur.

Question 1.

mod printer {
    fn print_test_page() {
        println!("A bunch of stuff no one looks at anyways.");
    }
}

fn main() {
    printer::print_test_page();
}

Question 2.

mod runtime {
    use parallel::RUNTIME as PARALLEL;
    use sequential::RUNTIME as SEQUENTIAL;

    mod sequential {
        pub const RUNTIME: &'static str = "sequential";
    }

    mod parallel {
        pub const RUNTIME: &'static str = "parallel";
    }
}

fn main() {
    println!(
        "Available runtimes: {}, {}",
        runtime::SEQUENTIAL,
        runtime::PARALLEL
    );
}

Question 1.

fn main() {
    quantity = 100;
    println!("Initial quantity: {}", quantity);
}

Question 2.

fn main() {
    let quantity;
    if quantity <= 50 {
        println!("We should restock.");
    }
}

Question 3.

fn main() {
    let quantity = 100;
    println!("Initial quantity: {}", quantity);
    quantity -= 1;
    println!("One item sold; new quantity: {}", quantity);
}

Question 1.

fn main() {
    my_main();
}

Question 2.

fn main() {
    my_main(3);
}

fn my_main(num_iters) {
    for i in 0..num_iters {
        println!("Iteration #{}", i + 1);
    }
}

Question 3.

Trois erreurs à la fois. Je n'étais vraiment pas réveillé en écrivant ce code :)

fn main() {
    println!("Result is {}", my_main());
}

fn my_main(num_iters: u32) -> {
    (0..num_iters).fold(0, |x, y| x + y);
}

Question 1.

trait MyTrait {}

fn use_trait(_: MyTrait) {}

fn main() {}

Question 2.

trait MyTrait {}

impl MyTrait for i32 {}

fn use_impl_box<T: MyTrait>(_: &T) {}

fn use_dyn_box(_: &dyn MyTrait) {}

fn main() {
    let x: i32 = 3;
    let i32_x: &i32 = &x;
    let dyn_x: &dyn MyTrait = &x;
    use_impl_box(i32_x);
    use_impl_box(dyn_x);
    use_dyn_box(i32_x);
    use_dyn_box(dyn_x);
}

Question 1.

fn flatten_ref<'a, 'b>(x: &'a &'b mut u32) -> &'b mut u32 {
    x
}

fn main() {}