28c4030aef6f4200c77b983551c05a0ac0ef52ec
[rust-101.git] / workspace / src / part05.rs
1 // Rust-101, Part 05: Clone
2 // ========================
3
4 // ## Big Numbers
5
6 pub struct BigInt {
7     pub data: Vec<u64>, // least significant digit first, no trailing zeros
8 }
9
10 // Now that we fixed the data representation, we can start implementing methods on it.
11 impl BigInt {
12     pub fn new(x: u64) -> Self {
13         if x == 0 {
14             unimplemented!()
15         } else {
16             unimplemented!()
17         }
18     }
19
20     pub fn test_invariant(&self) -> bool {
21         if self.data.len() == 0 {
22             true
23         } else {
24             unimplemented!()
25         }
26     }
27
28     // We can convert any vector of digits into a number, by removing trailing zeros. The `mut`
29     // declaration for `v` here is just like the one in `let mut ...`: We completely own `v`, but Rust
30     // still asks us to make our intention of modifying it explicit. This `mut` is *not* part of the
31     // type of `from_vec` - the caller has to give up ownership of `v` anyway, so they don't care anymore
32     // what you do to it.
33     // 
34     // **Exercise 05.1**: Implement this function.
35     // 
36     // *Hint*: You can use `pop` to remove the last element of a vector.
37     pub fn from_vec(mut v: Vec<u64>) -> Self {
38         unimplemented!()
39     }
40 }
41
42 // ## Cloning
43 fn clone_demo() {
44     let v = vec![0,1 << 16];
45     let b1 = BigInt::from_vec((&v).clone());
46     let b2 = BigInt::from_vec(v);
47 }
48
49 impl Clone for BigInt {
50     fn clone(&self) -> Self {
51         unimplemented!()
52     }
53 }
54
55 // We can also make the type `SomethingOrNothing<T>` implement `Clone`. 
56 use part02::{SomethingOrNothing,Something,Nothing};
57 impl<T: Clone> Clone for SomethingOrNothing<T> {
58     fn clone(&self) -> Self {
59         unimplemented!()
60     }
61 }
62
63 // **Exercise 05.2**: Write some more functions on `BigInt`. What about a function that returns the number of
64 // digits? The number of non-zero digits? The smallest/largest digit? Of course, these should all take `self` as a shared reference (i.e., in borrowed form).
65
66 // ## Mutation + aliasing considered harmful (part 2)
67 enum Variant {
68     Number(i32),
69     Text(String),
70 }
71 fn work_on_variant(mut var: Variant, text: String) {
72     let mut ptr: &mut i32;
73     match var {
74         Variant::Number(ref mut n) => ptr = n,
75         Variant::Text(_) => return,
76     }
77     /* var = Variant::Text(text); */                                /* BAD! */
78     *ptr = 1337;
79 }
80