use generics

Sponsored-by: author

1 files changed, 34 insertions, 28 deletions

diff --git a/src/main.rs b/src/main.rs
index 7fd05af..3d7b329 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,47 +1,53 @@
 fn main() {
-    let mut c = Container::default();
-    c.insert(42);
-    println!("{}", c.contains(42));
-    c.remove(42);
-    println!("{}", c.contains(42));
+    let mut c: Container<String> = Container::default();
+    let foo = String::from("foo");
+    let bar = String::from("bar");
+    c.insert(foo.clone());
+    c.insert(bar.clone());
+    println!("contains foo? {}", c.contains(&foo));
+    println!("len {}", c.len());
+    println!("is_empty {}", c.is_empty());
+
+    c.remove(foo.clone());
+    println!("contains foo? {}", c.contains(&foo));
 }
 
 #[derive(Debug, Default)]
-struct Container {
-    numbers: Vec<i32>,
+struct Container<T: Eq> {
+    values: Vec<T>,
 }
 
-impl Container {
+impl<T: Eq> Container<T> {
     fn len(&self) -> usize {
-        self.numbers.len()
+        self.values.len()
     }
 
     fn is_empty(&self) -> bool {
-        self.numbers.is_empty()
+        self.values.is_empty()
     }
 
-    fn contains(&self, n: i32) -> bool {
-        self.find(n).is_some()
+    fn contains(&self, v: &T) -> bool {
+        self.find(v).is_some()
     }
 
-    fn insert(&mut self, n: i32) {
-        if !self.contains(n) {
-            self.numbers.push(n);
+    fn insert(&mut self, v: T) {
+        if !self.contains(&v) {
+            self.values.push(v);
         }
     }
 
-    fn remove(&mut self, n: i32) -> Option<i32> {
-        if let Some(i) = self.find(n) {
-            self.numbers.remove(i);
-            Some(n)
+    fn remove(&mut self, v: T) -> Option<T> {
+        if let Some(i) = self.find(&v) {
+            self.values.remove(i);
+            Some(v)
         } else {
             None
         }
     }
 
-    fn find(&self, n: i32) -> Option<usize> {
-        for (i, x) in self.numbers.iter().enumerate() {
-            if *x == n {
+    fn find(&self, v: &T) -> Option<usize> {
+        for (i, x) in self.values.iter().enumerate() {
+            if x == v {
                 return Some(i);
             }
         }
@@ -55,7 +61,7 @@ mod test {
 
     #[test]
     fn is_empty_initially() {
-        let c = Container::default();
+        let c: Container<i32> = Container::default();
         assert_eq!(c.len(), 0);
         assert!(c.is_empty());
     }
@@ -63,17 +69,17 @@ mod test {
     #[test]
     fn inserts() {
         let mut c = Container::default();
-        assert!(!c.contains(0));
+        assert!(!c.contains(&0));
         c.insert(0);
         assert_eq!(c.len(), 1);
         assert!(!c.is_empty());
-        assert!(c.contains(0));
+        assert!(c.contains(&0));
     }
 
     #[test]
     fn removes() {
         let mut c = Container::default();
-        assert!(!c.contains(0));
+        assert!(!c.contains(&0));
         c.insert(0);
         c.remove(0);
         assert!(c.is_empty());
@@ -82,12 +88,12 @@ mod test {
     #[test]
     fn inserts_only_once() {
         let mut c = Container::default();
-        assert!(!c.contains(0));
+        assert!(!c.contains(&0));
         c.insert(0);
         c.insert(0);
         assert_eq!(c.len(), 1);
         assert!(!c.is_empty());
-        assert!(c.contains(0));
+        assert!(c.contains(&0));
         c.remove(0);
         assert!(c.is_empty());
     }