interpolate now takes an IntoIterator

src/lib.rs

@@ -82,8 +82,13 @@ impl Sharks {
     /// secret = sharks.recover(&shares);
     /// // Not enough shares to recover secret
     /// assert!(secret.is_err());
-    pub fn recover(&self, shares: &[Share]) -> Result<Vec<u8>, &str> {
-        let shares_x: HashSet<u8> = shares.iter().map(|s| s.x.0).collect();
+    pub fn recover<'a, I, J>(&self, shares: I) -> Result<Vec<u8>, &str>
+    where
+        I: IntoIterator<Item = &'a Share, IntoIter = J>,
+        J: Iterator<Item = &'a Share> + Clone,
+    {
+        let shares = shares.into_iter();
+        let shares_x: HashSet<u8> = shares.clone().map(|s| s.x.0).collect();
 
         if shares_x.len() < self.0 as usize {
             Err("Not enough shares to recover original secret")

src/math.rs

@@ -9,14 +9,25 @@ 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(shares: &[Share]) -> Vec<u8> {
-    (0..shares[0].y.len())
+pub fn interpolate<'a, I, J>(shares: I) -> Vec<u8>
+where
+    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
-                .iter()
+                .clone()
                 .map(|s_i| {
                     shares
-                        .iter()
+                        .clone()
                         .filter(|s_j| s_j.x != s_i.x)
                         .map(|s_j| s_j.x / (s_j.x - s_i.x))
                         .product::<GF256>()