simplify generic types, update docs, revert interpolate parameter types

src/field.rs

@@ -58,7 +58,7 @@ const EXP_TABLE: [u8; 512] = [
     0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01, 0x02,
 ];
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, PartialEq, Copy, Clone)]
 pub struct GF256(pub u8);
 
 #[allow(clippy::suspicious_arithmetic_impl)]

src/lib.rs

@@ -64,7 +64,7 @@ impl Sharks {
         math::get_evaluator(polys)
     }
 
-    /// Given a slice of shares, recovers the original secret.
+    /// Given a collection of shares, recovers the original secret.
     /// If the number of distinct shares is less than the minimum threshold an `Err` is returned,
     /// otherwise an `Ok` containing the secret.
     ///
@@ -82,18 +82,28 @@ impl Sharks {
     /// secret = sharks.recover(&shares);
     /// // Not enough shares to recover secret
     /// assert!(secret.is_err());
-    pub fn recover<'a, I, J>(&self, shares: I) -> Result<Vec<u8>, &str>
+    pub fn recover<'a, T>(&self, shares: T) -> Result<Vec<u8>, &str>
     where
-        I: IntoIterator<Item = &'a Share, IntoIter = J>,
+        T: IntoIterator<Item = &'a Share>,
-        J: Iterator<Item = &'a Share> + Clone,
+        T::IntoIter: Iterator<Item = &'a Share>,
     {
-        let shares = shares.into_iter();
+        let (keys, shares) = shares
-        let shares_x: HashSet<u8> = shares.clone().map(|s| s.x.0).collect();
+            .into_iter()
+            .map(|s| {
+                (
+                    s.x.0,
+                    Share {
+                        x: s.x,
+                        y: s.y.clone(),
+                    },
+                )
+            })
+            .unzip::<u8, Share, HashSet<u8>, Vec<Share>>();
 
-        if shares_x.len() < self.0 as usize {
+        if keys.len() < self.0 as usize {
             Err("Not enough shares to recover original secret")
         } else {
-            Ok(math::interpolate(shares))
+            Ok(math::interpolate(shares.as_slice()))
         }
     }
 }

src/math.rs

@@ -9,25 +9,14 @@ use super::share::Share;
 // The expected `shares` argument format is the same as the output by the `get_evaluator´ function.
 // Where each (key, value) pair corresponds to one share, where the key is the `x` and the value is a vector of `y`,
 // where each element corresponds to one of the secret's byte chunks.
-pub fn interpolate<'a, I, J>(shares: I) -> Vec<u8>
+pub fn interpolate(shares: &[Share]) -> Vec<u8> {
-where
+    (0..shares[0].y.len())
-    I: IntoIterator<Item = &'a Share, IntoIter = J>,
-    J: Iterator<Item = &'a Share> + Clone,
-{
-    let shares = shares.into_iter();
-    (0..shares
-        .clone()
-        .peekable()
-        .peek()
-        .expect("There should be at least one share")
-        .y
-        .len())
         .map(|s| {
             shares
-                .clone()
+                .iter()
                 .map(|s_i| {
                     shares
-                        .clone()
+                        .iter()
                         .filter(|s_j| s_j.x != s_i.x)
                         .map(|s_j| s_j.x / (s_j.x - s_i.x))
                         .product::<GF256>()