workspace/src/part06.rs

   1 // Rust-101, Part 06: Copy, Lifetimes
   2 // ==================================
   3
   4 // We continue to work on our `BigInt`, so we start by importing what we already established.
   5 use part05::BigInt;
   6
   7 // With `BigInt` being about numbers, we should be able to write a version of `vec_min`
   8 // that computes the minimum of a list of `BigInt`. First, we have to write `min` for `BigInt`.
   9 impl BigInt {
  10     fn min_try1(self, other: Self) -> Self {
  11         debug_assert!(self.test_invariant() && other.test_invariant());
  12         // Now our assumption of having no trailing zeros comes in handy:
  13         // If the lengths of the two numbers differ, we already know which is larger.
  14         if self.data.len() < other.data.len() {
  15             self
  16         } else if self.data.len() > other.data.len() {
  17             other
  18         } else {
  19             // **Exercise 06.1**: Fill in this code.
  20             unimplemented!()
  21         }
  22     }
  23 }
  24
  25 // Now we can write `vec_min`.
  26 fn vec_min(v: &Vec<BigInt>) -> Option<BigInt> {
  27     let mut min: Option<BigInt> = None;
  28     // If `v` is a shared borrowed vector, then the default for iterating over it is to call `iter`, the iterator that borrows the elements.
  29     for e in v {
  30         unimplemented!()
  31     }
  32     min
  33 }
  34
  35 // ## `Copy` types
  36
  37 use part02::{SomethingOrNothing,Something,Nothing};
  38 impl<T: Copy> Copy for SomethingOrNothing<T> {}
  39
  40
  41 // ## Lifetimes
  42
  43 fn head<T>(v: &Vec<T>) -> Option<&T> {
  44     if v.len() > 0 {
  45         unimplemented!()
  46     } else {
  47         None
  48     }
  49 }
  50 // Technically, we are returning a pointer to the first element. But doesn't that mean that callers have to be
  51 // careful? Imagine `head` would be a C++ function, and we would write the following code.
  52 /*
  53   int foo(std::vector<int> v) {
  54     int *first = head(v);
  55     v.push_back(42);
  56     return *first;
  57   }
  58 */
  59 fn rust_foo(mut v: Vec<i32>) -> i32 {
  60     let first: Option<&i32> = head(&v);
  61     /* v.push(42); */
  62     *first.unwrap()
  63 }
  64
  65