Fixes some issues found by clippy (#41)

examples/frame.rs

@@ -17,17 +17,11 @@ fn main() {
 
     println!("** Selection **");
 
-    println!(
-        "by multiple index labels\n{:?}\n",
-        &df.locs(&vec![20, 30, 40])
-    );
-    println!(
-        "by multiple index locations\n{:?}\n",
-        &df.ilocs(&vec![0, 2, 1])
-    );
+    println!("by multiple index labels\n{:?}\n", &df.locs(&[20, 30, 40]));
+    println!("by multiple index locations\n{:?}\n", &df.ilocs(&[0, 2, 1]));
 
     println!("** GroupBy **");
-    let dg = df.groupby(vec!["A", "A", "B", "A", "B"]);
+    let dg = df.groupby(&["A", "A", "B", "A", "B"]);
     println!("get group\n{:?}\n", &dg.get_group(&"A"));
 
     println!("** Reshaping **");

examples/series.rs

@@ -13,14 +13,8 @@ fn main() {
     println!("{:?}\n", &s);
 
     println!("** Selection **");
-    println!(
-        "by multiple index labels\n{:?}\n",
-        &s.locs(&vec![10, 40, 50])
-    );
-    println!(
-        "by multiple index locations\n{:?}\n",
-        &s.ilocs(&vec![2, 3, 4])
-    );
+    println!("by multiple index labels\n{:?}\n", &s.locs(&[10, 40, 50]));
+    println!("by multiple index locations\n{:?}\n", &s.ilocs(&[2, 3, 4]));
 
     println!("** Calculation **");
     println!("elemwise\n{:?}\n", &(&s + 1));
@@ -29,7 +23,7 @@ fn main() {
     println!("histogram\n{:?}\n", s.value_counts());
 
     println!("** Group By **");
-    let sg = s.groupby(vec![1, 1, 1, 2, 2]);
+    let sg = s.groupby(&[1, 1, 1, 2, 2]);
     // println!("{:?}", sg.grouper);
     println!("{:?}\n", sg.get_group(&1));
     println!("{:?}\n", sg.sum());

src/algos/counter.rs

@@ -33,8 +33,8 @@ where
         // sort by value, not using Sorter::sort_by for Vec
         let mut map: BTreeMap<usize, Vec<Cow<T>>> = BTreeMap::new();
 
-        for (ref k, ref c) in self.counts.iter() {
-            let e = map.entry(**c).or_insert(Vec::<Cow<T>>::new());
+        for (k, c) in &self.counts {
+            let e = map.entry(*c).or_insert_with(Vec::<Cow<T>>::new);
             e.push(Cow::Borrowed(k));
         }
 

src/algos/grouper.rs

@@ -24,7 +24,7 @@ where
         let mut map: HashMap<T, Vec<usize>> = HashMap::new();
 
         for (i, k) in key.iter().enumerate() {
-            let e = map.entry(k.clone()).or_insert(Vec::<usize>::new());
+            let e = map.entry(k.clone()).or_insert_with(Vec::<usize>::new);
             e.push(i);
         }
         HashGrouper { groups: map }

src/algos/join.rs

@@ -36,24 +36,21 @@ where
         // keep left order
         for (i, key) in left.iter().enumerate() {
             // ToDo: sort?
-            match map.get(&Cow::Borrowed(key)) {
-                Some(val) => {
-                    indexer.push((*key).clone());
-                    lindexer.push(i);
-                    rindexer.push(*val);
-                }
-                None => {}
+            if let Some(val) = map.get(&Cow::Borrowed(key)) {
+                indexer.push((*key).clone());
+                lindexer.push(i);
+                rindexer.push(*val);
             }
         }
         (indexer, lindexer, rindexer)
     }
 
     fn left(left: &[T], right: &[T]) -> (Vec<T>, Vec<usize>, Vec<usize>) {
-        HashJoin::keep_first(&left, &right)
+        HashJoin::keep_first(left, right)
     }
 
     fn right(left: &[T], right: &[T]) -> (Vec<T>, Vec<usize>, Vec<usize>) {
-        let res = HashJoin::keep_first(&right, &left);
+        let res = HashJoin::keep_first(right, left);
         (res.0, res.2, res.1)
     }
 

src/algos/set.rs

@@ -44,7 +44,7 @@ where
     // Use HashMap to keep the order
 
     // Clone for result Vec
-    let mut res: Vec<T> = a.iter().cloned().collect();
+    let mut res: Vec<T> = a.to_vec();
 
     let set = CowCollections::to_hashset(a);
 

src/frame/aggregation.rs

@@ -133,10 +133,8 @@ where
             Array::Float64Array(nvalues)
         };
 
-        let new_values: Vec<Cow<Array>> = ndf.values
-            .iter()
-            .map(|ref x| Cow::Owned(describe(x)))
-            .collect();
+        let new_values: Vec<Cow<Array>> =
+            ndf.values.iter().map(|x| Cow::Owned(describe(x))).collect();
         DataFrame::from_cow(new_values, Cow::Owned(Indexer::new(new_index)), ndf.columns)
     }
 }

src/frame/formatting.rs

@@ -38,7 +38,7 @@ where
         for (i, label) in str_index.iter().enumerate() {
             let mut row_vec = vec![];
             row_vec.push(label.clone());
-            for column in str_values.iter() {
+            for column in &str_values {
                 row_vec.push(column[i].clone());
             }
             result.push(row_vec.join(" "));

src/frame/mod.rs

@@ -61,7 +61,7 @@ where
         // boudaries are checked in Indexer.reindex
 
         let mut new_values: Vec<Cow<Array>> = Vec::with_capacity(self.columns.len());
-        for current in self.values.iter() {
+        for current in &self.values {
             let new_value = unsafe { current.ilocs_unchecked(locations) };
             new_values.push(Cow::Owned(new_value));
         }
@@ -134,10 +134,10 @@ where
         let columns: Indexer<C> = columns.into();
 
         assert!(values.len() == columns.len(), "Length mismatch!");
-        let values: Vec<Cow<Array>> = values.into_iter().map(|x| Cow::Owned(x)).collect();
+        let values: Vec<Cow<Array>> = values.into_iter().map(Cow::Owned).collect();
 
         let len = index.len();
-        for value in values.iter() {
+        for value in &values {
             assert!(value.len() == len, "Length mismatch!");
         }
         DataFrame {
@@ -161,11 +161,11 @@ where
     }
 
     pub fn dtypes(&self) -> Vec<String> {
-        self.iter().map(|ref x| x.dtype()).collect()
+        self.iter().map(|x| x.dtype()).collect()
     }
 
     pub fn is_numeric(&self) -> Vec<bool> {
-        self.iter().map(|ref x| x.is_numeric()).collect()
+        self.iter().map(|x| x.is_numeric()).collect()
     }
 
     fn get_numeric_data(&'i self) -> DataFrame<'i, 'i, 'i, I, C> {
@@ -180,24 +180,19 @@ where
         self.igets(&indexer)
     }
 
-    fn assert_binop(&self, other: &Self) {
-        assert!(self.index == other.index, "index must be the same!");
-        assert!(self.columns == other.columns, "columns must be the same!");
-    }
-
     pub fn insert(&mut self, values: Array, name: C) {
         assert!(self.len() == values.len(), "Length mismatch!");
 
         self.values.push(Cow::Owned(values));
         self.columns.to_mut().push(name);
     }
 
-    pub fn groupby<G>(&'i self, other: Vec<G>) -> GroupBy<DataFrame<I, C>, G>
+    pub fn groupby<G>(&'i self, other: &[G]) -> GroupBy<DataFrame<I, C>, G>
     where
         G: Clone + Eq + Hash + Ord,
     {
 
-        GroupBy::new(&self, other)
+        GroupBy::new(self, other)
     }
 }
 

src/frame/reshape.rs

@@ -22,7 +22,7 @@ where
 
         let mut new_values: Vec<Cow<Array>> = Vec::with_capacity(self.columns.len());
         for (svalues, ovalues) in self.values.iter().zip(&other.values) {
-            let new_value = svalues.append(&ovalues);
+            let new_value = svalues.append(ovalues);
             new_values.push(Cow::Owned(new_value));
         }
         DataFrame::from_cow(

src/groupby.rs

@@ -16,14 +16,14 @@ where
     D: RowIndex<'a>,
     G: Clone + Eq + Hash + Ord,
 {
-    pub fn new(data: &'a D, indexer: Vec<G>) -> Self {
+    pub fn new(data: &'a D, indexer: &[G]) -> Self {
 
         assert!(
             data.len() == indexer.len(),
             "Series and Indexer length are different"
         );
 
-        let grouper: HashGrouper<G> = HashGrouper::groupby(&indexer);
+        let grouper: HashGrouper<G> = HashGrouper::groupby(indexer);
 
         GroupBy {
             data: data,
@@ -33,7 +33,7 @@ where
 
     pub fn get_group(&self, group: &G) -> D {
         if let Some(locs) = self.grouper.get(group) {
-            self.data.ilocs(&locs)
+            self.data.ilocs(locs)
         } else {
             panic!("Group not found!");
         }

src/indexer/mod.rs

@@ -120,7 +120,7 @@ where
 
     /// Return label locations (Vector) corresponding to given labels (Vector)
     fn get_locs(&self, labels: &[U]) -> Vec<usize> {
-        labels.iter().map(|label| self.get_loc(&label)).collect()
+        labels.iter().map(|label| self.get_loc(label)).collect()
     }
 
     fn init_state(&self) {

src/io/mod.rs

@@ -90,8 +90,8 @@ where
         let mut columns: Vec<String> = Vec::with_capacity(self.values.len() + 1);
         // pad
         // columns.push(Scalar::String("".to_string()));
-        for i in self.columns.values.iter() {
-            let s: String = i.to_string().into();
+        for i in &self.columns.values {
+            let s: String = i.to_string();
             columns.push(s);
         }
         writer.write_record(columns)?;
@@ -102,7 +102,7 @@ where
             // let s: Scalar = self.index.values[i].clone().into();
             // row.push(s);
 
-            for col in self.values.iter() {
+            for col in &self.values {
                 row.push(col.iloc(&i).into());
             }
             writer.write_record(row)?;

src/series/groupby.rs

@@ -36,8 +36,8 @@ where
         let mut new_values: Vec<W> = Vec::with_capacity(self.grouper.len());
 
         let groups = self.groups();
-        for g in groups.iter() {
-            let s = self.get_group(&g);
+        for g in &groups {
+            let s = self.get_group(g);
             new_values.push(func(&s));
         }
         Series::new(new_values, groups)
@@ -130,7 +130,7 @@ mod tests {
         let s = Series::<f64, usize>::from_vec(values);
 
         // Instanciate directly method
-        let sg = GroupBy::<Series<f64, usize>, i64>::new(&s, vec![1, 1, 1, 2, 2, 2]);
+        let sg = GroupBy::<Series<f64, usize>, i64>::new(&s, &[1, 1, 1, 2, 2, 2]);
         assert_eq!(sg.groups().len(), 2);
 
         let s1 = sg.get_group(&1);
@@ -152,7 +152,7 @@ mod tests {
         let index: Vec<i64> = vec![10, 20, 30, 40, 50];
         let s = Series::<i64, i64>::new(values, index);
 
-        let sg = GroupBy::<Series<i64, i64>, i64>::new(&s, vec![1, 1, 1, 2, 2]);
+        let sg = GroupBy::<Series<i64, i64>, i64>::new(&s, &[1, 1, 1, 2, 2]);
 
         let exp: Series<i64, i64> = Series::new(vec![6, 9], vec![1, 2]);
         assert_eq!(sg.sum(), exp);
@@ -172,7 +172,7 @@ mod tests {
         let values: Vec<i64> = vec![1, 2, 3, 4, 5];
         let index: Vec<i64> = vec![10, 20, 30, 40, 50];
         let s = Series::<i64, i64>::new(values, index);
-        let sg = GroupBy::<Series<i64, i64>, &str>::new(&s, vec!["A", "A", "A", "B", "B"]);
+        let sg = GroupBy::<Series<i64, i64>, &str>::new(&s, &["A", "A", "A", "B", "B"]);
 
         let exp: Series<i64, &str> = Series::new(vec![6, 9], vec!["A", "B"]);
         assert_eq!(sg.sum(), exp);

src/series/mod.rs

@@ -60,8 +60,8 @@ where
     }
 
     fn reindex_by_index(&self, locations: &[usize]) -> Self {
-        let new_index = self.index.reindex(&locations);
-        let new_values = unsafe { Indexing::reindex_unchecked(&self.values, &locations) };
+        let new_index = self.index.reindex(locations);
+        let new_values = unsafe { Indexing::reindex_unchecked(&self.values, locations) };
         Series::new(new_values, new_index)
     }
 
@@ -120,11 +120,11 @@ where
         assert!(self.index == other.index, "index must be the same!");
     }
 
-    pub fn groupby<G>(&self, other: Vec<G>) -> GroupBy<Series<V, I>, G>
+    pub fn groupby<G>(&self, other: &[G]) -> GroupBy<Series<V, I>, G>
     where
         G: Clone + Eq + Hash + Ord,
     {
-        GroupBy::new(&self, other)
+        GroupBy::new(self, other)
     }
 }
 

tests/frame_groupby.rs

@@ -16,7 +16,7 @@ fn test_frame_get_group() {
     );
     assert_eq!(df.len(), 5);
 
-    let dg = df.groupby(vec![1, 2, 1, 1, 2]);
+    let dg = df.groupby(&[1, 2, 1, 1, 2]);
     assert_eq!(&dg.groups().len(), &2);
 
     let df1 = dg.get_group(&1);

tests/series_groupby.rs

@@ -9,7 +9,7 @@ fn test_series_get_group() {
     let s = Series::<f64, usize>::from_vec(values);
 
     // Use Series method
-    let sg = s.groupby(vec![1, 1, 1, 2, 2, 2]);
+    let sg = s.groupby(&[1, 1, 1, 2, 2, 2]);
     assert_eq!(sg.groups().len(), 2);
 
     let s1 = sg.get_group(&1);
@@ -27,7 +27,7 @@ fn test_series_agg_sum_integer_grouper() {
     let index: Vec<i64> = vec![10, 20, 30, 40, 50];
     let s = Series::<i64, i64>::new(values, index);
 
-    let sg = s.groupby(vec![1, 1, 1, 2, 2]);
+    let sg = s.groupby(&[1, 1, 1, 2, 2]);
     let sum = sg.sum();
 
     let exp: Series<i64, i64> = Series::new(vec![6, 9], vec![1, 2]);
@@ -39,7 +39,7 @@ fn test_series_agg_sum_str_grouper() {
     let values: Vec<i64> = vec![1, 2, 3, 4, 5];
     let index: Vec<i64> = vec![10, 20, 30, 40, 50];
     let s = Series::<i64, i64>::new(values, index);
-    let sg = s.groupby(vec!["A", "A", "A", "B", "B"]);
+    let sg = s.groupby(&["A", "A", "A", "B", "B"]);
     let sum = sg.sum();
 
     let exp: Series<i64, &str> = Series::new(vec![6, 9], vec!["A", "B"]);
@@ -52,7 +52,7 @@ fn test_series_agg_mean_integer_grouper() {
     let index: Vec<i64> = vec![10, 20, 30, 40, 50];
     let s = Series::<i64, i64>::new(values, index);
 
-    let sg = s.groupby(vec![1, 1, 1, 2, 2]);
+    let sg = s.groupby(&[1, 1, 1, 2, 2]);
     let sum = sg.mean();
 
     let exp: Series<f64, i64> = Series::new(vec![2.0, 4.5], vec![1, 2]);