updated some of the examples

Author: BartMassey

addy.rs

@@ -10,7 +10,7 @@ pub trait Numy {
         lhs + rhs
     }
 
-    fn render(self) -> Self::Rendering;
+    fn render(&self) -> Self::Rendering;
 }
 
 struct U64String(String);
@@ -29,15 +29,15 @@ impl std::ops::Add for U64String {
 impl Numy for U64String {
     type Rendering = String;
 
-    fn render(self) -> Self::Rendering {
-        self.0
+    fn render(&self) -> Self::Rendering {
+        self.0.clone()
     }
 }
 
 impl Numy for f64 {
     type Rendering = String;
 
-    fn render(self) -> Self::Rendering {
+    fn render(&self) -> Self::Rendering {
         self.to_string()
     }
 }
@@ -49,11 +49,12 @@ impl Numy for u64 {
         lhs + rhs + 1
     }
 
-    fn render(mut self) -> Self::Rendering {
+    fn render(&self) -> Self::Rendering {
+        let mut value = *self;
         let mut result = Vec::new();
-        while self > 0 {
-            result.push((self % 10) as u8);
-            self /= 10;
+        while value > 0 {
+            result.push((value % 10) as u8);
+            value /= 10;
         }
         result.reverse();
         result

bno-salad.rs

@@ -1,26 +1,26 @@
 // From Blandy & Orendorff's *Programming Rust*
 
-trait Vegetable {
+pub trait Vegetable {
     fn desc(&self) -> &'static str;
 }
 
 #[derive(Clone, Copy)]
-struct Lettuce;
+pub struct Lettuce;
 impl Vegetable for Lettuce {
     fn desc(&self) -> &'static str {
-        "lettuce"
+        self.desc()
     }
 }
 
 #[derive(Clone, Copy)]
-struct Tomato;
+pub struct Tomato;
 impl Vegetable for Tomato {
     fn desc(&self) -> &'static str {
-        "tomato"
+        self.desc()
     }
 }
 
-struct GenericSalad<T: Vegetable> {
+pub struct GenericSalad<T: Vegetable> {
     veggies: Vec<T>,
 }
 
@@ -35,46 +35,102 @@ impl<T: Vegetable> GenericSalad<T> {
         self.veggies.push(v);
     }
 
-    fn display(&self) {
+    pub fn display(&self) {
         for v in &self.veggies {
             println!("{}", v.desc());
         }
     }
 }
 
-struct TraitSalad<'a> {
-    veggies: Vec<&'a dyn Vegetable>,
+pub struct TraitSalad {
+    veggies: Vec<Box<dyn Vegetable>>,
 }
 
-impl<'a> TraitSalad<'a> {
+impl TraitSalad {
     fn new() -> Self {
         TraitSalad {
             veggies: Vec::new(),
         }
     }
 
-    fn add(&mut self, v: &'a dyn Vegetable) {
+    fn add(&mut self, v: Box<dyn Vegetable>) {
         self.veggies.push(v);
     }
 
-    fn display(&self) {
+    pub fn display(&self) {
         for v in &self.veggies {
             println!("{}", v.desc());
         }
     }
 }
 
-fn main() {
+impl Lettuce {
+    fn desc(&self) -> &'static str {
+        "lettuce"
+    }
+}
+
+impl Tomato {
+    fn desc(&self) -> &'static str {
+        "tomato"
+    }
+}
+
+enum SaladVegetable {
+    SaladLettuce,
+    SaladTomato,
+    SaladCucumber,
+}
+use SaladVegetable::*;
+
+pub struct EnumSalad {
+    veggies: Vec<SaladVegetable>,
+}
+
+impl EnumSalad {
+    fn new() -> Self {
+        EnumSalad {
+            veggies: Vec::new(),
+        }
+    }
+
+    fn add(&mut self, v: SaladVegetable) {
+        self.veggies.push(v);
+    }
+
+    pub fn display(&self) {
+        for v in &self.veggies {
+            match v {
+                SaladLettuce => println!("lettuce"),
+                SaladTomato => println!("tomato"),
+                SaladCucumber => println!("cucumber"),
+            }
+        }
+    }
+}
+
+pub fn make_me_a_generic_lettuce_salad<T: Vegetable + Clone>(veggie: T) ->
+    GenericSalad<T>
+{
     let mut generic_salad = GenericSalad::new();
-    for v in vec![Lettuce, Lettuce] {
+    for v in vec![veggie.clone(), veggie.clone()] {
         generic_salad.add(v);
     }
-    generic_salad.display();
-
-    println!();
+    generic_salad
+}
 
+pub fn make_me_a_trait_salad() -> TraitSalad {
     let mut trait_salad = TraitSalad::new();
-    trait_salad.add(&Lettuce);
-    trait_salad.add(&Tomato);
-    trait_salad.display();
+    trait_salad.add(Box::new(Lettuce));
+    trait_salad.add(Box::new(Tomato));
+    trait_salad
+}
+
+pub fn make_me_a_enum_salad() -> EnumSalad {
+    let mut enum_salad = EnumSalad::new();
+    enum_salad.add(SaladLettuce);
+    enum_salad.add(SaladTomato);
+    enum_salad.add(SaladTomato);
+    enum_salad.add(SaladCucumber);
+    enum_salad
 }

matmul.rs

@@ -1,44 +1,49 @@
 use std::ops::Mul;
 
 #[derive(Debug, Clone, Copy)]
-struct Matrix3([[u64;3];3]);
+struct Matrix<const N: usize>([[u64;N];N]);
 
-impl Mul for Matrix3 {
-    type Output = Matrix3;
+impl<const N: usize> Mul for Matrix<N> {
+    type Output = Matrix<N>;
 
-    fn mul(self, Matrix3(rhs): Self) -> Self {
-        let Matrix3(lhs) = self;
-        let mut result = [[0;3];3];
-        for i in 0..3 {
-            for j in 0..3 {
-                for k in 0..3 {
+    fn mul(self, Matrix(rhs): Self) -> Self {
+        let Matrix(lhs) = self;
+        let mut result = [[0;N];N];
+        for i in 0..N {
+            for j in 0..N {
+                for k in 0..N {
                     result[i][k] += lhs[i][j] * rhs[j][k];
                 }
             }
         }
-        Matrix3(result)
+        Matrix(result)
     }
 }
 
-impl PartialEq for Matrix3 {
-    fn eq(&self, rhs: &Matrix3) -> bool {
+impl<const N: usize> PartialEq for Matrix<N> {
+    fn eq(&self, rhs: &Matrix<N>) -> bool {
         self.0 == rhs.0
     }
 }
 
-const TTT: Matrix3 = Matrix3(
+const TTT: Matrix<3> = Matrix(
     [[1,2,3],
      [4,5,6],
      [7,8,9]]
 );
 
-const ID: Matrix3 = Matrix3(
+const ID: Matrix<3> = Matrix(
     [[1,0,0],
      [0,1,0],
      [0,0,1]]
 );
 
-const MAGIC: Matrix3 = Matrix3(
+const ID2: Matrix<2> = Matrix(
+    [[1,0],
+     [0,1]]
+);
+
+const MAGIC: Matrix<3> = Matrix(
     [[6,1,8],
      [7,5,3],
      [2,9,4]]
@@ -48,5 +53,6 @@ fn main() {
     assert_eq!(TTT * ID, TTT);
     assert_eq!(ID * TTT, TTT);
     assert!(TTT * MAGIC != MAGIC * TTT);
+    assert_eq!(ID2 * ID2, ID2);
     println!("{:?}", TTT * TTT);
 }

phantom.rs

@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 struct Hash<T> {
     h: u128,
     p: PhantomData<T>,
@@ -30,7 +30,9 @@ fn main() {
     println!("{:?}", h1);
     let h2 = Hash::hash(1u64);
     println!("{:?}", h2);
+    let h3 = Hash::hash((0i32, 1i32));
+    println!("{:?}", h1);
     // Can't even compare these, since they are of
     // different type.
-    // println!("{}", h1 == h2);
+    println!("{}", h1 == h2);
 }

point.rs

@@ -21,7 +21,7 @@ impl Point {
     }
 
     fn collapse(self) -> i64 {
-        self.x + self.y
+        self.x - self.y
     }
 }
 

top.rs

@@ -22,17 +22,17 @@ impl<T: fmt::Debug> fmt::Debug for Top<'_, T> {
 }
 
 // Can parameterize a function to make it able to take a specified type of data.
-fn make_top<T>(count: usize, order: fn(&T, &T) -> Ordering, vals: &[T]) -> Top<'_, T> {
-    let mut elems: Vec<&T> = vals.iter().collect();
-    elems.sort_by(|&v1, &v2| order(v1, v2));
-    if count < elems.len() {
-        elems.truncate(count);
-    }
-    Top { count, order, elems }
-}
-
 // Must parameterize an impl to match its type.
 impl<'a, T> Top<'a, T> {
+    fn new(count: usize, order: fn(&T, &T) -> Ordering, vals: &[T]) -> Top<'_, T> {
+        let mut elems: Vec<&T> = vals.iter().collect();
+        elems.sort_by(|&v1, &v2| order(v1, v2));
+        if count < elems.len() {
+            elems.truncate(count);
+        }
+        Top { count, order, elems }
+    }
+
     fn update(&mut self, val: &'a T) {
         self.elems.push(val);
         let order = self.order;
@@ -45,9 +45,9 @@ impl<'a, T> Top<'a, T> {
 }
 
 fn main() {
-    let vals = [9, 7, 3, 1, 4, 6, 8, 2, 5];
-    let mut top = make_top(3, |x, y| x.cmp(y), &vals);
+    let vals = ['d', 'b', 'c', 'a'];
+    let mut top = Top::new(3, |x, y| x.cmp(y), &vals);
     println!("{:?}", top);
-    top.update(&0);
+    Top::update(&mut top, &'X');
     println!("{:?}", top);
 }