Initial commit

src/vector/distinct.rs

@@ -0,0 +1,28 @@
+#[cfg(feature = "vec")]
+pub trait Distinct {
+    fn distinct(&mut self);
+}
+
+#[cfg(feature = "vec")]
+impl<T: PartialEq + Clone> Distinct for Vec<T> {
+    fn distinct(&mut self) {
+        *self = self.iter().fold(vec![], |mut acc, x| {
+            if !acc.contains(x) {
+                acc.push(x.clone());
+            }
+            acc
+        });
+    }
+}
+
+#[cfg(all(test, feature = "vec"))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_distinct() {
+        let mut vec = vec![1, 2, 3, 1, 2, 3];
+        vec.distinct();
+        assert_eq!(vec, vec![1, 2, 3]);
+    }
+}

src/vector/map.rs

@@ -0,0 +1,37 @@
+#[macro_export]
+#[cfg(feature = "vec")]
+macro_rules! map {
+    () => { std::collections::HashMap::new() };
+    ($($k:expr => $v:expr),* $(,)?) => {
+        {
+            let mut temp_map = std::collections::HashMap::new();
+            $(
+                temp_map.insert($k, $v);
+            )*
+            temp_map
+        }
+    };
+}
+
+#[cfg(all(test, feature = "vec"))]
+mod tests {
+    use std::collections::HashMap;
+
+    #[test]
+    fn test_empty_map() {
+        let map: HashMap<usize, usize> = map!();
+        assert_eq!(map.len(), 0);
+    }
+    #[test]
+    fn test_map() {
+        let map = map! {
+            "one" => 1,
+            "two" => 2,
+            "three" => 3,
+        };
+        assert_eq!(map.len(), 3);
+        assert_eq!(map.get("one"), Some(&1));
+        assert_eq!(map.get("two"), Some(&2));
+        assert_eq!(map.get("three"), Some(&3));
+    }
+}

src/vector/matrix.rs

@@ -0,0 +1,33 @@
+#[macro_export]
+#[cfg(feature = "vec")]
+macro_rules! matrix {
+    ($x:expr; $m:expr, $n:expr) => {
+        vec![vec![$x; $n]; $m]
+    };
+    ($($($x:expr),*);*) => {
+        {
+            let mut temp_vec = vec![];
+            {} // Needed to avoid clippy warning
+            $(
+                temp_vec.push(vec![$($x),*]);
+            )*
+            temp_vec
+        }
+    };
+}
+
+#[cfg(all(test, feature = "vec"))]
+mod tests {
+
+    #[test]
+    fn test_matrix() {
+        let matrix = matrix![1, 2, 3; 4, 5, 6; 7, 8, 9];
+        assert_eq!(matrix, vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]);
+    }
+
+    #[test]
+    fn test_matrix_with_single_value() {
+        let matrix = matrix![0; 2, 3];
+        assert_eq!(matrix, vec![vec![0, 0, 0], vec![0, 0, 0]]);
+    }
+}

src/vector/mod.rs

@@ -0,0 +1,4 @@
+pub mod distinct;
+pub mod map;
+pub mod matrix;
+pub mod set;

src/vector/set.rs

@@ -0,0 +1,33 @@
+#[macro_export]
+#[cfg(feature = "vec")]
+macro_rules! set {
+    () => { std::collections::HashSet::new() };
+    ($($x:expr),* $(,)?) => {
+        {
+            let mut temp_set = std::collections::HashSet::new();
+            $(
+                temp_set.insert($x);
+            )*
+            temp_set
+        }
+    };
+}
+
+#[cfg(all(test, feature = "vec"))]
+mod tests {
+    use std::collections::HashSet;
+
+    #[test]
+    fn test_empty_set() {
+        let set: HashSet<usize> = set![];
+        assert_eq!(set.len(), 0);
+    }
+    #[test]
+    fn test_set() {
+        let set = set![1, 2, 3];
+        assert_eq!(set.len(), 3);
+        assert!(set.contains(&1));
+        assert!(set.contains(&2));
+        assert!(set.contains(&3));
+    }
+}