// I AM NOT DONE

    let out = map.iter().fold(0, |count, val| if val.1 == &value { count + 1 } else { count } );
    out

    let out = collection.iter().fold(0, |count_a, map| count_a + map.iter().fold(0, |count_b, val| if val.1 == &value { count_b + 1 } else { count_b }) );
    out

// I AM NOT DONE

    if num == 0 { 0 } else { (1..=num).fold(1, |acc, elem| acc * elem) }

// I AM NOT DONE

pub fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {}

pub fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
    match (a, b) {
        (_, 0) => Err(DivisionError::DivideByZero),
        (0, _) => Ok(0),
        _ => if a % b == 0 {
            Ok(a / b)
        } else {
            Err(DivisionError::NotDivisible(
                NotDivisibleError {
                    dividend: a,
                    divisor: b
                }
            ))
        }
    }
}

fn result_with_list() -> () {

fn result_with_list() -> Result<Vec<i32>, DivisionError> {

    let division_results = numbers.into_iter().map(|n| divide(n, 27));

    let division_results = numbers.into_iter().map(|n| divide(n, 27)).collect();
    division_results

fn list_of_results() -> () {

fn list_of_results() -> Vec<Result<i32, DivisionError>> {

    let division_results = numbers.into_iter().map(|n| divide(n, 27));

    let division_results = numbers.into_iter().map(|n| divide(n, 27)).collect();
    division_results

// I AM NOT DONE

        Some(first) => ???,

        Some(first) => first.to_uppercase().to_string() + c.as_str(),

    vec![]

    let out = words.iter().map(|x| capitalize_first(x)).collect();
    out

    String::new()

    // let out = words.iter().fold(String::new(), |acc, elem| acc + &capitalize_first(elem));
    let out = words.iter().map(|x| capitalize_first(x)).collect();
    out

//  Make me compile by filling in the `???`s

//  Make me compile by filling in the `Some(&"")`s

// I AM NOT DONE

    let mut my_iterable_fav_fruits = ???;   // TODO: Step 1

    let mut my_iterable_fav_fruits = my_fav_fruits.iter();

    assert_eq!(my_iterable_fav_fruits.next(), ???);     // TODO: Step 2

    assert_eq!(my_iterable_fav_fruits.next(), Some(&"custard apple"));

    assert_eq!(my_iterable_fav_fruits.next(), ???);     // TODO: Step 2.1

    assert_eq!(my_iterable_fav_fruits.next(), Some(&"peach"));

    assert_eq!(my_iterable_fav_fruits.next(), ???);     // TODO: Step 3

    assert_eq!(my_iterable_fav_fruits.next(), None);

// I AM NOT DONE

    Cons(i32, List),

    Cons(i32, Box<List>),

    unimplemented!()

    List::Nil

    unimplemented!()

    List::Cons(0, Box::new(List::Nil))

// I AM NOT DONE

    let shared_numbers = // TODO

    let shared_numbers = Arc::new(numbers);

        let child_numbers = // TODO

        let child_numbers = shared_numbers.clone();